组件发现和动态加载系统

packages/editor-core/src/Services/ComponentLoaderService.ts

@@ -0,0 +1,141 @@
+import type { IService } from '@esengine/ecs-framework';
+import { Injectable, Component } from '@esengine/ecs-framework';
+import { createLogger } from '@esengine/ecs-framework';
+import { MessageHub } from './MessageHub';
+import type { ComponentFileInfo } from './ComponentDiscoveryService';
+import { ComponentRegistry } from './ComponentRegistry';
+
+const logger = createLogger('ComponentLoaderService');
+
+export interface LoadedComponentInfo {
+    fileInfo: ComponentFileInfo;
+    componentClass: typeof Component;
+    loadedAt: number;
+}
+
+@Injectable()
+export class ComponentLoaderService implements IService {
+    private loadedComponents: Map<string, LoadedComponentInfo> = new Map();
+    private messageHub: MessageHub;
+    private componentRegistry: ComponentRegistry;
+
+    constructor(messageHub: MessageHub, componentRegistry: ComponentRegistry) {
+        this.messageHub = messageHub;
+        this.componentRegistry = componentRegistry;
+    }
+
+    public async loadComponents(
+        componentInfos: ComponentFileInfo[],
+        modulePathTransform?: (filePath: string) => string
+    ): Promise<LoadedComponentInfo[]> {
+        logger.info(`Loading ${componentInfos.length} components`);
+
+        const loadedComponents: LoadedComponentInfo[] = [];
+
+        for (const componentInfo of componentInfos) {
+            try {
+                const loadedComponent = await this.loadComponent(componentInfo, modulePathTransform);
+                if (loadedComponent) {
+                    loadedComponents.push(loadedComponent);
+                }
+            } catch (error) {
+                logger.error(`Failed to load component: ${componentInfo.fileName}`, error);
+            }
+        }
+
+        await this.messageHub.publish('components:loaded', {
+            count: loadedComponents.length,
+            components: loadedComponents
+        });
+
+        logger.info(`Successfully loaded ${loadedComponents.length} components`);
+        return loadedComponents;
+    }
+
+    public async loadComponent(
+        componentInfo: ComponentFileInfo,
+        modulePathTransform?: (filePath: string) => string
+    ): Promise<LoadedComponentInfo | null> {
+        try {
+            const modulePath = modulePathTransform
+                ? modulePathTransform(componentInfo.path)
+                : this.convertToModulePath(componentInfo.path);
+
+            logger.debug(`Loading component from: ${modulePath}`);
+
+            const module = await import(/* @vite-ignore */ modulePath);
+
+            if (!componentInfo.className) {
+                logger.warn(`No class name found for component: ${componentInfo.fileName}`);
+                return null;
+            }
+
+            const componentClass = module[componentInfo.className];
+
+            if (!componentClass || !(componentClass.prototype instanceof Component)) {
+                logger.error(`Invalid component class: ${componentInfo.className}`);
+                return null;
+            }
+
+            this.componentRegistry.register({
+                name: componentInfo.className,
+                type: componentClass
+            });
+
+            const loadedInfo: LoadedComponentInfo = {
+                fileInfo: componentInfo,
+                componentClass,
+                loadedAt: Date.now()
+            };
+
+            this.loadedComponents.set(componentInfo.path, loadedInfo);
+
+            logger.info(`Component loaded and registered: ${componentInfo.className}`);
+
+            return loadedInfo;
+        } catch (error) {
+            logger.error(`Failed to load component: ${componentInfo.fileName}`, error);
+            return null;
+        }
+    }
+
+    public getLoadedComponents(): LoadedComponentInfo[] {
+        return Array.from(this.loadedComponents.values());
+    }
+
+    public unloadComponent(filePath: string): boolean {
+        const loadedComponent = this.loadedComponents.get(filePath);
+
+        if (!loadedComponent || !loadedComponent.fileInfo.className) {
+            return false;
+        }
+
+        this.componentRegistry.unregister(loadedComponent.fileInfo.className);
+        this.loadedComponents.delete(filePath);
+
+        logger.info(`Component unloaded: ${loadedComponent.fileInfo.className}`);
+        return true;
+    }
+
+    public clearLoadedComponents(): void {
+        for (const [filePath] of this.loadedComponents) {
+            this.unloadComponent(filePath);
+        }
+        logger.info('Cleared all loaded components');
+    }
+
+    private convertToModulePath(filePath: string): string {
+        const normalizedPath = filePath.replace(/\\/g, '/');
+
+        if (normalizedPath.startsWith('http://') || normalizedPath.startsWith('https://')) {
+            return normalizedPath;
+        }
+
+        return `file:///${normalizedPath}`;
+    }
+
+    public dispose(): void {
+        this.clearLoadedComponents();
+        logger.info('ComponentLoaderService disposed');
+    }
+}