@vlian/framework 1.0.0

package/dist/core/plugin/PluginSandbox.js

@@ -0,0 +1,125 @@
+/**
+ * 插件沙箱
+ * 用于插件隔离和权限控制
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * 插件权限
+ */ export var PluginPermission = /*#__PURE__*/ function(PluginPermission) {
+    /**
+   * 访问配置
+   */ PluginPermission["ACCESS_CONFIG"] = "access_config";
+    /**
+   * 访问状态管理器
+   */ PluginPermission["ACCESS_STATE_MANAGER"] = "access_state_manager";
+    /**
+   * 访问存储
+   */ PluginPermission["ACCESS_STORAGE"] = "access_storage";
+    /**
+   * 发布事件
+   */ PluginPermission["EMIT_EVENTS"] = "emit_events";
+    /**
+   * 订阅事件
+   */ PluginPermission["SUBSCRIBE_EVENTS"] = "subscribe_events";
+    return PluginPermission;
+}({});
+/**
+ * 插件沙箱
+ */ export class PluginSandbox {
+    /**
+   * 检查权限
+   * 
+   * @param permission - 权限
+   * @returns 是否有权限
+   */ hasPermission(permission) {
+        if (!this.config.strictMode) {
+            return true; // 非严格模式，允许所有权限
+        }
+        return this.permissions.has(permission);
+    }
+    /**
+   * 检查是否可以访问配置键
+   * 
+   * @param key - 配置键
+   * @returns 是否可以访问
+   */ canAccessConfig(key) {
+        if (!this.hasPermission("access_config")) {
+            return false;
+        }
+        if (this.config.configWhitelist && this.config.configWhitelist.length > 0) {
+            return this.config.configWhitelist.includes(key);
+        }
+        return true;
+    }
+    /**
+   * 检查是否可以访问状态作用域
+   * 
+   * @param scope - 状态作用域
+   * @returns 是否可以访问
+   */ canAccessStateScope(scope) {
+        if (!this.hasPermission("access_state_manager")) {
+            return false;
+        }
+        if (this.config.stateScopeWhitelist && this.config.stateScopeWhitelist.length > 0) {
+            return this.config.stateScopeWhitelist.includes(scope);
+        }
+        return true;
+    }
+    /**
+   * 过滤配置（根据白名单）
+   * 
+   * @param config - 完整配置
+   * @returns 过滤后的配置
+   */ filterConfig(config) {
+        if (!this.hasPermission("access_config")) {
+            return {};
+        }
+        if (!this.config.configWhitelist || this.config.configWhitelist.length === 0) {
+            return config;
+        }
+        const filtered = {};
+        for (const key of this.config.configWhitelist){
+            if (key in config) {
+                filtered[key] = config[key];
+            }
+        }
+        return filtered;
+    }
+    /**
+   * 获取沙箱配置
+   */ getConfig() {
+        return {
+            ...this.config
+        };
+    }
+    /**
+   * 更新权限
+   * 
+   * @param permissions - 权限列表
+   */ updatePermissions(permissions) {
+        this.permissions = new Set(permissions);
+        this.config.permissions = permissions;
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        _define_property(this, "permissions", void 0);
+        this.config = {
+            strictMode: true,
+            ...config
+        };
+        this.permissions = new Set(config.permissions || []);
+    }
+}
+
+//# sourceMappingURL=PluginSandbox.js.map

package/dist/core/plugin/PluginSandbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/plugin/PluginSandbox.ts"],"sourcesContent":["/**\n * 插件沙箱\n * 用于插件隔离和权限控制\n */\n\nimport type { StartOptions } from '../types';\n\n/**\n * 插件权限\n */\nexport enum PluginPermission {\n  /**\n   * 访问配置\n   */\n  ACCESS_CONFIG = 'access_config',\n\n  /**\n   * 访问状态管理器\n   */\n  ACCESS_STATE_MANAGER = 'access_state_manager',\n\n  /**\n   * 访问存储\n   */\n  ACCESS_STORAGE = 'access_storage',\n\n  /**\n   * 发布事件\n   */\n  EMIT_EVENTS = 'emit_events',\n\n  /**\n   * 订阅事件\n   */\n  SUBSCRIBE_EVENTS = 'subscribe_events',\n}\n\n/**\n * 插件沙箱配置\n */\nexport interface PluginSandboxConfig {\n  /**\n   * 插件名称\n   */\n  name: string;\n\n  /**\n   * 允许的权限列表\n   */\n  permissions?: PluginPermission[];\n\n  /**\n   * 允许访问的配置键（白名单）\n   */\n  configWhitelist?: string[];\n\n  /**\n   * 允许访问的状态作用域（白名单）\n   */\n  stateScopeWhitelist?: (string | symbol)[];\n\n  /**\n   * 是否启用严格模式（默认true）\n   */\n  strictMode?: boolean;\n}\n\n/**\n * 插件沙箱\n */\nexport class PluginSandbox {\n  private config: PluginSandboxConfig;\n  private permissions: Set<PluginPermission>;\n\n  constructor(config: PluginSandboxConfig) {\n    this.config = {\n      strictMode: true,\n      ...config,\n    };\n    this.permissions = new Set(config.permissions || []);\n  }\n\n  /**\n   * 检查权限\n   * \n   * @param permission - 权限\n   * @returns 是否有权限\n   */\n  hasPermission(permission: PluginPermission): boolean {\n    if (!this.config.strictMode) {\n      return true; // 非严格模式，允许所有权限\n    }\n\n    return this.permissions.has(permission);\n  }\n\n  /**\n   * 检查是否可以访问配置键\n   * \n   * @param key - 配置键\n   * @returns 是否可以访问\n   */\n  canAccessConfig(key: string): boolean {\n    if (!this.hasPermission(PluginPermission.ACCESS_CONFIG)) {\n      return false;\n    }\n\n    if (this.config.configWhitelist && this.config.configWhitelist.length > 0) {\n      return this.config.configWhitelist.includes(key);\n    }\n\n    return true;\n  }\n\n  /**\n   * 检查是否可以访问状态作用域\n   * \n   * @param scope - 状态作用域\n   * @returns 是否可以访问\n   */\n  canAccessStateScope(scope: string | symbol): boolean {\n    if (!this.hasPermission(PluginPermission.ACCESS_STATE_MANAGER)) {\n      return false;\n    }\n\n    if (this.config.stateScopeWhitelist && this.config.stateScopeWhitelist.length > 0) {\n      return this.config.stateScopeWhitelist.includes(scope);\n    }\n\n    return true;\n  }\n\n  /**\n   * 过滤配置（根据白名单）\n   * \n   * @param config - 完整配置\n   * @returns 过滤后的配置\n   */\n  filterConfig(config: StartOptions): Partial<StartOptions> {\n    if (!this.hasPermission(PluginPermission.ACCESS_CONFIG)) {\n      return {};\n    }\n\n    if (!this.config.configWhitelist || this.config.configWhitelist.length === 0) {\n      return config;\n    }\n\n    const filtered: Partial<StartOptions> = {};\n    for (const key of this.config.configWhitelist) {\n      if (key in config) {\n        (filtered as any)[key] = (config as any)[key];\n      }\n    }\n\n    return filtered;\n  }\n\n  /**\n   * 获取沙箱配置\n   */\n  getConfig(): PluginSandboxConfig {\n    return { ...this.config };\n  }\n\n  /**\n   * 更新权限\n   * \n   * @param permissions - 权限列表\n   */\n  updatePermissions(permissions: PluginPermission[]): void {\n    this.permissions = new Set(permissions);\n    this.config.permissions = permissions;\n  }\n}\n"],"names":["PluginPermission","PluginSandbox","hasPermission","permission","config","strictMode","permissions","has","canAccessConfig","key","configWhitelist","length","includes","canAccessStateScope","scope","stateScopeWhitelist","filterConfig","filtered","getConfig","updatePermissions","Set"],"mappings":"AAAA;;;CAGC;;;;;;;;;;;;;AAID;;CAEC,GACD,OAAO,IAAA,AAAKA,0CAAAA;IACV;;GAEC;IAGD;;GAEC;IAGD;;GAEC;IAGD;;GAEC;IAGD;;GAEC;WAvBSA;MAyBX;AAgCD;;CAEC,GACD,OAAO,MAAMC;IAYX;;;;;GAKC,GACDC,cAAcC,UAA4B,EAAW;QACnD,IAAI,CAAC,IAAI,CAACC,MAAM,CAACC,UAAU,EAAE;YAC3B,OAAO,MAAM,eAAe;QAC9B;QAEA,OAAO,IAAI,CAACC,WAAW,CAACC,GAAG,CAACJ;IAC9B;IAEA;;;;;GAKC,GACDK,gBAAgBC,GAAW,EAAW;QACpC,IAAI,CAAC,IAAI,CAACP,aAAa,mBAAkC;YACvD,OAAO;QACT;QAEA,IAAI,IAAI,CAACE,MAAM,CAACM,eAAe,IAAI,IAAI,CAACN,MAAM,CAACM,eAAe,CAACC,MAAM,GAAG,GAAG;YACzE,OAAO,IAAI,CAACP,MAAM,CAACM,eAAe,CAACE,QAAQ,CAACH;QAC9C;QAEA,OAAO;IACT;IAEA;;;;;GAKC,GACDI,oBAAoBC,KAAsB,EAAW;QACnD,IAAI,CAAC,IAAI,CAACZ,aAAa,0BAAyC;YAC9D,OAAO;QACT;QAEA,IAAI,IAAI,CAACE,MAAM,CAACW,mBAAmB,IAAI,IAAI,CAACX,MAAM,CAACW,mBAAmB,CAACJ,MAAM,GAAG,GAAG;YACjF,OAAO,IAAI,CAACP,MAAM,CAACW,mBAAmB,CAACH,QAAQ,CAACE;QAClD;QAEA,OAAO;IACT;IAEA;;;;;GAKC,GACDE,aAAaZ,MAAoB,EAAyB;QACxD,IAAI,CAAC,IAAI,CAACF,aAAa,mBAAkC;YACvD,OAAO,CAAC;QACV;QAEA,IAAI,CAAC,IAAI,CAACE,MAAM,CAACM,eAAe,IAAI,IAAI,CAACN,MAAM,CAACM,eAAe,CAACC,MAAM,KAAK,GAAG;YAC5E,OAAOP;QACT;QAEA,MAAMa,WAAkC,CAAC;QACzC,KAAK,MAAMR,OAAO,IAAI,CAACL,MAAM,CAACM,eAAe,CAAE;YAC7C,IAAID,OAAOL,QAAQ;gBAChBa,QAAgB,CAACR,IAAI,GAAG,AAACL,MAAc,CAACK,IAAI;YAC/C;QACF;QAEA,OAAOQ;IACT;IAEA;;GAEC,GACDC,YAAiC;QAC/B,OAAO;YAAE,GAAG,IAAI,CAACd,MAAM;QAAC;IAC1B;IAEA;;;;GAIC,GACDe,kBAAkBb,WAA+B,EAAQ;QACvD,IAAI,CAACA,WAAW,GAAG,IAAIc,IAAId;QAC3B,IAAI,CAACF,MAAM,CAACE,WAAW,GAAGA;IAC5B;IAlGA,YAAYF,MAA2B,CAAE;QAHzC,uBAAQA,UAAR,KAAA;QACA,uBAAQE,eAAR,KAAA;QAGE,IAAI,CAACF,MAAM,GAAG;YACZC,YAAY;YACZ,GAAGD,MAAM;QACX;QACA,IAAI,CAACE,WAAW,GAAG,IAAIc,IAAIhB,OAAOE,WAAW,IAAI,EAAE;IACrD;AA6FF"}

package/dist/core/plugin.cjs

@@ -0,0 +1,496 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PluginEventBus () {
+        return _PluginEventBus.PluginEventBus;
+    },
+    get PluginManager () {
+        return PluginManager;
+    },
+    get PluginPermission () {
+        return _PluginSandbox.PluginPermission;
+    },
+    get PluginSandbox () {
+        return _PluginSandbox.PluginSandbox;
+    },
+    get pluginEventBus () {
+        return _PluginEventBus.pluginEventBus;
+    },
+    get pluginManager () {
+        return pluginManager;
+    }
+});
+const _PluginSandbox = require("./plugin/PluginSandbox");
+const _PluginEventBus = require("./plugin/PluginEventBus");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let PluginManager = class PluginManager {
+    /**
+   * 注册插件
+   * 
+   * 优化：检查插件依赖是否已注册
+   */ register(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            console.warn(`插件 ${plugin.name} 已存在，将被覆盖`);
+        }
+        // 检查依赖是否已注册
+        if (plugin.dependencies && plugin.dependencies.length > 0) {
+            const missingDeps = plugin.dependencies.filter((dep)=>!this.plugins.has(dep));
+            if (missingDeps.length > 0) {
+                console.warn(`插件 ${plugin.name} 的依赖未注册: ${missingDeps.join(', ')}`);
+            }
+        }
+        this.plugins.set(plugin.name, plugin);
+        this.pluginStatus.set(plugin.name, 'registered');
+        // 创建插件沙箱
+        if (plugin.sandbox) {
+            const sandbox = new _PluginSandbox.PluginSandbox({
+                ...plugin.sandbox,
+                name: plugin.name
+            });
+            this.sandboxes.set(plugin.name, sandbox);
+        } else {
+            // 如果没有配置沙箱，创建默认沙箱（非严格模式）
+            const sandbox = new _PluginSandbox.PluginSandbox({
+                strictMode: false,
+                name: plugin.name
+            });
+            this.sandboxes.set(plugin.name, sandbox);
+        }
+    }
+    /**
+   * 获取插件加载顺序（考虑依赖和优先级）
+   * 
+   * @returns 插件名称数组，按加载顺序排列
+   */ getLoadOrder() {
+        const plugins = Array.from(this.plugins.values());
+        // 按优先级排序
+        const sortedPlugins = plugins.sort((a, b)=>{
+            const priorityA = a.priority ?? 100;
+            const priorityB = b.priority ?? 100;
+            return priorityA - priorityB;
+        });
+        // 构建依赖图并拓扑排序
+        const visited = new Set();
+        const visiting = new Set();
+        const result = [];
+        const visit = (pluginName)=>{
+            if (visiting.has(pluginName)) {
+                console.warn(`检测到循环依赖，涉及插件: ${pluginName}`);
+                return;
+            }
+            if (visited.has(pluginName)) {
+                return;
+            }
+            visiting.add(pluginName);
+            const plugin = this.plugins.get(pluginName);
+            if (plugin?.dependencies) {
+                for (const dep of plugin.dependencies){
+                    visit(dep);
+                }
+            }
+            visiting.delete(pluginName);
+            visited.add(pluginName);
+            result.push(pluginName);
+        };
+        for (const plugin of sortedPlugins){
+            visit(plugin.name);
+        }
+        return result;
+    }
+    /**
+   * 注销插件
+   */ unregister(name) {
+        const plugin = this.plugins.get(name);
+        if (plugin && plugin.destroy) {
+            plugin.destroy();
+        }
+        this.plugins.delete(name);
+        this.sandboxes.delete(name);
+        this.pluginStatus.delete(name);
+        this.pluginLoaders.delete(name);
+    }
+    /**
+   * 动态加载插件（热插拔）
+   * 
+   * @param options - 插件加载选项
+   * @returns 加载的插件
+   */ async loadPlugin(options) {
+        let plugin;
+        if (options.url) {
+            // 从URL加载插件
+            const response = await fetch(options.url);
+            if (!response.ok) {
+                throw new Error(`无法加载插件: ${options.url} (${response.status})`);
+            }
+            const pluginModule = await response.json();
+            plugin = pluginModule.default || pluginModule;
+        } else if (options.modulePath) {
+            // 从模块路径动态导入
+            const pluginModule = await Promise.resolve(options.modulePath).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
+            plugin = pluginModule.default || pluginModule;
+        } else {
+            throw new Error('必须提供 url 或 modulePath');
+        }
+        if (!plugin || !plugin.name) {
+            throw new Error('插件格式无效：必须包含 name 属性');
+        }
+        // 检查插件是否已加载
+        if (this.plugins.has(plugin.name)) {
+            throw new Error(`插件 ${plugin.name} 已加载`);
+        }
+        // 设置加载状态
+        this.pluginStatus.set(plugin.name, 'loading');
+        try {
+            // 注册插件
+            this.register(plugin);
+            // 如果要求立即初始化
+            if (options.initialize && options.initContext && options.startOptions) {
+                await this.initializePlugin(plugin.name, options.startOptions, options.initContext);
+            }
+            return plugin;
+        } catch (error) {
+            this.pluginStatus.delete(plugin.name);
+            throw error;
+        }
+    }
+    /**
+   * 初始化单个插件
+   * 
+   * @param name - 插件名称
+   * @param options - 启动选项
+   * @param context - 初始化上下文
+   */ async initializePlugin(name, options, context) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            throw new Error(`插件 ${name} 未注册`);
+        }
+        const status = this.pluginStatus.get(name);
+        if (status === 'initialized') {
+            return; // 已经初始化
+        }
+        try {
+            const sandbox = this.sandboxes.get(name);
+            if (!sandbox) {
+                throw new Error(`插件 ${name} 的沙箱未找到`);
+            }
+            // 执行初始化钩子
+            if (plugin.init) {
+                const filteredOptions = sandbox.filterConfig(options);
+                await plugin.init(filteredOptions, context, sandbox, _PluginEventBus.pluginEventBus);
+            }
+            this.pluginStatus.set(name, 'initialized');
+        } catch (error) {
+            console.error(`插件 ${name} 初始化失败:`, error);
+            throw error;
+        }
+    }
+    /**
+   * 卸载插件（热插拔）
+   * 
+   * @param name - 插件名称
+   * @param force - 是否强制卸载（即使有依赖）
+   */ async unloadPlugin(name, force = false) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            throw new Error(`插件 ${name} 未加载`);
+        }
+        // 检查是否有其他插件依赖此插件
+        if (!force) {
+            const dependents = Array.from(this.plugins.values()).filter((p)=>p.dependencies && p.dependencies.includes(name));
+            if (dependents.length > 0) {
+                throw new Error(`无法卸载插件 ${name}，以下插件依赖它: ${dependents.map((p)=>p.name).join(', ')}`);
+            }
+        }
+        // 执行销毁钩子
+        if (plugin.destroy) {
+            try {
+                await plugin.destroy();
+            } catch (error) {
+                console.error(`插件 ${name} 的 destroy 钩子执行失败:`, error);
+            }
+        }
+        // 从事件总线移除相关监听器（如果有）
+        // 注意：事件总线是全局的，这里只移除插件相关的事件
+        // 实际实现可能需要更细粒度的控制
+        // 清理插件
+        this.unregister(name);
+        this.pluginStatus.set(name, 'destroyed');
+    }
+    /**
+   * 检查插件是否可以热加载
+   * 
+   * @param plugin - 插件
+   * @returns 是否可以热加载
+   */ canHotLoad(plugin) {
+        // 检查依赖是否都已加载
+        if (plugin.dependencies && plugin.dependencies.length > 0) {
+            const missingDeps = plugin.dependencies.filter((dep)=>!this.plugins.has(dep));
+            if (missingDeps.length > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+   * 注册插件加载器（用于延迟加载）
+   * 
+   * @param name - 插件名称
+   * @param loader - 加载器函数
+   */ registerLoader(name, loader) {
+        this.pluginLoaders.set(name, loader);
+    }
+    /**
+   * 使用加载器加载插件
+   * 
+   * @param name - 插件名称
+   * @param options - 加载选项
+   * @returns 加载的插件
+   */ async loadPluginByLoader(name, options) {
+        const loader = this.pluginLoaders.get(name);
+        if (!loader) {
+            throw new Error(`插件 ${name} 的加载器未注册`);
+        }
+        const plugin = await loader();
+        if (!plugin || !plugin.name) {
+            throw new Error('插件格式无效：必须包含 name 属性');
+        }
+        if (plugin.name !== name) {
+            throw new Error(`插件名称不匹配: 期望 ${name}，实际 ${plugin.name}`);
+        }
+        // 检查插件是否已加载
+        if (this.plugins.has(plugin.name)) {
+            return this.plugins.get(plugin.name);
+        }
+        // 设置加载状态
+        this.pluginStatus.set(plugin.name, 'loading');
+        try {
+            // 注册插件
+            this.register(plugin);
+            // 如果要求立即初始化
+            if (options?.initialize && options.initContext && options.startOptions) {
+                await this.initializePlugin(plugin.name, options.startOptions, options.initContext);
+            }
+            return plugin;
+        } catch (error) {
+            this.pluginStatus.delete(plugin.name);
+            throw error;
+        }
+    }
+    /**
+   * 获取插件
+   */ get(name) {
+        return this.plugins.get(name);
+    }
+    /**
+   * 获取所有插件
+   */ getAll() {
+        return Array.from(this.plugins.values());
+    }
+    /**
+   * 执行初始化前钩子
+   * 
+   * 优化：按依赖顺序执行
+   */ async executeBeforeInit(options) {
+        const loadOrder = this.getLoadOrder();
+        for (const pluginName of loadOrder){
+            const plugin = this.plugins.get(pluginName);
+            if (!plugin || !plugin.beforeInit) {
+                continue;
+            }
+            try {
+                const sandbox = this.sandboxes.get(plugin.name);
+                if (!sandbox) {
+                    console.warn(`插件 ${plugin.name} 的沙箱未找到`);
+                    continue;
+                }
+                // 根据沙箱配置过滤选项
+                const filteredOptions = sandbox.filterConfig(options);
+                await plugin.beforeInit(filteredOptions, sandbox, _PluginEventBus.pluginEventBus);
+            } catch (error) {
+                console.error(`插件 ${plugin.name} 的 beforeInit 钩子执行失败:`, error);
+            }
+        }
+    }
+    /**
+   * 执行初始化钩子
+   * 
+   * 优化：按依赖顺序执行，并更新插件状态
+   */ async executeInit(options, context) {
+        const loadOrder = this.getLoadOrder();
+        for (const pluginName of loadOrder){
+            const plugin = this.plugins.get(pluginName);
+            if (!plugin || !plugin.init) {
+                continue;
+            }
+            try {
+                const sandbox = this.sandboxes.get(plugin.name);
+                if (!sandbox) {
+                    console.warn(`插件 ${plugin.name} 的沙箱未找到`);
+                    continue;
+                }
+                // 根据沙箱配置过滤选项
+                const filteredOptions = sandbox.filterConfig(options);
+                await plugin.init(filteredOptions, context, sandbox, _PluginEventBus.pluginEventBus);
+                this.pluginStatus.set(plugin.name, 'initialized');
+            } catch (error) {
+                console.error(`插件 ${plugin.name} 的 init 钩子执行失败:`, error);
+            }
+        }
+    }
+    /**
+   * 执行初始化后钩子
+   * 
+   * 优化：按依赖顺序执行（逆序，确保依赖插件先执行）
+   */ async executeAfterInit(options, context) {
+        const loadOrder = this.getLoadOrder();
+        // 逆序执行，确保依赖插件先执行
+        const reverseOrder = [
+            ...loadOrder
+        ].reverse();
+        for (const pluginName of reverseOrder){
+            const plugin = this.plugins.get(pluginName);
+            if (!plugin || !plugin.afterInit) {
+                continue;
+            }
+            try {
+                const sandbox = this.sandboxes.get(plugin.name);
+                if (!sandbox) {
+                    console.warn(`插件 ${plugin.name} 的沙箱未找到`);
+                    continue;
+                }
+                // 根据沙箱配置过滤选项
+                const filteredOptions = sandbox.filterConfig(options);
+                await plugin.afterInit(filteredOptions, context, sandbox, _PluginEventBus.pluginEventBus);
+            } catch (error) {
+                console.error(`插件 ${plugin.name} 的 afterInit 钩子执行失败:`, error);
+            }
+        }
+    }
+    /**
+   * 获取插件状态
+   * 
+   * @param name - 插件名称
+   * @returns 插件状态
+   */ getPluginStatus(name) {
+        return this.pluginStatus.get(name);
+    }
+    /**
+   * 检查插件是否已加载
+   * 
+   * @param name - 插件名称
+   * @returns 是否已加载
+   */ isLoaded(name) {
+        return this.plugins.has(name);
+    }
+    /**
+   * 获取已加载的插件列表
+   * 
+   * @returns 插件名称数组
+   */ getLoadedPlugins() {
+        return Array.from(this.plugins.keys());
+    }
+    /**
+   * 获取所有插件状态
+   * 
+   * @returns 插件状态映射
+   */ getAllPluginStatus() {
+        return new Map(this.pluginStatus);
+    }
+    /**
+   * 获取插件沙箱
+   * 
+   * @param name - 插件名称
+   * @returns 插件沙箱或undefined
+   */ getSandbox(name) {
+        return this.sandboxes.get(name);
+    }
+    /**
+   * 获取事件总线
+   */ getEventBus() {
+        return _PluginEventBus.pluginEventBus;
+    }
+    /**
+   * 销毁所有插件
+   */ async destroyAll() {
+        for (const plugin of this.plugins.values()){
+            if (plugin.destroy) {
+                try {
+                    await plugin.destroy();
+                } catch (error) {
+                    console.error(`插件 ${plugin.name} 的 destroy 钩子执行失败:`, error);
+                }
+            }
+        }
+        this.plugins.clear();
+    }
+    constructor(){
+        _define_property(this, "plugins", new Map());
+        _define_property(this, "sandboxes", new Map());
+        _define_property(this, "pluginStatus", new Map());
+        _define_property(this, "pluginLoaders", new Map());
+    }
+};
+const pluginManager = new PluginManager();
+
+//# sourceMappingURL=plugin.js.map