refactor: 代码规范化与依赖清理 (#317)

* refactor(deps): 统一编辑器包依赖配置 & 优化分层架构

- 将 ecs-engine-bindgen 提升为 Layer 1 核心包
- 统一 9 个编辑器包的依赖声明模式
- 清理废弃的包目录 (ui, ui-editor, network-*)

* refactor(tokens): 修复 PrefabService 令牌冲突 & 补充 module.json

- 将 editor-core 的 PrefabServiceToken 改名为 EditorPrefabServiceToken
  避免与 asset-system 的 PrefabServiceToken 冲突 (Symbol.for 冲突)
- 为 mesh-3d 添加 module.json
- 为 world-streaming 添加 module.json

* refactor(editor-core): 整理导出结构 & 添加 blueprint tokens.ts

- 按功能分组整理 editor-core 的 65 行导出
- 添加清晰的分组注释 (中英双语)
- 为 blueprint 添加占位符 tokens.ts

* chore(editor): 为 14 个编辑器插件包添加 module.json

统一编辑器包的模块配置，包含：
- isEditorPlugin 标识
- runtimeModule 关联
- exports 导出清单 (inspectors, panels, gizmos)

* refactor(core): 改进类型安全 - 减少 as any 使用

- 添加 GlobalTypes.ts 定义小游戏平台和 Chrome API 类型
- SoAStorage 使用 IComponentTypeMetadata 替代 as any
- PlatformDetector 使用类型安全的平台检测
- 添加 ISoAStorageStats/ISoAFieldStats 接口

* feat(editor): 添加 EditorServicesContext 解决 prop drilling

- 新增 contexts/EditorServicesContext.tsx 提供统一服务访问
- App.tsx 包裹 EditorServicesProvider
- 提供 useEditorServices/useMessageHub 等便捷 hooks
- SceneHierarchy 添加迁移注释，后续可移除 props

* docs(editor): 澄清 inspector 目录架构关系

- inspector/ 标记为内部实现，添加 @deprecated 警告
- inspectors/ 标记为公共 API 入口点
- 添加架构说明文档

* refactor(editor): 添加全局类型声明消除 window as any

- 创建 editor-app/src/global.d.ts 声明 Window 接口扩展
- 创建 editor-core/src/global.d.ts 声明 Window 接口扩展
- 更新 App.tsx 使用类型安全的 window 属性访问
- 更新 PluginLoader.ts 使用 window.__ESENGINE_PLUGINS__
- 更新 PluginSDKRegistry.ts 使用 window.__ESENGINE_SDK__
- 更新 UserCodeService.ts 使用类型安全的全局变量访问

* refactor(editor): 提取项目和场景操作到独立 hooks

- 创建 useProjectActions hook 封装项目操作
- 创建 useSceneActions hook 封装场景操作
- 为渐进式重构 App.tsx 做准备

* refactor(editor): 清理冗余代码和未使用文件

删除的目录和文件：
- application/state/ - 重复的状态管理（与 stores/ 重复）
- 8 个孤立 CSS 文件（对应组件不存在）
- AssetBrowser.tsx - 仅为 ContentBrowser 的向后兼容包装
- AssetPicker.tsx - 未被使用
- AssetPickerDialog.tsx (顶级) - 已被 dialogs/ 版本取代
- EntityInspector.tsx (顶级) - 已被 inspectors/views/ 版本取代

修复：
- 移除 App.tsx 中未使用的导入
- 更新 application/index.ts 移除已删除模块
- 修复 useProjectActions.ts 的 MutableRefObject 类型

* refactor(editor): 统一 inspectors 模块导出结构

- 在 inspectors/index.ts 重新导出 PropertyInspector
- 创建 inspectors/fields/index.ts barrel export
- 导出 views、fields、common 子模块
- 更新 EntityInspector 使用统一入口导入

* refactor(editor): 删除废弃的 Profiler 组件

删除未使用的组件（共 1059 行）：
- ProfilerPanel.tsx (229 行)
- ProfilerWindow.tsx (589 行)
- ProfilerDockPanel.tsx (241 行)
- ProfilerPanel.css
- ProfilerDockPanel.css

保留：AdvancedProfiler + AdvancedProfilerWindow（正在使用）

* refactor(runtime-core): 统一依赖处理与插件状态管理

- 新增 DependencyUtils 统一拓扑排序和依赖验证
- 新增 PluginState 定义插件生命周期状态机
- 合并 UnifiedPluginLoader 到 PluginLoader
- 清理 index.ts 移除不必要的 Token re-exports
- 新增 RuntimeMode/UserCodeRealm/ImportMapGenerator

* refactor(editor-core): 使用统一的 ImportMapGenerator

- WebBuildPipeline 使用 runtime-core 的 generateImportMap
- UserCodeService 添加 ImportMap 相关接口

* feat(compiler): 增强 esbuild 查找策略

- 支持本地 node_modules、pnpm exec、npx、全局多种来源
- EngineService 使用 RuntimeMode

* refactor(runtime-core): 简化 GameRuntime 代码

- 合并 _disableGameLogicSystems/_enableGameLogicSystems 为 _setGameLogicSystemsEnabled
- 精简本地 Token 定义的注释

* refactor(editor-core): 引入 BaseRegistry 基类消除代码重复

- 新增 BaseRegistry 和 PrioritizedRegistry 基类
- 重构 CompilerRegistry, InspectorRegistry, FieldEditorRegistry
- 统一注册表的日志记录和错误处理

* refactor(editor-core): 扩展 BaseRegistry 重构

- ComponentInspectorRegistry 继承 PrioritizedRegistry
- EditorComponentRegistry 继承 BaseRegistry
- EntityCreationRegistry 继承 BaseRegistry
- PropertyRendererRegistry 继承 PrioritizedRegistry
- 导出 BaseRegistry 基类供外部使用
- 统一双语注释格式

* refactor(editor-core): 代码优雅性优化

CommandManager:
- 提取 tryMergeWithLast() 和 pushToUndoStack() 消除重复代码
- 统一双语注释格式

FileActionRegistry:
- 提取 normalizeExtension() 消除扩展名规范化重复
- 统一私有属性命名风格（_前缀）
- 使用 createRegistryToken 统一 Token 创建

BaseRegistry:
- 添加 IOrdered 接口
- 添加 sortByOrder() 排序辅助方法

EntityCreationRegistry:
- 使用 sortByOrder() 简化排序逻辑

* refactor(editor-core): 统一日志系统 & 代码规范优化

- GizmoRegistry: 使用 createLogger 替代 console.warn
- VirtualNodeRegistry: 使用 createLogger 替代 console.warn
- WindowRegistry: 使用 logger、添加 _ 前缀、导出 IWindowRegistry token
- EditorViewportService: 使用 createLogger 替代 console.warn
- ComponentActionRegistry: 使用 logger、添加 _ 前缀、返回值改进
- SettingsRegistry: 使用 logger、提取 ensureCategory/ensureSection 方法
- 添加 WindowRegistry 到主导出

* refactor(editor-core): ModuleRegistry 使用 logger 替代 console

* refactor(editor-core): SerializerRegistry/UIRegistry 添加 token 和 _ 前缀

* refactor(editor-core): UIRegistry 代码优雅性 & Token 命名统一

- UIRegistry: 提取 _sortByOrder 消除 6 处重复排序逻辑
- UIRegistry: 添加分节注释和双语文档
- FieldEditorRegistry: Token 重命名为 FieldEditorRegistryToken
- PropertyRendererRegistry: Token 重命名为 PropertyRendererRegistryToken

* refactor(core): 统一日志系统 - console 替换为 logger

- ComponentSerializer: 使用 logger 替代 console.warn
- ComponentRegistry: console.warn → logger.warn (已有 logger)
- SceneSerializer: 添加 logger，替换 console.warn/error
- SystemScheduler: 添加 logger，替换 console.warn
- VersionMigration: 添加 logger，替换所有 console.warn
- RuntimeModeService: console.error → logger.error
- Core.ts: _logger 改为 readonly，双语错误消息
- SceneSerializer 修复：使用 getComponentTypeName 替代 constructor.name

* fix(core): 修复 constructor.name 压缩后失效问题

- Scene.ts: 使用 system.systemName 替代 system.constructor.name
- CommandBuffer.ts: 使用 getComponentTypeName() 替代 constructor.name

* refactor(editor-core): 代码规范优化 - 私有方法命名 & 日志统一

- BuildService: console → logger
- FileActionRegistry: 添加 logger, 私有方法 _ 前缀
- SettingsRegistry: 私有方法 _ 前缀 (ensureCategory → _ensureCategory)

* refactor(core): Scene.ts 私有变量命名规范化

- logger → _logger (遵循私有变量 _ 前缀规范)

* refactor(editor-core): 服务类私有成员命名规范化

- CommandManager: 私有变量/方法添加 _ 前缀
  - undoStack/redoStack/config/isExecuting
  - tryMergeWithLast/pushToUndoStack
- LocaleService: 私有变量/方法添加 _ 前缀
  - currentLocale/translations/changeListeners
  - deepMerge/getNestedValue/loadSavedLocale/saveLocale

* refactor(core): 私有成员命名规范化 & 单例模式优化

- Component.ts: _idGenerator 私有静态变量规范化
- PlatformManager.ts: _instance, _adapter, _logger 规范化
- AutoProfiler.ts: _instance, _config 及所有私有方法规范化
- ProfilerSDK.ts: _instance, _config 及所有私有方法规范化
- ComponentPoolManager: _instance, _pools, _usageTracker 规范化
- GlobalEventBus: _instance 规范化
- 添加中英双语 JSDoc 注释

* refactor(editor-app,behavior-tree-editor): 私有成员 & 单例模式命名规范化

editor-app:
- EngineService: private static instance → _instance
- EditorEngineSync: 所有私有成员添加 _ 前缀
- RuntimeResolver: 所有私有成员和方法添加 _ 前缀
- SettingsService: 所有私有成员和方法添加 _ 前缀

behavior-tree-editor:
- GlobalBlackboardService: 所有私有成员和方法添加 _ 前缀
- NotificationService: private static instance → _instance
- NodeRegistryService: 所有私有成员和方法添加 _ 前缀
- TreeStateAdapter: private static instance → _instance

* fix(editor-runtime): 添加 editor-core 到 external 避免传递依赖问题

将 @esengine/editor-core 添加到 vite external 配置，
避免 editor-core → runtime-core → ecs-engine-bindgen 的传递依赖
被错误地打包进 editor-runtime.js，导致 CI 构建失败。

* fix(core): 修复空接口 lint 错误

将 IByteDanceMiniGameAPI、IAlipayMiniGameAPI、IBaiduMiniGameAPI 从空接口改为类型别名，修复 no-empty-object-type 规则报错

packages/behavior-tree-editor/module.json

@@ -0,0 +1,15 @@
+{
+  "id": "behavior-tree-editor",
+  "name": "@esengine/behavior-tree-editor",
+  "displayName": "Behavior Tree Editor",
+  "description": "Visual behavior tree editor | 可视化行为树编辑器",
+  "version": "1.0.0",
+  "category": "Editor",
+  "icon": "GitBranch",
+  "isEditorPlugin": true,
+  "runtimeModule": "@esengine/behavior-tree",
+  "exports": {
+    "inspectors": ["BehaviorTreeComponentInspector"],
+    "panels": ["BehaviorTreeEditorPanel"]
+  }
+}

packages/behavior-tree-editor/package.json

@@ -24,6 +24,9 @@
     "dependencies": {
         "@esengine/behavior-tree": "workspace:*"
     },
+    "peerDependencies": {
+        "@esengine/editor-core": "workspace:*"
+    },
     "devDependencies": {
         "@esengine/ecs-framework": "workspace:*",
         "@esengine/engine-core": "workspace:*",

packages/behavior-tree-editor/src/application/services/GlobalBlackboardService.ts

@@ -24,64 +24,64 @@ export interface GlobalBlackboardVariable {
  * 管理跨行为树共享的全局变量
  */
 export class GlobalBlackboardService {
-    private static instance: GlobalBlackboardService;
-    private variables: Map<string, GlobalBlackboardVariable> = new Map();
-    private changeCallbacks: Array<() => void> = [];
-    private projectPath: string | null = null;
+    private static _instance: GlobalBlackboardService;
+    private _variables: Map<string, GlobalBlackboardVariable> = new Map();
+    private _changeCallbacks: Array<() => void> = [];
+    private _projectPath: string | null = null;
 
     private constructor() {}
 
     static getInstance(): GlobalBlackboardService {
-        if (!this.instance) {
-            this.instance = new GlobalBlackboardService();
+        if (!this._instance) {
+            this._instance = new GlobalBlackboardService();
         }
-        return this.instance;
+        return this._instance;
     }
 
     /**
      * 设置项目路径
      */
     setProjectPath(path: string | null): void {
-        this.projectPath = path;
+        this._projectPath = path;
     }
 
     /**
      * 获取项目路径
      */
     getProjectPath(): string | null {
-        return this.projectPath;
+        return this._projectPath;
     }
 
     /**
      * 添加全局变量
      */
     addVariable(variable: GlobalBlackboardVariable): void {
-        if (this.variables.has(variable.key)) {
+        if (this._variables.has(variable.key)) {
             throw new Error(`全局变量 "${variable.key}" 已存在`);
         }
-        this.variables.set(variable.key, variable);
-        this.notifyChange();
+        this._variables.set(variable.key, variable);
+        this._notifyChange();
     }
 
     /**
      * 更新全局变量
      */
     updateVariable(key: string, updates: Partial<Omit<GlobalBlackboardVariable, 'key'>>): void {
-        const variable = this.variables.get(key);
+        const variable = this._variables.get(key);
         if (!variable) {
             throw new Error(`全局变量 "${key}" 不存在`);
         }
-        this.variables.set(key, { ...variable, ...updates });
-        this.notifyChange();
+        this._variables.set(key, { ...variable, ...updates });
+        this._notifyChange();
     }
 
     /**
      * 删除全局变量
      */
     deleteVariable(key: string): boolean {
-        const result = this.variables.delete(key);
+        const result = this._variables.delete(key);
         if (result) {
-            this.notifyChange();
+            this._notifyChange();
         }
         return result;
     }
@@ -90,36 +90,36 @@ export class GlobalBlackboardService {
      * 重命名全局变量
      */
     renameVariable(oldKey: string, newKey: string): void {
-        if (!this.variables.has(oldKey)) {
+        if (!this._variables.has(oldKey)) {
             throw new Error(`全局变量 "${oldKey}" 不存在`);
         }
-        if (this.variables.has(newKey)) {
+        if (this._variables.has(newKey)) {
             throw new Error(`全局变量 "${newKey}" 已存在`);
         }
 
-        const variable = this.variables.get(oldKey)!;
-        this.variables.delete(oldKey);
-        this.variables.set(newKey, { ...variable, key: newKey });
-        this.notifyChange();
+        const variable = this._variables.get(oldKey)!;
+        this._variables.delete(oldKey);
+        this._variables.set(newKey, { ...variable, key: newKey });
+        this._notifyChange();
     }
 
     /**
      * 获取全局变量
      */
     getVariable(key: string): GlobalBlackboardVariable | undefined {
-        return this.variables.get(key);
+        return this._variables.get(key);
     }
 
     /**
      * 获取所有全局变量
      */
     getAllVariables(): GlobalBlackboardVariable[] {
-        return Array.from(this.variables.values());
+        return Array.from(this._variables.values());
     }
 
     getVariablesMap(): Record<string, GlobalBlackboardValue> {
         const map: Record<string, GlobalBlackboardValue> = {};
-        for (const [, variable] of this.variables) {
+        for (const [, variable] of this._variables) {
             map[variable.key] = variable.defaultValue;
         }
         return map;
@@ -129,15 +129,15 @@ export class GlobalBlackboardService {
      * 检查变量是否存在
      */
     hasVariable(key: string): boolean {
-        return this.variables.has(key);
+        return this._variables.has(key);
     }
 
     /**
      * 清空所有变量
      */
     clear(): void {
-        this.variables.clear();
-        this.notifyChange();
+        this._variables.clear();
+        this._notifyChange();
     }
 
     /**
@@ -146,7 +146,7 @@ export class GlobalBlackboardService {
     toConfig(): GlobalBlackboardConfig {
         const variables: BlackboardVariable[] = [];
 
-        for (const variable of this.variables.values()) {
+        for (const variable of this._variables.values()) {
             variables.push({
                 name: variable.key,
                 type: variable.type,
@@ -162,11 +162,11 @@ export class GlobalBlackboardService {
      * 从配置导入
      */
     fromConfig(config: GlobalBlackboardConfig): void {
-        this.variables.clear();
+        this._variables.clear();
 
         if (config.variables && Array.isArray(config.variables)) {
             for (const variable of config.variables) {
-                this.variables.set(variable.name, {
+                this._variables.set(variable.name, {
                     key: variable.name,
                     type: variable.type,
                     defaultValue: variable.value as GlobalBlackboardValue,
@@ -175,7 +175,7 @@ export class GlobalBlackboardService {
             }
         }
 
-        this.notifyChange();
+        this._notifyChange();
     }
 
     /**
@@ -202,17 +202,17 @@ export class GlobalBlackboardService {
      * 监听变化
      */
     onChange(callback: () => void): () => void {
-        this.changeCallbacks.push(callback);
+        this._changeCallbacks.push(callback);
         return () => {
-            const index = this.changeCallbacks.indexOf(callback);
+            const index = this._changeCallbacks.indexOf(callback);
             if (index > -1) {
-                this.changeCallbacks.splice(index, 1);
+                this._changeCallbacks.splice(index, 1);
             }
         };
     }
 
-    private notifyChange(): void {
-        this.changeCallbacks.forEach((cb) => {
+    private _notifyChange(): void {
+        this._changeCallbacks.forEach((cb) => {
             try {
                 cb();
             } catch (error) {

packages/behavior-tree-editor/src/application/state/BehaviorTreeDataStore.ts

@@ -536,15 +536,15 @@ export const useBehaviorTreeDataStore = create<BehaviorTreeDataState>((set, get)
  * 将 Zustand Store 适配为 ITreeState 接口
  */
 export class TreeStateAdapter implements ITreeState {
-    private static instance: TreeStateAdapter | null = null;
+    private static _instance: TreeStateAdapter | null = null;
 
     private constructor() {}
 
     static getInstance(): TreeStateAdapter {
-        if (!TreeStateAdapter.instance) {
-            TreeStateAdapter.instance = new TreeStateAdapter();
+        if (!TreeStateAdapter._instance) {
+            TreeStateAdapter._instance = new TreeStateAdapter();
         }
-        return TreeStateAdapter.instance;
+        return TreeStateAdapter._instance;
     }
 
     getTree(): BehaviorTree {

packages/behavior-tree-editor/src/infrastructure/services/NodeRegistryService.ts

@@ -36,63 +36,63 @@ export interface NodePropertyConfig {
  * 提供编辑器级别的节点注册和管理功能
  */
 export class NodeRegistryService {
-    private static instance: NodeRegistryService;
-    private customTemplates: Map<string, NodeTemplate> = new Map();
-    private registrationCallbacks: Array<(template: NodeTemplate) => void> = [];
+    private static _instance: NodeRegistryService;
+    private _customTemplates: Map<string, NodeTemplate> = new Map();
+    private _registrationCallbacks: Array<(template: NodeTemplate) => void> = [];
 
     private constructor() {}
 
     static getInstance(): NodeRegistryService {
-        if (!this.instance) {
-            this.instance = new NodeRegistryService();
+        if (!this._instance) {
+            this._instance = new NodeRegistryService();
         }
-        return this.instance;
+        return this._instance;
     }
 
     /**
      * 注册自定义节点类型
      */
     registerNode(config: NodeRegistrationConfig): void {
-        const nodeType = this.mapStringToNodeType(config.type);
+        const nodeType = this._mapStringToNodeType(config.type);
 
         const metadata: NodeMetadata = {
             implementationType: config.implementationType,
             nodeType: nodeType,
             displayName: config.displayName,
             description: config.description || '',
-            category: config.category || this.getDefaultCategory(config.type),
-            configSchema: this.convertPropertiesToSchema(config.properties || []),
-            childrenConstraints: this.getChildrenConstraints(config)
+            category: config.category || this._getDefaultCategory(config.type),
+            configSchema: this._convertPropertiesToSchema(config.properties || []),
+            childrenConstraints: this._getChildrenConstraints(config)
         };
 
         class DummyExecutor {}
         NodeMetadataRegistry.register(DummyExecutor, metadata);
 
-        const template = this.createTemplate(config, metadata);
-        this.customTemplates.set(config.implementationType, template);
+        const template = this._createTemplate(config, metadata);
+        this._customTemplates.set(config.implementationType, template);
 
-        this.registrationCallbacks.forEach((cb) => cb(template));
+        this._registrationCallbacks.forEach((cb) => cb(template));
     }
 
     /**
      * 注销节点类型
      */
     unregisterNode(implementationType: string): boolean {
-        return this.customTemplates.delete(implementationType);
+        return this._customTemplates.delete(implementationType);
     }
 
     /**
      * 获取所有自定义模板
      */
     getCustomTemplates(): NodeTemplate[] {
-        return Array.from(this.customTemplates.values());
+        return Array.from(this._customTemplates.values());
     }
 
     /**
      * 检查节点类型是否已注册
      */
     hasNode(implementationType: string): boolean {
-        return this.customTemplates.has(implementationType) ||
+        return this._customTemplates.has(implementationType) ||
                NodeMetadataRegistry.getMetadata(implementationType) !== undefined;
     }
 
@@ -100,16 +100,16 @@ export class NodeRegistryService {
      * 监听节点注册事件
      */
     onNodeRegistered(callback: (template: NodeTemplate) => void): () => void {
-        this.registrationCallbacks.push(callback);
+        this._registrationCallbacks.push(callback);
         return () => {
-            const index = this.registrationCallbacks.indexOf(callback);
+            const index = this._registrationCallbacks.indexOf(callback);
             if (index > -1) {
-                this.registrationCallbacks.splice(index, 1);
+                this._registrationCallbacks.splice(index, 1);
             }
         };
     }
 
-    private mapStringToNodeType(type: string): NodeType {
+    private _mapStringToNodeType(type: string): NodeType {
         switch (type) {
             case 'composite': return NodeType.Composite;
             case 'decorator': return NodeType.Decorator;
@@ -119,7 +119,7 @@ export class NodeRegistryService {
         }
     }
 
-    private getDefaultCategory(type: string): string {
+    private _getDefaultCategory(type: string): string {
         switch (type) {
             case 'composite': return '组合';
             case 'decorator': return '装饰器';
@@ -129,12 +129,12 @@ export class NodeRegistryService {
         }
     }
 
-    private convertPropertiesToSchema(properties: NodePropertyConfig[]): Record<string, any> {
+    private _convertPropertiesToSchema(properties: NodePropertyConfig[]): Record<string, any> {
         const schema: Record<string, any> = {};
 
         for (const prop of properties) {
             schema[prop.name] = {
-                type: this.mapPropertyType(prop.type),
+                type: this._mapPropertyType(prop.type),
                 default: prop.defaultValue,
                 description: prop.description,
                 min: prop.min,
@@ -146,7 +146,7 @@ export class NodeRegistryService {
         return schema;
     }
 
-    private mapPropertyType(type: string): string {
+    private _mapPropertyType(type: string): string {
         switch (type) {
             case 'string':
             case 'code':
@@ -162,7 +162,7 @@ export class NodeRegistryService {
         }
     }
 
-    private getChildrenConstraints(config: NodeRegistrationConfig): { min?: number; max?: number } | undefined {
+    private _getChildrenConstraints(config: NodeRegistrationConfig): { min?: number; max?: number } | undefined {
         if (config.minChildren !== undefined || config.maxChildren !== undefined) {
             return {
                 min: config.minChildren,
@@ -183,7 +183,7 @@ export class NodeRegistryService {
         }
     }
 
-    private createTemplate(config: NodeRegistrationConfig, metadata: NodeMetadata): NodeTemplate {
+    private _createTemplate(config: NodeRegistrationConfig, metadata: NodeMetadata): NodeTemplate {
         const defaultConfig: any = {
             nodeType: config.type
         };
@@ -212,10 +212,10 @@ export class NodeRegistryService {
         const template: NodeTemplate = {
             type: metadata.nodeType,
             displayName: config.displayName,
-            category: config.category || this.getDefaultCategory(config.type),
+            category: config.category || this._getDefaultCategory(config.type),
             description: config.description || '',
-            icon: config.icon || this.getDefaultIcon(config.type),
-            color: config.color || this.getDefaultColor(config.type),
+            icon: config.icon || this._getDefaultIcon(config.type),
+            color: config.color || this._getDefaultColor(config.type),
             className: config.implementationType,
             defaultConfig,
             properties: (config.properties || []).map((p) => ({
@@ -242,7 +242,7 @@ export class NodeRegistryService {
         return template;
     }
 
-    private getDefaultIcon(type: string): string {
+    private _getDefaultIcon(type: string): string {
         switch (type) {
             case 'composite': return 'GitBranch';
             case 'decorator': return 'Settings';
@@ -252,7 +252,7 @@ export class NodeRegistryService {
         }
     }
 
-    private getDefaultColor(type: string): string {
+    private _getDefaultColor(type: string): string {
         switch (type) {
             case 'composite': return '#1976d2';
             case 'decorator': return '#fb8c00';

packages/behavior-tree-editor/src/services/NotificationService.ts

@@ -4,33 +4,33 @@ import type { MessageHub } from '@esengine/editor-runtime';
 const logger = createLogger('NotificationService');
 
 export class NotificationService {
-    private static instance: NotificationService;
-    private messageHub: MessageHub | null = null;
+    private static _instance: NotificationService;
+    private _messageHub: MessageHub | null = null;
 
     private constructor() {
         // 延迟获取 MessageHub，因为初始化时可能还不可用
     }
 
-    private getMessageHub(): MessageHub | null {
-        if (!this.messageHub && PluginAPI.isAvailable) {
+    private _getMessageHub(): MessageHub | null {
+        if (!this._messageHub && PluginAPI.isAvailable) {
             try {
-                this.messageHub = PluginAPI.messageHub;
+                this._messageHub = PluginAPI.messageHub;
             } catch (error) {
                 logger.warn('MessageHub not available');
             }
         }
-        return this.messageHub;
+        return this._messageHub;
     }
 
     public static getInstance(): NotificationService {
-        if (!NotificationService.instance) {
-            NotificationService.instance = new NotificationService();
+        if (!NotificationService._instance) {
+            NotificationService._instance = new NotificationService();
         }
-        return NotificationService.instance;
+        return NotificationService._instance;
     }
 
     public showToast(message: string, type: 'success' | 'error' | 'warning' | 'info' = 'info'): void {
-        const hub = this.getMessageHub();
+        const hub = this._getMessageHub();
         if (!hub) {
             logger.info(`[Toast ${type}] ${message}`);
             return;