refactor(editor): 提取行为树编辑器为独立包并重构编辑器架构 (#216)

* refactor(editor): 提取行为树编辑器为独立包并重构编辑器架构

* feat(editor): 添加插件市场功能

* feat(editor): 重构插件市场以支持版本管理和ZIP打包

* feat(editor): 重构插件发布流程并修复React渲染警告

* fix(plugin): 修复插件发布和市场的路径不一致问题

* feat: 重构插件发布流程并添加插件删除功能

* fix(editor): 完善插件删除功能并修复多个关键问题

* fix(auth): 修复自动登录与手动登录的竞态条件问题

* feat(editor): 重构插件管理流程

* feat(editor): 支持 ZIP 文件直接发布插件

- 新增 PluginSourceParser 解析插件源
- 重构发布流程支持文件夹和 ZIP 两种方式
- 优化发布向导 UI

* feat(editor): 插件市场支持多版本安装

- 插件解压到项目 plugins 目录
- 新增 Tauri 后端安装/卸载命令
- 支持选择任意版本安装
- 修复打包逻辑，保留完整 dist 目录结构

* feat(editor): 个人中心支持多版本管理

- 合并同一插件的不同版本
- 添加版本历史展开/折叠功能
- 禁止有待审核 PR 时更新插件

* fix(editor): 修复 InspectorRegistry 服务注册

- InspectorRegistry 实现 IService 接口
- 注册到 Core.services 供插件使用

* feat(behavior-tree-editor): 完善插件注册和文件操作

- 添加文件创建模板和操作处理器
- 实现右键菜单创建行为树功能
- 修复文件读取权限问题（使用 Tauri 命令）
- 添加 BehaviorTreeEditorPanel 组件
- 修复 rollup 配置支持动态导入

* feat(plugin): 完善插件构建和发布流程

* fix(behavior-tree-editor): 完整恢复编辑器并修复 Toast 集成

* fix(behavior-tree-editor): 修复节点选中、连线跟随和文件加载问题并优化性能

* fix(behavior-tree-editor): 修复端口连接失败问题并优化连线样式

* refactor(behavior-tree-editor): 移除调试面板功能简化代码结构

* refactor(behavior-tree-editor): 清理冗余代码合并重复逻辑

* feat(behavior-tree-editor): 完善编辑器核心功能增强扩展性

* fix(lint): 修复ESLint错误确保CI通过

* refactor(behavior-tree-editor): 优化编辑器工具栏和编译器功能

* refactor(behavior-tree-editor): 清理技术债务，优化代码质量

* fix(editor-app): 修复字符串替换安全问题

packages/editor-app/src/core/bootstrap/EditorBootstrap.ts

@@ -0,0 +1,58 @@
+import 'reflect-metadata';
+import { Core } from '@esengine/ecs-framework';
+import { singleton } from 'tsyringe';
+import { DIContainer, globalContainer } from '../di/DIContainer';
+import { EditorEventBus } from '../events/EditorEventBus';
+import { CommandRegistry } from '../commands/CommandRegistry';
+import { PanelRegistry } from '../commands/PanelRegistry';
+
+export interface EditorContext {
+    container: DIContainer;
+    eventBus: EditorEventBus;
+    commands: CommandRegistry;
+    panels: PanelRegistry;
+    scene: Core;
+}
+
+@singleton()
+export class EditorBootstrap {
+    private initialized = false;
+
+    async initialize(): Promise<EditorContext> {
+        if (this.initialized) {
+            throw new Error('EditorBootstrap has already been initialized');
+        }
+
+        console.log('[EditorBootstrap] Starting editor initialization...');
+
+        const scene = await this.createScene();
+        console.log('[EditorBootstrap] Scene created');
+
+        const container = globalContainer;
+
+        const eventBus = container.resolve(EditorEventBus);
+        console.log('[EditorBootstrap] EventBus initialized');
+
+        const commands = container.resolve(CommandRegistry);
+        console.log('[EditorBootstrap] CommandRegistry initialized');
+
+        const panels = container.resolve(PanelRegistry);
+        console.log('[EditorBootstrap] PanelRegistry initialized');
+
+        this.initialized = true;
+        console.log('[EditorBootstrap] Editor initialized successfully');
+
+        return {
+            container,
+            eventBus,
+            commands,
+            panels,
+            scene
+        };
+    }
+
+    private async createScene(): Promise<Core> {
+        const scene = await Core.create();
+        return scene;
+    }
+}

packages/editor-app/src/core/bootstrap/index.ts

@@ -0,0 +1 @@
+export * from './EditorBootstrap';

packages/editor-app/src/core/commands/CommandRegistry.ts

@@ -0,0 +1,57 @@
+import { singleton } from 'tsyringe';
+import type { ICommand, ICommandRegistry, KeyBinding } from '../interfaces/ICommandRegistry';
+
+@singleton()
+export class CommandRegistry implements ICommandRegistry {
+    private commands = new Map<string, ICommand>();
+
+    register(command: ICommand): void {
+        if (this.commands.has(command.id)) {
+            console.warn(`Command ${command.id} is already registered. Overwriting.`);
+        }
+        this.commands.set(command.id, command);
+    }
+
+    unregister(commandId: string): void {
+        this.commands.delete(commandId);
+    }
+
+    async execute(commandId: string, context?: unknown): Promise<void> {
+        const command = this.commands.get(commandId);
+        if (!command) {
+            throw new Error(`Command ${commandId} not found`);
+        }
+
+        if (command.when && !command.when()) {
+            console.warn(`Command ${commandId} cannot be executed (when clause failed)`);
+            return;
+        }
+
+        try {
+            await command.execute(context);
+        } catch (error) {
+            console.error(`Error executing command ${commandId}:`, error);
+            throw error;
+        }
+    }
+
+    getCommand(commandId: string): ICommand | undefined {
+        return this.commands.get(commandId);
+    }
+
+    getCommands(): ICommand[] {
+        return Array.from(this.commands.values());
+    }
+
+    getKeybindings(): Array<{ command: ICommand; keybinding: KeyBinding }> {
+        const bindings: Array<{ command: ICommand; keybinding: KeyBinding }> = [];
+
+        for (const command of this.commands.values()) {
+            if (command.keybinding) {
+                bindings.push({ command, keybinding: command.keybinding });
+            }
+        }
+
+        return bindings;
+    }
+}

packages/editor-app/src/core/commands/PanelRegistry.ts

@@ -0,0 +1,34 @@
+import { singleton } from 'tsyringe';
+import type { IPanelRegistry, PanelDescriptor } from '../interfaces/IPanelRegistry';
+
+@singleton()
+export class PanelRegistry implements IPanelRegistry {
+    private panels = new Map<string, PanelDescriptor>();
+
+    register(panel: PanelDescriptor): void {
+        if (this.panels.has(panel.id)) {
+            console.warn(`Panel ${panel.id} is already registered. Overwriting.`);
+        }
+        this.panels.set(panel.id, panel);
+    }
+
+    unregister(panelId: string): void {
+        this.panels.delete(panelId);
+    }
+
+    getPanel(panelId: string): PanelDescriptor | undefined {
+        return this.panels.get(panelId);
+    }
+
+    getPanels(category?: string): PanelDescriptor[] {
+        const allPanels = Array.from(this.panels.values());
+
+        if (!category) {
+            return allPanels.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        }
+
+        return allPanels
+            .filter(panel => panel.category === category)
+            .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+}

packages/editor-app/src/core/commands/index.ts

@@ -0,0 +1,2 @@
+export * from './CommandRegistry';
+export * from './PanelRegistry';

packages/editor-app/src/core/di/DIContainer.ts

@@ -0,0 +1,52 @@
+import 'reflect-metadata';
+import { container, DependencyContainer, InjectionToken, Lifecycle } from 'tsyringe';
+
+export class DIContainer {
+    private readonly container: DependencyContainer;
+
+    constructor(parent?: DependencyContainer) {
+        this.container = parent ? parent.createChildContainer() : container;
+    }
+
+    registerSingleton<T>(token: InjectionToken<T>, implementation?: new (...args: unknown[]) => T): void {
+        if (implementation) {
+            this.container.register(token, { useClass: implementation }, { lifecycle: Lifecycle.Singleton });
+        } else {
+            this.container.registerSingleton(token as new (...args: unknown[]) => T);
+        }
+    }
+
+    registerInstance<T>(token: InjectionToken<T>, instance: T): void {
+        this.container.registerInstance(token, instance);
+    }
+
+    registerTransient<T>(token: InjectionToken<T>, implementation: new (...args: unknown[]) => T): void {
+        this.container.register(token, { useClass: implementation }, { lifecycle: Lifecycle.Transient });
+    }
+
+    registerFactory<T>(token: InjectionToken<T>, factory: (container: DependencyContainer) => T): void {
+        this.container.register(token, { useFactory: factory });
+    }
+
+    resolve<T>(token: InjectionToken<T>): T {
+        return this.container.resolve(token);
+    }
+
+    isRegistered<T>(token: InjectionToken<T>): boolean {
+        return this.container.isRegistered(token);
+    }
+
+    createChild(): DIContainer {
+        return new DIContainer(this.container);
+    }
+
+    getNativeContainer(): DependencyContainer {
+        return this.container;
+    }
+
+    dispose(): void {
+        this.container.clearInstances();
+    }
+}
+
+export const globalContainer = new DIContainer();

packages/editor-app/src/core/events/EditorEventBus.ts

@@ -0,0 +1,7 @@
+import { singleton } from 'tsyringe';
+import { TypedEventBus } from './TypedEventBus';
+import type { EditorEventMap } from './EditorEventMap';
+
+@singleton()
+export class EditorEventBus extends TypedEventBus<EditorEventMap> {
+}

packages/editor-app/src/core/events/EditorEventMap.ts

@@ -0,0 +1,98 @@
+import type { Entity, Component } from '@esengine/ecs-framework';
+import type { Node } from '@esengine/behavior-tree-editor';
+
+export interface PluginEvent {
+    name: string;
+    category?: string;
+}
+
+export interface EntityEvent {
+    entity: Entity;
+}
+
+export interface ComponentEvent {
+    entity: Entity;
+    component: Component;
+}
+
+export interface ComponentPropertyChangedEvent {
+    entity: Entity;
+    component: Component;
+    property: string;
+    value: unknown;
+}
+
+export interface AssetFileEvent {
+    path: string;
+    type?: string;
+}
+
+export interface BehaviorTreeNodeEvent {
+    node: Node;
+}
+
+export interface BehaviorTreeLoadFileEvent {
+    filePath: string;
+}
+
+export interface DynamicPanelEvent {
+    panelId: string;
+    data?: unknown;
+}
+
+export interface UIWindowEvent {
+    windowId: string;
+    data?: unknown;
+}
+
+export interface FullscreenEvent {
+    fullscreen: boolean;
+}
+
+export interface LocaleChangedEvent {
+    locale: string;
+}
+
+export interface NotificationEvent {
+    type: 'success' | 'error' | 'warning' | 'info';
+    message: string;
+    duration?: number;
+}
+
+export interface SceneEvent {
+    scenePath?: string;
+}
+
+export interface EditorEventMap extends Record<string, unknown> {
+    'plugin:installed': PluginEvent;
+    'plugin:enabled': PluginEvent;
+    'plugin:disabled': PluginEvent;
+
+    'entity:selected': EntityEvent;
+    'remote-entity:selected': EntityEvent;
+    'entity:added': EntityEvent;
+    'entity:removed': EntityEvent;
+    'entities:cleared': Record<string, never>;
+
+    'component:added': ComponentEvent;
+    'component:removed': ComponentEvent;
+    'component:property:changed': ComponentPropertyChangedEvent;
+
+    'asset:reveal': AssetFileEvent;
+    'asset-file:selected': AssetFileEvent;
+
+    'behavior-tree:node-selected': BehaviorTreeNodeEvent;
+    'behavior-tree:load-file': BehaviorTreeLoadFileEvent;
+
+    'dynamic-panel:open': DynamicPanelEvent;
+    'ui:openWindow': UIWindowEvent;
+    'editor:fullscreen': FullscreenEvent;
+
+    'locale:changed': LocaleChangedEvent;
+    'notification:show': NotificationEvent;
+
+    'scene:loaded': SceneEvent;
+    'scene:new': SceneEvent;
+    'scene:saved': SceneEvent;
+    'scene:modified': SceneEvent;
+}

packages/editor-app/src/core/events/TypedEventBus.ts

@@ -0,0 +1,57 @@
+import { Subject, Observable, Subscription } from 'rxjs';
+import { singleton } from 'tsyringe';
+import type { IEventBus, Unsubscribe } from '../interfaces/IEventBus';
+
+@singleton()
+export class TypedEventBus<TEvents = Record<string, unknown>> implements IEventBus<TEvents> {
+    private subjects = new Map<keyof TEvents, Subject<TEvents[keyof TEvents]>>();
+    private subscriptions: Subscription[] = [];
+
+    async publish<K extends keyof TEvents>(topic: K, data: TEvents[K]): Promise<void> {
+        const subject = this.getSubject(topic);
+        subject.next(data);
+    }
+
+    subscribe<K extends keyof TEvents>(
+        topic: K,
+        handler: (data: TEvents[K]) => void | Promise<void>
+    ): Unsubscribe {
+        const subscription = this.observe(topic).subscribe(async (data) => {
+            try {
+                await handler(data);
+            } catch (error) {
+                console.error(`Error in event handler for topic ${String(topic)}:`, error);
+            }
+        });
+
+        this.subscriptions.push(subscription);
+
+        return () => {
+            subscription.unsubscribe();
+            const index = this.subscriptions.indexOf(subscription);
+            if (index !== -1) {
+                this.subscriptions.splice(index, 1);
+            }
+        };
+    }
+
+    observe<K extends keyof TEvents>(topic: K): Observable<TEvents[K]> {
+        return this.getSubject(topic).asObservable() as Observable<TEvents[K]>;
+    }
+
+    dispose(): void {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+        this.subscriptions = [];
+        this.subjects.forEach(subject => subject.complete());
+        this.subjects.clear();
+    }
+
+    private getSubject<K extends keyof TEvents>(topic: K): Subject<TEvents[K]> {
+        let subject = this.subjects.get(topic) as Subject<TEvents[K]> | undefined;
+        if (!subject) {
+            subject = new Subject<TEvents[K]>();
+            this.subjects.set(topic, subject as unknown as Subject<TEvents[keyof TEvents]>);
+        }
+        return subject;
+    }
+}

packages/editor-app/src/core/events/index.ts

@@ -0,0 +1,3 @@
+export * from './EditorEventMap';
+export * from './TypedEventBus';
+export * from './EditorEventBus';

packages/editor-app/src/core/index.ts

@@ -0,0 +1,5 @@
+export * from './interfaces';
+export * from './di/DIContainer';
+export * from './events';
+export * from './commands';
+export * from './bootstrap';

packages/editor-app/src/core/interfaces/ICommandRegistry.ts

@@ -0,0 +1,25 @@
+export interface KeyBinding {
+    key: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}
+
+export interface ICommand {
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: string;
+    readonly keybinding?: KeyBinding;
+    readonly when?: () => boolean;
+    execute(context?: unknown): void | Promise<void>;
+}
+
+export interface ICommandRegistry {
+    register(command: ICommand): void;
+    unregister(commandId: string): void;
+    execute(commandId: string, context?: unknown): Promise<void>;
+    getCommand(commandId: string): ICommand | undefined;
+    getCommands(): ICommand[];
+    getKeybindings(): Array<{ command: ICommand; keybinding: KeyBinding }>;
+}

packages/editor-app/src/core/interfaces/IEventBus.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+
+export type Unsubscribe = () => void;
+
+export interface IEventBus<TEvents = Record<string, unknown>> {
+    publish<K extends keyof TEvents>(topic: K, data: TEvents[K]): Promise<void>;
+
+    subscribe<K extends keyof TEvents>(
+        topic: K,
+        handler: (data: TEvents[K]) => void | Promise<void>
+    ): Unsubscribe;
+
+    observe<K extends keyof TEvents>(topic: K): Observable<TEvents[K]>;
+
+    dispose(): void;
+}

packages/editor-app/src/core/interfaces/IPanelRegistry.ts

@@ -0,0 +1,17 @@
+import type { ComponentType, ReactNode } from 'react';
+
+export interface PanelDescriptor {
+    id: string;
+    title: string;
+    icon?: ReactNode;
+    component: ComponentType<unknown>;
+    category?: string;
+    order?: number;
+}
+
+export interface IPanelRegistry {
+    register(panel: PanelDescriptor): void;
+    unregister(panelId: string): void;
+    getPanel(panelId: string): PanelDescriptor | undefined;
+    getPanels(category?: string): PanelDescriptor[];
+}

packages/editor-app/src/core/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './IEventBus';
+export * from './ICommandRegistry';
+export * from './IPanelRegistry';