@wukong-kit/extension 0.1.0

package/dist/services/ModuleRegistryService.js

@@ -0,0 +1,891 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleRegistryService = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+class ModuleRegistryService {
+    constructor(projectPath = Editor.Project.path) {
+        this.projectPath = projectPath;
+        this.configPath = (0, path_1.join)(projectPath, 'assets', 'config', 'wukong.modules.json');
+        this.packageJsonPath = (0, path_1.join)(projectPath, 'package.json');
+    }
+    async listModules() {
+        const config = this.readConfig();
+        const packageJson = this.readPackageJson();
+        const dependencies = {
+            ...(packageJson.dependencies ?? {}),
+            ...(packageJson.devDependencies ?? {})
+        };
+        return Promise.all(config.supportedModules.map(async (module) => {
+            const installedVersion = dependencies[module.npmPackage] ?? null;
+            const installPackage = module.installPackage || module.npmPackage;
+            const enabledModule = config.enabledModules.find(item => item.id === module.id);
+            const initMode = module.initMode ?? 'none';
+            const shouldFetchLatest = Boolean(installedVersion) && !installPackage.startsWith('file:');
+            const latestVersion = shouldFetchLatest ? await this.fetchLatestVersion(module.npmPackage).catch(() => null) : null;
+            return {
+                ...module,
+                installPackage,
+                initMode,
+                enabled: enabledModule?.enabled ?? Boolean(enabledModule),
+                order: this.normalizeOrder(enabledModule?.order ?? module.defaultOrder ?? 100),
+                installed: Boolean(installedVersion),
+                installedVersion,
+                latestVersion,
+                updateAvailable: Boolean(installedVersion && latestVersion && this.normalizeVersion(installedVersion) !== latestVersion)
+            };
+        }));
+    }
+    async installModule(npmPackage) {
+        await this.runNpm(['install', npmPackage]);
+        const config = this.readConfig();
+        const module = config.supportedModules.find(item => npmPackage === item.npmPackage || npmPackage === item.installPackage || npmPackage.startsWith(`${item.npmPackage}@`));
+        if (module && !config.enabledModules.some(item => item.id === module.id)) {
+            config.enabledModules.push({
+                id: module.id,
+                npmPackage: module.npmPackage,
+                installedAt: new Date().toISOString(),
+                enabled: true,
+                order: this.normalizeOrder(module.defaultOrder ?? 100)
+            });
+            this.writeConfig(config);
+        }
+        if (module) {
+            await this.applyLibraryPackage(module);
+            this.writeLibraryBootstrap();
+            await this.refreshLibraryAssets();
+        }
+        return this.listModules();
+    }
+    async uninstallModule(npmPackage) {
+        const config = this.readConfig();
+        const module = config.supportedModules.find(item => npmPackage === item.npmPackage || npmPackage === item.installPackage || npmPackage.startsWith(`${item.npmPackage}@`));
+        const packageName = module?.npmPackage ?? npmPackage;
+        if (module) {
+            this.removeLibraryEditorTemplates(module);
+        }
+        await this.runNpm(['uninstall', packageName]);
+        if (module) {
+            config.enabledModules = config.enabledModules.filter(item => item.id !== module.id);
+            this.writeConfig(config);
+            this.writeLibraryBootstrap();
+            await this.refreshLibraryAssets();
+        }
+        return this.listModules();
+    }
+    async updateLibraryState(options = {}) {
+        if (!options.id) {
+            throw new Error('Library id is required.');
+        }
+        const config = this.readConfig();
+        const module = config.supportedModules.find(item => item.id === options.id);
+        if (!module) {
+            throw new Error(`Library not found: ${options.id}`);
+        }
+        let enabledModule = config.enabledModules.find(item => item.id === module.id);
+        if (!enabledModule) {
+            enabledModule = {
+                id: module.id,
+                npmPackage: module.npmPackage,
+                installedAt: new Date().toISOString(),
+                enabled: options.enabled ?? false,
+                order: this.normalizeOrder(options.order ?? module.defaultOrder ?? 100)
+            };
+            config.enabledModules.push(enabledModule);
+        }
+        else {
+            enabledModule.enabled = options.enabled ?? enabledModule.enabled ?? true;
+            enabledModule.order = this.normalizeOrder(options.order ?? enabledModule.order ?? module.defaultOrder ?? 100);
+        }
+        this.writeConfig(config);
+        this.writeLibraryBootstrap();
+        await this.refreshLibraryAssets();
+        return this.listModules();
+    }
+    async createModule(options = {}) {
+        const baseName = this.toPascalCase(options.name || 'NewModule');
+        const className = this.withWKPrefix(baseName);
+        const order = this.normalizeOrder(options.order);
+        const dirName = this.toFolderName(baseName);
+        const dir = (0, path_1.join)(this.projectPath, 'assets', 'scripts', 'game', 'modules', dirName);
+        if ((0, fs_1.existsSync)(dir) && (0, fs_1.readdirSync)(dir).length > 0) {
+            throw new Error(`Module already exists: ${className}`);
+        }
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+        const modelPath = (0, path_1.join)(dir, `${className}Model.ts`);
+        const controllerPath = (0, path_1.join)(dir, `${className}Controller.ts`);
+        const modulePath = (0, path_1.join)(dir, `${className}Module.ts`);
+        const files = [modelPath, controllerPath, modulePath];
+        if (!(0, fs_1.existsSync)(modelPath)) {
+            (0, fs_1.writeFileSync)(modelPath, this.modelScript(baseName, className), 'utf8');
+        }
+        if (!(0, fs_1.existsSync)(controllerPath)) {
+            (0, fs_1.writeFileSync)(controllerPath, this.controllerScript(baseName, className), 'utf8');
+        }
+        if (!(0, fs_1.existsSync)(modulePath)) {
+            (0, fs_1.writeFileSync)(modulePath, this.moduleScript(baseName, className, order), 'utf8');
+        }
+        this.upsertModuleEntry(dirName, className);
+        if (options.withView) {
+            const view = await this.createView({
+                moduleName: baseName,
+                viewName: 'Main',
+                layer: 'UI',
+                cache: true
+            });
+            files.push(...view.files);
+        }
+        await Editor.Message.request('asset-db', 'refresh-asset', 'db://assets/scripts/game/modules');
+        return {
+            moduleName: className,
+            folderPath: dir,
+            files
+        };
+    }
+    async createView(options = {}) {
+        const baseName = this.toPascalCase(options.moduleName || 'NewModule');
+        const viewName = this.toPascalCase(options.viewName || 'View');
+        const className = this.withWKPrefix(baseName);
+        const viewClassName = `${className}${viewName}View`;
+        const folderName = this.toFolderName(baseName);
+        const dir = (0, path_1.join)(this.projectPath, 'assets', 'scripts', 'game', 'modules', folderName);
+        const viewsDir = (0, path_1.join)(dir, 'views');
+        (0, fs_1.mkdirSync)(viewsDir, { recursive: true });
+        const viewPath = (0, path_1.join)(viewsDir, `${viewClassName}.ts`);
+        const modulePath = (0, path_1.join)(dir, `${className}Module.ts`);
+        const controllerPath = (0, path_1.join)(dir, `${className}Controller.ts`);
+        const layer = options.layer || 'UI';
+        const cache = options.cache ?? true;
+        if ((0, fs_1.existsSync)(viewPath)) {
+            throw new Error(`View already exists: ${viewClassName}`);
+        }
+        (0, fs_1.writeFileSync)(viewPath, this.viewScript(viewClassName), 'utf8');
+        await this.requestWithTimeout('asset-db', 'refresh-asset', 'db://assets/scripts/game/modules');
+        const scriptUuid = await this.readScriptUuid(viewPath, 5000);
+        const compressedUuid = this.compressUuid(scriptUuid);
+        const prefabDirFS = (0, path_1.join)(this.projectPath, 'assets', 'resources', 'prefabs', folderName);
+        (0, fs_1.mkdirSync)(prefabDirFS, { recursive: true });
+        const prefabFileName = `${baseName}${viewName}.prefab`;
+        const prefabFilePath = (0, path_1.join)(prefabDirFS, prefabFileName);
+        (0, fs_1.writeFileSync)(prefabFilePath, this.prefabContent(viewClassName, compressedUuid), 'utf8');
+        await this.requestWithTimeout('asset-db', 'refresh-asset', 'db://assets/resources/prefabs');
+        await this.waitForFile(prefabFilePath + '.meta', 5000);
+        const prefabPath = `prefabs/${folderName}/${baseName}${viewName}`;
+        if (!(0, fs_1.existsSync)(modulePath)) {
+            (0, fs_1.writeFileSync)(modulePath, this.moduleScript(baseName, className, 100), 'utf8');
+        }
+        this.upsertViewInModule(modulePath, viewClassName, viewName, prefabPath, layer, cache);
+        return {
+            moduleName: className,
+            folderPath: dir,
+            files: [viewPath, modulePath, prefabFilePath],
+        };
+    }
+    async deleteView(options = {}) {
+        const baseName = this.toPascalCase(options.moduleName || 'NewModule');
+        const className = this.withWKPrefix(baseName);
+        const viewClassName = options.className || `${className}${this.toPascalCase(options.viewName || 'View')}View`;
+        const dir = (0, path_1.join)(this.projectPath, 'assets', 'scripts', 'game', 'modules', this.toFolderName(baseName));
+        const viewPath = (0, path_1.join)(dir, 'views', `${viewClassName}.ts`);
+        const modulePath = (0, path_1.join)(dir, `${className}Module.ts`);
+        if ((0, fs_1.existsSync)(viewPath)) {
+            (0, fs_1.unlinkSync)(viewPath);
+        }
+        if ((0, fs_1.existsSync)(modulePath)) {
+            this.removeViewFromModule(modulePath, viewClassName);
+        }
+        await Editor.Message.request('asset-db', 'refresh-asset', 'db://assets/scripts/game/modules');
+        return this.listProjectModules();
+    }
+    async updateModuleOrder(options = {}) {
+        const baseName = this.toPascalCase(options.moduleName || 'NewModule');
+        const className = this.withWKPrefix(baseName);
+        const modulePath = (0, path_1.join)(this.projectPath, 'assets', 'scripts', 'game', 'modules', this.toFolderName(baseName), `${className}Module.ts`);
+        if (!(0, fs_1.existsSync)(modulePath)) {
+            throw new Error(`Module declaration not found: ${className}Module.ts`);
+        }
+        const order = this.normalizeOrder(options.order);
+        let content = (0, fs_1.readFileSync)(modulePath, 'utf8');
+        if (/order:\s*-?\d+/.test(content)) {
+            content = content.replace(/order:\s*-?\d+/, `order: ${order}`);
+        }
+        else {
+            content = content.replace(/name:\s*'[^']+',/, match => `${match}\n  order: ${order},`);
+        }
+        (0, fs_1.writeFileSync)(modulePath, content, 'utf8');
+        await Editor.Message.request('asset-db', 'refresh-asset', 'db://assets/scripts/game/modules');
+        return this.listProjectModules();
+    }
+    async createManager(options = {}) {
+        const baseName = this.toPascalCase(options.name || 'NewManager').replace(/Manager$/, '');
+        const className = `${this.withWKPrefix(baseName)}Manager`;
+        const exportName = this.toManagerExportName(baseName);
+        const dir = (0, path_1.join)(this.projectPath, 'assets', 'scripts', 'core', 'managers');
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+        const managerPath = (0, path_1.join)(dir, `${className}.ts`);
+        if ((0, fs_1.existsSync)(managerPath)) {
+            throw new Error(`Manager already exists: ${className}`);
+        }
+        (0, fs_1.writeFileSync)(managerPath, this.managerScript(className, exportName), 'utf8');
+        await Editor.Message.request('asset-db', 'refresh-asset', 'db://assets/scripts/core/managers');
+        return {
+            moduleName: className,
+            folderPath: dir,
+            files: [managerPath]
+        };
+    }
+    listProjectModules() {
+        const modulesDir = (0, path_1.join)(this.projectPath, 'assets', 'scripts', 'game', 'modules');
+        if (!(0, fs_1.existsSync)(modulesDir))
+            return [];
+        return (0, fs_1.readdirSync)(modulesDir)
+            .map(entry => (0, path_1.join)(modulesDir, entry))
+            .filter(item => (0, fs_1.statSync)(item).isDirectory())
+            .map(dir => this.scanProjectModule(dir))
+            .filter((module) => Boolean(module))
+            .sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
+    }
+    diagnoseProject() {
+        const issues = [];
+        const modules = this.listProjectModules();
+        const config = this.readConfig();
+        const packageJson = this.readPackageJson();
+        const dependencies = {
+            ...(packageJson.dependencies ?? {}),
+            ...(packageJson.devDependencies ?? {})
+        };
+        const moduleNames = new Set();
+        for (const module of modules) {
+            if (moduleNames.has(module.name)) {
+                issues.push({
+                    level: 'error',
+                    code: 'MODULE_DUPLICATE',
+                    message: `Duplicate project module: ${module.name}`,
+                    target: module.displayPath
+                });
+            }
+            moduleNames.add(module.name);
+            if (!module.controllerPath) {
+                issues.push({
+                    level: 'warn',
+                    code: 'MODULE_CONTROLLER_MISSING',
+                    message: `${module.className} has no controller script.`,
+                    target: module.displayPath
+                });
+            }
+            if (!module.modulePath) {
+                issues.push({
+                    level: 'warn',
+                    code: 'MODULE_DECLARATION_MISSING',
+                    message: `${module.className} has no module declaration script.`,
+                    target: module.displayPath
+                });
+            }
+            this.inspectModuleViewPrefabs(module, issues);
+        }
+        for (const module of config.supportedModules) {
+            const installedVersion = dependencies[module.npmPackage];
+            const enabled = config.enabledModules.find(item => item.id === module.id);
+            if (enabled && !installedVersion) {
+                issues.push({
+                    level: 'warn',
+                    code: 'LIB_ENABLED_NOT_INSTALLED',
+                    message: `${module.displayName} is enabled but not installed.`,
+                    target: module.npmPackage
+                });
+            }
+        }
+        if (issues.length === 0) {
+            issues.push({
+                level: 'info',
+                code: 'PROJECT_OK',
+                message: 'No Wukong project issues found.'
+            });
+        }
+        return issues;
+    }
+    readConfig() {
+        if (!(0, fs_1.existsSync)(this.configPath)) {
+            return this.emptyConfig();
+        }
+        const config = JSON.parse((0, fs_1.readFileSync)(this.configPath, 'utf8'));
+        return {
+            schemaVersion: config.schemaVersion ?? 1,
+            framework: config.framework ?? {
+                name: '@wukong-kit/core',
+                version: '0.0.0'
+            },
+            enabledModules: config.enabledModules ?? [],
+            supportedModules: config.supportedModules ?? []
+        };
+    }
+    inspectModuleViewPrefabs(module, issues) {
+        if (!module.modulePath || !(0, fs_1.existsSync)(module.modulePath))
+            return;
+        const content = (0, fs_1.readFileSync)(module.modulePath, 'utf8');
+        const prefabMatches = content.matchAll(/prefab:\s*['"]([^'"]+)['"]/g);
+        for (const match of prefabMatches) {
+            const prefabPath = match[1];
+            const filePath = (0, path_1.join)(this.projectPath, 'assets', 'resources', `${prefabPath}.prefab`);
+            if ((0, fs_1.existsSync)(filePath))
+                continue;
+            issues.push({
+                level: 'error',
+                code: 'VIEW_PREFAB_MISSING',
+                message: `${module.className} references missing prefab: ${prefabPath}`,
+                target: module.modulePath
+            });
+        }
+    }
+    emptyConfig() {
+        return {
+            schemaVersion: 1,
+            framework: {
+                name: '@wukong-kit/core',
+                version: '0.0.0'
+            },
+            enabledModules: [],
+            supportedModules: []
+        };
+    }
+    writeConfig(config) {
+        (0, fs_1.writeFileSync)(this.configPath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    readPackageJson() {
+        if (!(0, fs_1.existsSync)(this.packageJsonPath))
+            return {};
+        return JSON.parse((0, fs_1.readFileSync)(this.packageJsonPath, 'utf8'));
+    }
+    fetchLatestVersion(npmPackage) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)('npm', ['view', npmPackage, 'version'], { shell: process.platform === 'win32', timeout: 8000 }, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+    runNpm(args) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)('npm', args, {
+                cwd: this.projectPath,
+                shell: process.platform === 'win32'
+            }, error => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    async applyLibraryPackage(module) {
+        const packageRoot = this.resolveInstalledPackageRoot(module.npmPackage);
+        if (!packageRoot)
+            return;
+        const packageManifest = this.readLibraryPackageManifest(packageRoot);
+        const templates = packageManifest.assetTemplates ?? module.assetTemplates ?? [];
+        for (const template of templates) {
+            const source = (0, path_1.join)(packageRoot, template.from);
+            const target = (0, path_1.join)(this.projectPath, template.to);
+            if (!(0, fs_1.existsSync)(source))
+                continue;
+            (0, fs_1.mkdirSync)(target, { recursive: true });
+            this.copyDirectory(source, target);
+        }
+        const editorTemplates = packageManifest.editorTemplates ?? module.editorTemplates ?? [];
+        for (const template of editorTemplates) {
+            const source = (0, path_1.join)(packageRoot, template.from);
+            const target = (0, path_1.join)(this.projectPath, template.to);
+            if (!(0, fs_1.existsSync)(source))
+                continue;
+            (0, fs_1.mkdirSync)(target, { recursive: true });
+            this.copyDirectory(source, target);
+            this.enableProjectExtension(target);
+            await this.tryEnableKnownEditorExtension(target);
+        }
+    }
+    enableProjectExtension(extensionPath) {
+        const packageJsonPath = (0, path_1.join)(extensionPath, 'package.json');
+        if (!(0, fs_1.existsSync)(packageJsonPath))
+            return;
+        const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf8'));
+        const packageName = packageJson.name || (0, path_1.basename)(extensionPath);
+        const packagesConfigPath = (0, path_1.join)(this.projectPath, 'profiles', 'v2', 'editor', 'packages.json');
+        const config = (0, fs_1.existsSync)(packagesConfigPath)
+            ? JSON.parse((0, fs_1.readFileSync)(packagesConfigPath, 'utf8'))
+            : { 'disable-packages': {} };
+        const disabled = config['disable-packages'] ?? {};
+        delete disabled[packageName];
+        delete disabled[(0, path_1.basename)(extensionPath)];
+        delete disabled[`project://${extensionPath.replace(/\\/g, '/')}`];
+        config['disable-packages'] = disabled;
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(packagesConfigPath), { recursive: true });
+        (0, fs_1.writeFileSync)(packagesConfigPath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    async tryEnableKnownEditorExtension(extensionPath) {
+        const editorPackage = Editor.Package;
+        if (!editorPackage?.getPackages)
+            return;
+        const normalizedTarget = (0, path_1.resolve)(extensionPath);
+        let knownPackage = this.findKnownEditorPackage(normalizedTarget);
+        if (!knownPackage) {
+            await this.importEditorExtension(extensionPath);
+            await this.sleep(800);
+            knownPackage = this.findKnownEditorPackage(normalizedTarget);
+        }
+        if (!knownPackage)
+            return;
+        await this.enableEditorExtension(knownPackage.path);
+    }
+    async importEditorExtension(extensionPath) {
+        await this.requestEditorExtensionMessage('import-package-by-path', [extensionPath]);
+        await this.requestEditorExtensionMessage('scanning');
+    }
+    async enableEditorExtension(extensionPath) {
+        try {
+            await Editor.Message.request('extension', 'enable', extensionPath);
+        }
+        catch {
+            try {
+                await Editor.Package?.enable?.(extensionPath, { force: true });
+            }
+            catch {
+                // Leave the extension enabled in project profile; it can still be enabled from Extension Manager.
+            }
+        }
+        await this.requestEditorExtensionMessage('reload', extensionPath);
+        try {
+            await Editor.Package?.reload?.(extensionPath);
+        }
+        catch {
+            // Reload is best-effort because Creator versions differ slightly here.
+        }
+    }
+    async requestEditorExtensionMessage(message, ...args) {
+        try {
+            await Editor.Message.request('extension', message, ...args);
+        }
+        catch {
+            // These messages are available in Creator 3.8.x. If a patch version differs, profile enabling still remains.
+        }
+    }
+    findKnownEditorPackage(normalizedTarget) {
+        return Editor.Package?.getPackages?.({ invalid: true })
+            .find(item => (0, path_1.resolve)(item.path) === normalizedTarget);
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    removeLibraryEditorTemplates(module) {
+        const packageRoot = this.resolveInstalledPackageRoot(module.npmPackage);
+        const packageManifest = packageRoot ? this.readLibraryPackageManifest(packageRoot) : {};
+        const editorTemplates = packageManifest.editorTemplates ?? module.editorTemplates ?? [];
+        for (const template of editorTemplates) {
+            const target = (0, path_1.join)(this.projectPath, template.to);
+            if (!(0, fs_1.existsSync)(target) || !this.isSafeProjectPath(target))
+                continue;
+            this.removeDirectory(target);
+        }
+    }
+    copyDirectory(source, target) {
+        (0, fs_1.mkdirSync)(target, { recursive: true });
+        for (const entry of (0, fs_1.readdirSync)(source)) {
+            const sourcePath = (0, path_1.join)(source, entry);
+            const targetPath = (0, path_1.join)(target, entry);
+            const stats = (0, fs_1.statSync)(sourcePath);
+            if (stats.isDirectory()) {
+                this.copyDirectory(sourcePath, targetPath);
+                continue;
+            }
+            (0, fs_1.mkdirSync)((0, path_1.dirname)(targetPath), { recursive: true });
+            (0, fs_1.copyFileSync)(sourcePath, targetPath);
+        }
+    }
+    removeDirectory(target) {
+        if (!(0, fs_1.existsSync)(target))
+            return;
+        for (const entry of (0, fs_1.readdirSync)(target)) {
+            const entryPath = (0, path_1.join)(target, entry);
+            const stats = (0, fs_1.statSync)(entryPath);
+            if (stats.isDirectory()) {
+                this.removeDirectory(entryPath);
+                continue;
+            }
+            (0, fs_1.unlinkSync)(entryPath);
+        }
+        (0, fs_1.rmdirSync)(target);
+    }
+    isSafeProjectPath(target) {
+        const projectRoot = (0, path_1.resolve)(this.projectPath);
+        const resolvedTarget = (0, path_1.resolve)(target);
+        return resolvedTarget === projectRoot || resolvedTarget.startsWith(projectRoot + '\\') || resolvedTarget.startsWith(projectRoot + '/');
+    }
+    writeLibraryBootstrap() {
+        const config = this.readConfig();
+        const packageJson = this.readPackageJson();
+        const dependencies = {
+            ...(packageJson.dependencies ?? {}),
+            ...(packageJson.devDependencies ?? {})
+        };
+        const enabledModules = config.enabledModules
+            .filter(item => item.enabled ?? true)
+            .map(item => {
+            const module = config.supportedModules.find(candidate => candidate.id === item.id);
+            if (!module || !dependencies[module.npmPackage] || (module.initMode ?? 'none') !== 'auto')
+                return null;
+            const packageRoot = this.resolveInstalledPackageRoot(module.npmPackage);
+            const packageManifest = packageRoot ? this.readLibraryPackageManifest(packageRoot) : {};
+            const runtimeInit = packageManifest.runtimeInit ?? module.runtimeInit;
+            if (!runtimeInit)
+                return null;
+            return {
+                id: module.id,
+                order: this.normalizeOrder(item.order ?? module.defaultOrder ?? 100),
+                runtimeInit
+            };
+        })
+            .filter((item) => Boolean(item))
+            .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+        const bootstrapPath = (0, path_1.join)(this.projectPath, 'assets', 'scripts', 'core', 'WKLibBootstrap.ts');
+        (0, fs_1.mkdirSync)((0, path_1.join)(this.projectPath, 'assets', 'scripts', 'core'), { recursive: true });
+        if (enabledModules.length === 0) {
+            (0, fs_1.writeFileSync)(bootstrapPath, 'export async function initWukongLibraries(): Promise<void> {}\n', 'utf8');
+            return;
+        }
+        const imports = enabledModules
+            .map((item, index) => `import { ${item.runtimeInit.export} as initLibrary${index} } from '${item.runtimeInit.import}';`)
+            .join('\n');
+        const calls = enabledModules
+            .map((item, index) => `  await initLibrary${index}();`)
+            .join('\n');
+        (0, fs_1.writeFileSync)(bootstrapPath, `${imports}\n\nexport async function initWukongLibraries(): Promise<void> {\n${calls}\n}\n`, 'utf8');
+    }
+    readLibraryPackageManifest(packageRoot) {
+        const manifestPath = (0, path_1.join)(packageRoot, 'wukong-lib.json');
+        if (!(0, fs_1.existsSync)(manifestPath))
+            return {};
+        return JSON.parse((0, fs_1.readFileSync)(manifestPath, 'utf8'));
+    }
+    resolveInstalledPackageRoot(npmPackage) {
+        const parts = npmPackage.split('/');
+        const packageRoot = npmPackage.startsWith('@')
+            ? (0, path_1.join)(this.projectPath, 'node_modules', parts[0], parts[1] ?? '')
+            : (0, path_1.join)(this.projectPath, 'node_modules', npmPackage);
+        return (0, fs_1.existsSync)(packageRoot) ? packageRoot : null;
+    }
+    async refreshLibraryAssets() {
+        await Editor.Message.request('asset-db', 'refresh-asset', 'db://assets').catch(() => undefined);
+    }
+    normalizeVersion(version) {
+        return version.replace(/^[~^]/, '').replace(/^latest$/, '');
+    }
+    toPascalCase(input) {
+        const name = input
+            .replace(/[^a-zA-Z0-9]+/g, ' ')
+            .split(' ')
+            .filter(Boolean)
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+            .join('');
+        return name || 'NewModule';
+    }
+    withWKPrefix(name) {
+        return name.startsWith('WK') ? name : `WK${name}`;
+    }
+    toFolderName(name) {
+        return `${name.charAt(0).toLowerCase()}${name.slice(1)}`;
+    }
+    normalizeOrder(order) {
+        const value = Number(order);
+        if (!Number.isFinite(value))
+            return 100;
+        return Math.trunc(value);
+    }
+    upsertModuleEntry(folderName, className) {
+        const modulesDir = (0, path_1.join)(this.projectPath, 'assets', 'scripts', 'game', 'modules');
+        (0, fs_1.mkdirSync)(modulesDir, { recursive: true });
+        const entryPath = (0, path_1.join)(modulesDir, 'WKModules.ts');
+        const importLine = `import './${folderName}/${className}Module';`;
+        const content = (0, fs_1.existsSync)(entryPath) ? (0, fs_1.readFileSync)(entryPath, 'utf8') : '// Wukong module side-effect imports.\n';
+        if (content.includes(importLine))
+            return;
+        (0, fs_1.writeFileSync)(entryPath, `${content.trimEnd()}\n${importLine}\n`, 'utf8');
+    }
+    modelScript(baseName, className) {
+        return `import { WKModel } from '@wukong-kit/core';
+
+export class ${className}Model extends WKModel {
+  readonly name = '${className}Model';
+
+  enabled = true;
+  moduleName = '${baseName}';
+}
+`;
+    }
+    controllerScript(baseName, className) {
+        return `import { App, WKController, WKLogger } from '@wukong-kit/core';
+import { ${className}Model } from './${className}Model';
+
+export class ${className}Controller extends WKController<${className}Model> {
+  onInit(): void {
+    this.model = App.getModel(${className}Model);
+    WKLogger.info('${baseName} module ready.', this.model.enabled);
+  }
+}
+`;
+    }
+    moduleScript(baseName, className, order) {
+        return `import { defineWKModule, WKLayer } from '@wukong-kit/core';
+import { ${className}Controller } from './${className}Controller';
+import { ${className}Model } from './${className}Model';
+
+export const ${className}Module = defineWKModule({
+  name: '${baseName}',
+  order: ${order},
+  model: ${className}Model,
+  controller: ${className}Controller,
+  views: [
+    // <wk-views>
+    // </wk-views>
+  ],
+});
+`;
+    }
+    viewScript(className) {
+        return `import { _decorator } from 'cc';
+import { WKView } from '@wukong-kit/core';
+
+const { ccclass } = _decorator;
+
+@ccclass('${className}')
+export class ${className} extends WKView {
+  override init(): void {
+    // Bind 2D node presentation here.
+  }
+}
+`;
+    }
+    prefabContent(nodeName, compressedScriptUuid) {
+        const nodeFileId = this.generateUUID();
+        const compFileId = this.generateUUID();
+        const data = [
+            {
+                __type__: 'cc.Prefab',
+                _name: nodeName,
+                _objFlags: 0,
+                __editorExtras__: {},
+                _native: '',
+                data: { __id__: 1 },
+                optimizationPolicy: 0,
+                persistent: false,
+            },
+            {
+                __type__: 'cc.Node',
+                _name: nodeName,
+                _objFlags: 0,
+                __editorExtras__: {},
+                _parent: null,
+                _children: [],
+                _active: true,
+                _components: [{ __id__: 2 }],
+                _prefab: { __id__: 4 },
+                _lpos: { __type__: 'cc.Vec3', x: 0, y: 0, z: 0 },
+                _lrot: { __type__: 'cc.Quat', x: 0, y: 0, z: 0, w: 1 },
+                _lscale: { __type__: 'cc.Vec3', x: 1, y: 1, z: 1 },
+                _mobility: 0,
+                _layer: 1073741824,
+                _euler: { __type__: 'cc.Vec3', x: 0, y: 0, z: 0 },
+                _id: '',
+            },
+            {
+                __type__: compressedScriptUuid,
+                _name: '',
+                _objFlags: 0,
+                __editorExtras__: {},
+                node: { __id__: 1 },
+                _enabled: true,
+                __prefab: { __id__: 3 },
+                _id: '',
+            },
+            {
+                __type__: 'cc.CompPrefabInfo',
+                fileId: compFileId,
+            },
+            {
+                __type__: 'cc.PrefabInfo',
+                root: { __id__: 1 },
+                asset: { __id__: 0 },
+                fileId: nodeFileId,
+                instance: null,
+                targetOverrides: null,
+            },
+        ];
+        return JSON.stringify(data, null, 2) + '\n';
+    }
+    requestWithTimeout(pkg, msg, ...args) {
+        const req = Editor.Message.request(pkg, msg, ...args);
+        const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error(`Editor.Message.request timeout: ${pkg}:${msg}`)), 10000));
+        return Promise.race([req, timeout]);
+    }
+    compressUuid(uuid) {
+        const hex = uuid.replace(/-/g, '');
+        if (!/^[0-9a-fA-F]{32}$/.test(hex)) {
+            throw new Error(`Invalid script uuid: ${uuid}`);
+        }
+        const base64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+        let result = hex.slice(0, 5);
+        for (let i = 5; i < hex.length; i += 3) {
+            const value = parseInt(hex.slice(i, i + 3).padEnd(3, '0'), 16);
+            result += base64chars[(value >> 6) & 63];
+            result += base64chars[value & 63];
+        }
+        return result;
+    }
+    generateUUID() {
+        // Fallback for environments where crypto.randomUUID is unavailable (e.g. Cocos extension sandbox)
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    async readScriptUuid(viewPath, timeoutMs) {
+        const metaPath = viewPath + '.meta';
+        const start = Date.now();
+        let attempts = 0;
+        while (!(0, fs_1.existsSync)(metaPath)) {
+            if (Date.now() - start >= timeoutMs) {
+                throw new Error(`Timed out waiting for script .meta after ${attempts} attempts: ${metaPath}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, 200));
+            attempts++;
+        }
+        const raw = (0, fs_1.readFileSync)(metaPath, 'utf8');
+        const meta = JSON.parse(raw);
+        if (!meta.uuid) {
+            throw new Error(`Script .meta missing uuid: ${metaPath}`);
+        }
+        return meta.uuid;
+    }
+    waitForFile(path, timeoutMs) {
+        const start = Date.now();
+        return new Promise((resolve, reject) => {
+            const check = () => {
+                if ((0, fs_1.existsSync)(path)) {
+                    resolve();
+                    return;
+                }
+                if (Date.now() - start >= timeoutMs) {
+                    reject(new Error(`Timed out waiting for file: ${path}`));
+                    return;
+                }
+                setTimeout(check, 100);
+            };
+            check();
+        });
+    }
+    managerScript(className, exportName) {
+        return `import { WKSingleton } from '@wukong-kit/core';
+
+export class ${className} extends WKSingleton {
+  init(): void {}
+
+  dispose(): void {
+    ${className}.clear();
+  }
+}
+
+export const ${exportName} = ${className}.get();
+`;
+    }
+    upsertViewInModule(modulePath, viewClassName, viewName, prefabPath, layer, cache) {
+        let content = (0, fs_1.readFileSync)(modulePath, 'utf8');
+        const importLine = `import { ${viewClassName} } from './views/${viewClassName}';`;
+        if (!content.includes(importLine)) {
+            const exportIndex = content.indexOf('export const ');
+            content = exportIndex >= 0 ? `${content.slice(0, exportIndex)}${importLine}\n${content.slice(exportIndex)}` : `${importLine}\n${content}`;
+        }
+        if (!content.includes('// <wk-views>')) {
+            content = content.replace(/views:\s*\[/, 'views: [\n    // <wk-views>\n    // </wk-views>');
+        }
+        const entry = `    {
+      name: '${viewName}',
+      type: ${viewClassName},
+      prefab: '${prefabPath}',
+      layer: WKLayer.${layer},
+      cache: ${cache},
+    },`;
+        if (!content.includes(`type: ${viewClassName}`)) {
+            content = content.replace('    // </wk-views>', `${entry}\n    // </wk-views>`);
+        }
+        (0, fs_1.writeFileSync)(modulePath, content, 'utf8');
+    }
+    removeViewFromModule(modulePath, viewClassName) {
+        let content = (0, fs_1.readFileSync)(modulePath, 'utf8');
+        const importPattern = new RegExp(`^import \\{ ${viewClassName} \\} from './views/${viewClassName}';\\r?\\n`, 'm');
+        content = content.replace(importPattern, '');
+        const viewEntryPattern = new RegExp(`\\s*\\{\\r?\\n\\s*name: '[^']+',\\r?\\n\\s*type: ${viewClassName},\\r?\\n\\s*prefab: '[^']+',\\r?\\n\\s*layer: WKLayer\\.[A-Za-z]+,\\r?\\n\\s*cache: (?:true|false),\\r?\\n\\s*\\},`, 'm');
+        content = content.replace(viewEntryPattern, '');
+        (0, fs_1.writeFileSync)(modulePath, content, 'utf8');
+    }
+    scanProjectModule(dir) {
+        const files = (0, fs_1.readdirSync)(dir).filter(file => file.endsWith('.ts'));
+        const moduleFile = files.find(file => file.endsWith('Module.ts')) ?? null;
+        const modelFile = files.find(file => file.endsWith('Model.ts')) ?? null;
+        const controllerFile = files.find(file => file.endsWith('Controller.ts')) ?? null;
+        const className = moduleFile ? moduleFile.replace(/Module\.ts$/, '') : this.withWKPrefix(this.toPascalCase((0, path_1.basename)(dir)));
+        const name = className.replace(/^WK/, '');
+        const order = moduleFile ? this.readModuleOrder((0, path_1.join)(dir, moduleFile)) : 100;
+        const viewsDir = (0, path_1.join)(dir, 'views');
+        const views = (0, fs_1.existsSync)(viewsDir)
+            ? (0, fs_1.readdirSync)(viewsDir)
+                .filter(file => file.endsWith('View.ts'))
+                .map(file => ({
+                name: this.toViewDisplayName(file.replace(/\.ts$/, ''), name),
+                className: file.replace(/\.ts$/, ''),
+                scriptPath: (0, path_1.join)(viewsDir, file),
+                displayPath: this.toProjectRelativePath((0, path_1.join)(viewsDir, file))
+            }))
+            : [];
+        if (!moduleFile && !modelFile && !controllerFile && views.length === 0)
+            return null;
+        return {
+            name,
+            className,
+            order,
+            folderPath: dir,
+            displayPath: this.toProjectRelativePath(dir),
+            modelPath: modelFile ? (0, path_1.join)(dir, modelFile) : null,
+            controllerPath: controllerFile ? (0, path_1.join)(dir, controllerFile) : null,
+            modulePath: moduleFile ? (0, path_1.join)(dir, moduleFile) : null,
+            displayFiles: [moduleFile, modelFile, controllerFile].filter((file) => Boolean(file)).map(file => this.toProjectRelativePath((0, path_1.join)(dir, file))),
+            views
+        };
+    }
+    toViewDisplayName(className, moduleName) {
+        return (className
+            .replace(/^WK/, '')
+            .replace(new RegExp(`^${moduleName}`), '')
+            .replace(/View$/, '') || 'Main');
+    }
+    toManagerExportName(name) {
+        const cleanName = name.replace(/^WK/, '');
+        return `${cleanName.charAt(0).toLowerCase()}${cleanName.slice(1)}Manager`;
+    }
+    readModuleOrder(modulePath) {
+        const content = (0, fs_1.readFileSync)(modulePath, 'utf8');
+        const match = content.match(/order:\s*(-?\d+)/);
+        return this.normalizeOrder(match?.[1]);
+    }
+    toProjectRelativePath(path) {
+        return path
+            .replace(this.projectPath, '')
+            .replace(/^[/\\]/, '')
+            .replace(/\\/g, '/');
+    }
+}
+exports.ModuleRegistryService = ModuleRegistryService;
+//# sourceMappingURL=ModuleRegistryService.js.map