diff --git a/extensions/cocos-code-mode/@types/.DS_Store b/extensions/cocos-code-mode/@types/.DS_Store new file mode 100644 index 0000000..05aaa2a Binary files /dev/null and b/extensions/cocos-code-mode/@types/.DS_Store differ diff --git a/extensions/cocos-code-mode/@types/schema/.DS_Store b/extensions/cocos-code-mode/@types/schema/.DS_Store new file mode 100644 index 0000000..5e45c14 Binary files /dev/null and b/extensions/cocos-code-mode/@types/schema/.DS_Store differ diff --git a/extensions/cocos-code-mode/@types/schema/package/.DS_Store b/extensions/cocos-code-mode/@types/schema/package/.DS_Store new file mode 100644 index 0000000..8cade47 Binary files /dev/null and b/extensions/cocos-code-mode/@types/schema/package/.DS_Store differ diff --git a/extensions/cocos-code-mode/@types/schema/package/base/panels.json b/extensions/cocos-code-mode/@types/schema/package/base/panels.json new file mode 100644 index 0000000..9e268fb --- /dev/null +++ b/extensions/cocos-code-mode/@types/schema/package/base/panels.json @@ -0,0 +1,81 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "description": "面板数据 / Panel data", + "additionalProperties": false, + "patternProperties": { + "^[a-zA-Z0-9_-]+$": { + "type": "object", + "description": "面板名 / Panel name", + "properties": { + "title": { + "type": "string", + "default": "Default Panel", + "description": "面板标题，支持 i18n:key / Panel title, support for i18n:key (required)" + }, + "main": { + "type": "string", + "default": "dist/panels/default/index.js", + "description": "入口函数 / Entry function (required)" + }, + "icon": { + "type": "string", + "description": "面板图标存放相对目录 / Relative directory for panel icon storage" + }, + "type": { + "type": "string", + "enum": ["dockable", "simple"], + "default": "dockable", + "description": "面板类型（dockable | simple） / Panel type (dockable | simple)" + }, + "flags": { + "type": "object", + "properties": { + "resizable": { + "type": "boolean", + "default": true, + "description": "是否可以改变大小，默认 true / Whether the size can be changed, default true" + }, + "save": { + "type": "boolean", + "default": true, + "description": "是否需要保存，默认 false / Whether to save, default false" + }, + "alwaysOnTop": { + "type": "boolean", + "default": true, + "description": "是否保持顶层显示，默认 false / Whether to keep the top level display, default false" + } + } + }, + "size": { + "type": "object", + "description": "面板大小信息 / Panel size information", + "properties": { + "min-width": { + "type": "number", + "default": 200, + "description": "面板最小宽度 / Minimum panel width" + }, + "min-height": { + "type": "number", + "default": 200, + "description": "面板最小高度 / Minimum panel height" + }, + "width": { + "type": "number", + "default": 400, + "description": " 面板默认宽度 / Panel Default Width" + }, + "height": { + "type": "number", + "default": 600, + "description": "面板默认高度 / Panel Default Height" + } + } + } + }, + "required": ["title", "main"] + } + } +} diff --git a/extensions/cocos-code-mode/@types/schema/package/contributions/index.json b/extensions/cocos-code-mode/@types/schema/package/contributions/index.json new file mode 100644 index 0000000..263ab76 --- /dev/null +++ b/extensions/cocos-code-mode/@types/schema/package/contributions/index.json @@ -0,0 +1,7 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "description": "其他扩展插件的扩展配置 / Extended configuration for other extension plugins", + "properties": {}, + "required": [] +} diff --git a/extensions/cocos-code-mode/@types/schema/package/index.json b/extensions/cocos-code-mode/@types/schema/package/index.json new file mode 100644 index 0000000..be569fa --- /dev/null +++ b/extensions/cocos-code-mode/@types/schema/package/index.json @@ -0,0 +1,59 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "description": "插件定义文件 / Extension definition file", + "properties": { + "author": { + "type": "string", + "description": "作者 / Author", + "default": "Cocos Creator Developer" + }, + "contributions": { + "$ref": "./contributions/index.json" + }, + "dependencies": { + "type": "object", + "description": "发布时所需的依赖库 / Dependencies required for publishing" + }, + "description": { + "type": "string", + "description": "简要介绍扩展关键特性、用途，支持 i18n / Brief introduction of the key features and uses of the extension, supporting i18n" + }, + "devDependencies": { + "type": "object", + "description": "开发时所需的依赖库 / Dependencies required for development" + }, + "editor": { + "type": "string", + "description": "支持的 Cocos Creator 编辑器版本，支持 semver 格式 / Supported Cocos Creator editor version, supporting semver format" + }, + "main": { + "type": "string", + "description": "入口函数 / Entry function", + "default": "./dist/index.js" + }, + "name": { + "type": "string", + "description": "不能以 _ 或 . 开头、不能含有大写字母，也不能含有 URL 的非法字符例如 .、' 和 ,。 / Cannot start with _ or., cannot contain uppercase letters, and cannot contain URL illegal characters such as.,'and,", + "default": "Custom Extension" + }, + "package_version": { + "type": "number", + "description": "扩展系统预留版本号 / Extension system reserved version number", + "default": 2 + }, + "panels": { + "$ref": "./base/panels.json" + }, + "scripts": { + "type": "object", + "description": "NPM 脚本 / NPM scripts" + }, + "version": { + "type": "string", + "description": "版本号字符串 / Version number string", + "default": "1.0.0" + } + }, + "required": ["author", "name", "package_version", "version"] +} diff --git a/extensions/cocos-code-mode/README.md b/extensions/cocos-code-mode/README.md new file mode 100644 index 0000000..7d32161 --- /dev/null +++ b/extensions/cocos-code-mode/README.md @@ -0,0 +1,219 @@ +# Code Mode for Cocos Creator + +**Code Mode** turns the Cocos Creator Editor into an AI-controllable tool. It runs an HTTP server inside the editor that exposes scene manipulation, asset management, and property inspection as structured tool calls via [UTCP Protocol](https://www.utcp.io/) — letting AI agents build, inspect, and modify Cocos Creator projects the same way a developer would through the UI. +These tools are combined in [UTCP Code Mode](https://github.com/universal-tool-calling-protocol/code-mode/) environment to achieve maximum performance and token efficiency for AI agents, letting them call the tools in isolated JS sandbox. + +## Tools + +![Tools <> UI Mapping](tools_screenshot.jpg) + +| Category | Tools | Purpose | +|----------|-------|---------| +| **Scene** | `nodeGetTree`, `nodeGetAtPath`, `nodeCreate`, `nodeCreatePrimitive`, `nodeOperate` | Navigate and build scene hierarchy | +| **Components** | `nodeComponentsGet`, `nodeComponentAdd`, `nodeComponentRemove`, `nodeGetAvailableComponentTypes` | Attach, remove, and discover components | +| **Inspector** | `inspectorGetInstanceDefinition`, `inspectorGetSettingsDefinition`, `inspectorGetInstanceProperties`, `inspectorGetSettingsProperties`, `inspectorSetInstanceProperties`, `inspectorSetSettingsProperties` | Introspect types and read/write properties | +| **Assets** | `assetGetTree`, `assetGetAtPath`, `assetCreate`, `assetImport`, `assetOperate`, `assetGetPreview` | Browse, create, and manage project assets | +| **Editor** | `editorOperate`, `editorGetLogs`, `editorGetScenePreview` | Control editor state and capture previews | + + +## How It Works + +**Code Mode** follows a **discover, then act** pattern. AI agents never guess at property names or component structures — they query for the real definitions first. + +``` +1. Get the scene tree → find the node you need +2. Get its type definition → learn its actual properties +3. Set properties by name → make precise changes +``` + +### Example + +```typescript +// Find the camera node +const tree = CocosEditor.nodeGetTree({}); +const cameraRef = tree.children[0].components[0]; // component reference + +// Discover what properties Camera has +const def = CocosEditor.inspectorGetInstanceDefinition({ reference: cameraRef }); +// → "export class Camera { fov: number; near: number; far: number; ... }" + +// Set multiple properties in one call +CocosEditor.inspectorSetInstanceProperties({ + reference: cameraRef, + propertyPaths: ["fov", "near", "far"], + values: [60, 0.1, 1000] +}); +``` + +## Architecture + +### Tool Execution + +The extension runs an Express.js HTTP server on a configurable port (default: auto-assigned). Tool handlers execute asynchronously using Cocos Creator's Editor Message API — all editor interactions go through `Editor.Message.request`, which marshals calls to the appropriate editor subsystem. + +- **Read tools** (GET) — query scene state and return structured data immediately. +- **Write tools** (POST) — mutate scene state and call `Editor.Message.request('scene', 'snapshot')` to register the change as an undoable step. + +This means AI agents can safely chain read calls and batch writes without blocking the editor. + +### Tool Discovery + +Tools are TypeScript class methods decorated with `@utcpTool`. The `ToolRegistry` collects them at startup, builds JSON schemas from the inline definitions, and serves a UTCP manual at the `/utcp` endpoint. + +```typescript +export class SceneTools { + + @utcpTool( + 'nodeGetTree', + 'Get the hierarchy tree of specific node or scene root if no reference is provided.', + { + type: 'object', + properties: { + reference: InstanceReferenceSchema + } + }, + SceneTreeItemSchema, "GET", ['scene', 'graph', 'node', 'hierarchy', 'tree'] + ) + async nodeGetTree(args: { reference?: IInstanceReference }): Promise { + // ... + } +} +``` + +### Instance References + +Nodes, components, and assets are passed around as lightweight UUID-based handles: + +```typescript +{ id: "a1b2c3d4-...", type: "cc.Camera" } +``` + +Returned by tree queries, component lookups, and creation tools. Passed back to any tool that needs to target a specific object. + +### TypeScript Definitions + +Code Mode dynamically generates TypeScript class definitions from the live editor property dump. When an AI agent calls `inspectorGetInstanceDefinition`, it receives a complete TypeScript class with the correct field names, types, enums, and decorator hints — including `@property` attributes like `min`, `max`, `unit`, and `tooltip`. + +```typescript +// Example output for a Transform-like node +export class Node { + readonly uuid: string; + /** World position */ + worldPosition: Vec3; + /** World rotation (euler angles) */ + worldRotation: Vec3; + worldScale: Vec3; + active: boolean; +} +``` + +Components without special handling are reflected automatically from the serialized property dump. Common Cocos math types (`Vec2`, `Vec3`, `Vec4`, `Color`, `Rect`, `Quat`, `Mat4`, `Gradient`, etc.) are always available via `inspectorGetSettingsDefinition({ settingsType: 'CommonTypes' })`. + +### Settings Inspection + +Two special settings types can be inspected and modified directly: +- **`CurrentSceneGlobals`** — ambient light, skybox, shadows, and other scene-level rendering settings. +- **`ProjectSettings`** — engine and project configuration. + +## Installation + +### From release + +1. Download last release from this repository. +2. Open Cocos Creator, go to **Extension → Extension Manager**, and click `Import Extension File(.zip)` button (icon with arrow). +3. Select the downloaded zip file. +4. The UTCP server starts automatically and registers itself in `~/.utcp_config.json` by default. + +### Build from source + +1. Clone this repository. +2. Install `node` and `npm`. +3. run +```bash +git clone https://github.com/romarogov/cocos-code-mode.git +cd cocos-code-mode +npm i +npm run package +``` +4. If everything builds fine, `cocos-code-mode.zip` file should appear in repository root. +5. Install it in Cocos Creator with **Extension Manager**. + +## Adding Custom Tools + +You should add custom tools right in extension package and build it from source as described above. + +Implementation example: + +```typescript +import { utcpTool } from './utcp/decorators'; + +export class MyTools { + + @utcpTool( + 'myCustomTool', + 'Describe what this tool does', + { + type: 'object', + properties: { + input: { type: 'string' }, + count: { type: 'number', default: 10 } + }, + required: ['input'] + }, + { type: 'object', properties: { result: { type: 'string' } } }, + "POST", + ['custom', 'tags'] + ) + async myCustomTool(args: { input: string, count?: number }): Promise<{ result: string }> { + // Implementation + } +} +``` + +Register the class by importing it in `utcp-server.ts`. Tools are served automatically at startup. No additional registration needed. + +## UTCP Call Templates Configuration + +The extension provides a **Configuration** panel accessible from the **Code Mode** top menu. It shows the current server port, the path to the UTCP config file, and lets you manage additional UTCP call templates to connect other UTCP-compatible tool providers (including MCP servers) into the same Code Mode execution context. + +You can find Call Template structures in [UTCP documentation](https://www.utcp.io/protocols): +- [MCP Call Template](https://utcp.io/protocols/mcp#call-template-structure) +- [HTTP Call Template](https://utcp.io/protocols/http#call-template-structure) ([Streamable](https://utcp.io/protocols/http#call-template-structure), [SSE](https://utcp.io/protocols/http#call-template-structure)) +- [CLI Call Template](https://utcp.io/protocols/cli#call-template-structure) +- [Text Call Template](http://utcp.io/protocols/text#call-template-structure) + +The extension automatically maintains a `CocosEditor` entry in UTCP Config pointing to the running server port. + +## Integration + +Code Mode works with any UTCP-compatible client, including the [Code Mode MCP server](https://github.com/universal-tool-calling-protocol/code-mode/?tab=readme-ov-file#even-easier-ready-to-use-mcp-server) for AI assistants. + +### MCP Server Config + +```json +{ + "mcpServers": { + "code-mode": { + "command": "npx", + "args": ["@utcp/code-mode-mcp"], + "env": { + "UTCP_CONFIG_FILE": "~/.utcp_config.json" + } + } + } +} +``` + +### Claude Code Configuration + +To set up a Claude Code agent to use Code Mode, open your project and run: + +Linux/MacOS: +``` bash +claude mcp add --transport stdio --env UTCP_CONFIG_FILE="~/.utcp_config.json" -- code-mode npx @utcp/code-mode-mcp +``` + +Windows: +``` powershell +claude mcp add --transport stdio --env UTCP_CONFIG_FILE="%userprofile%/.utcp_config.json" -- code-mode cmd /c npx @utcp/code-mode-mcp +``` \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/main.js b/extensions/cocos-code-mode/dist/main.js new file mode 100644 index 0000000..9353e4a --- /dev/null +++ b/extensions/cocos-code-mode/dist/main.js @@ -0,0 +1,70 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.methods = void 0; +exports.load = load; +exports.unload = unload; +const package_json_1 = __importDefault(require("../package.json")); +const utcp_server_1 = require("./utcp/utcp-server"); +const config_manager_1 = require("./utcp/config-manager"); +let utcpServer = null; +exports.methods = { + openPanel() { + Editor.Panel.open(package_json_1.default.name + '.configuration'); + }, + openPreviewPanel() { + Editor.Panel.open(package_json_1.default.name + '.preview'); + }, + async restartServer(newPort) { + if (utcpServer) { + console.log(`[${package_json_1.default.name}] Restarting UTCP Server on port ${newPort}...`); + utcpServer.stop(); + try { + const actualPort = await utcpServer.start(newPort); + console.log(`[${package_json_1.default.name}] UTCP Server restarted on port ${actualPort}`); + // Используем менеджер конфигурации для обновления порта + const configManager = (0, config_manager_1.getConfigManager)(); + await configManager.updatePort(actualPort); + } + catch (err) { + console.error(`[${package_json_1.default.name}] Failed to restart UTCP Server:`, err); + } + } + } +}; +async function load() { + // Initialize config manager + const configManager = (0, config_manager_1.getConfigManager)(); + await configManager.initialize(); + utcpServer = new utcp_server_1.UtcpServerManager(); + let wasConfiguredPort = true; + // Load port from profile, default to 0 (random free port) if not set + let port = await Editor.Profile.getConfig(package_json_1.default.name, 'serverPort'); + if (typeof port !== 'number') { + port = 0; + wasConfiguredPort = false; + } + try { + const actualPort = await utcpServer.start(port); + console.log(`[${package_json_1.default.name}] UTCP Server started on port ${actualPort}`); + // Automatically update the port in the configuration on startup + await configManager.updatePort(actualPort); + console.log(`[${package_json_1.default.name}] UTCP config automatically updated with port ${actualPort}`); + } + catch (err) { + console.error(`[${package_json_1.default.name}] Failed to start UTCP Server:`, err); + } + if (!wasConfiguredPort) { + Editor.Panel.open(package_json_1.default.name); + } +} +function unload() { + if (utcpServer) { + console.log(`[${package_json_1.default.name}] Stopping UTCP Server...`); + utcpServer.stop(); + utcpServer = null; + } +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/panels/configuration/index.js b/extensions/cocos-code-mode/dist/panels/configuration/index.js new file mode 100644 index 0000000..78e2cd8 --- /dev/null +++ b/extensions/cocos-code-mode/dist/panels/configuration/index.js @@ -0,0 +1,201 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const package_json_1 = __importDefault(require("../../../package.json")); +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +const config_manager_1 = require("../../utcp/config-manager"); +module.exports = Editor.Panel.define({ + listeners: { + show() { console.log('show'); }, + hide() { console.log('hide'); }, + }, + template: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/template/configuration/index.html'), 'utf-8'), + style: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/style/configuration/index.css'), 'utf-8'), + $: { + app: '.panel', + portInput: '#port-input', + savePortBtn: '#save-port-btn', + // MCP Integration + mcpConfigCode: '#mcp-config-code', + // UTCP Config + utcpConfigPathInput: '#utcp-config-path', + utcpConfigPathSaveBtn: '#save-utcp-path-btn', + bridgeList: '#bridge-container', + addBridgeBtn: '#add-bridge-btn', + newTemplateJson: '#new-template-json', + }, + methods: { + async loadSettings() { + const configManager = (0, config_manager_1.getConfigManager)(); + await configManager.initialize(); + // Update UI with config path + if (this.$.utcpConfigPathInput) { + this.$.utcpConfigPathInput.value = configManager.getConfigPath(); + } + // Load Port + const port = await configManager.getCurrentPort(); + if (this.$.portInput) { + this.$.portInput.value = port || 0; + } + this.updateMcpCodeBlock(); + this.fetchBridgeList(); + }, + async saveSettings() { + const newPath = this.$.utcpConfigPathInput.value; + if (newPath) { + const configManager = (0, config_manager_1.getConfigManager)(); + await configManager.setConfigPath(newPath); + this.updateMcpCodeBlock(); + this.fetchBridgeList(); // Reload templates from new path + console.log('Saved UTCP Config Path:', newPath); + } + }, + async updatePort() { + const portVal = this.$.portInput.value; + const port = parseInt(portVal); + console.log(`Updating port to: ${port}`); + // Send message to main process to restart server + Editor.Message.send(package_json_1.default.name, 'restart-server', port); + }, + updateMcpCodeBlock() { + const codeEl = this.$.mcpConfigCode; + if (!codeEl) + return; + const configManager = (0, config_manager_1.getConfigManager)(); + const configPath = configManager.getConfigPath(); + const config = { + "mcpServers": { + "code-mode": { + "command": "npx", + "args": ["-y", "@utcp/code-mode-mcp"], + "env": { + "UTCP_CONFIG_FILE": configPath + } + } + } + }; + codeEl.textContent = JSON.stringify(config, null, 2); + }, + fetchBridgeList() { + const container = this.$.bridgeList; + if (!container) { + console.warn('Bridge Config Container not found'); + return; + } + // Clear "Loading..." or previous content + container.innerHTML = ''; + const configManager = (0, config_manager_1.getConfigManager)(); + const config = configManager.readConfig(); + const templates = config.manual_call_templates || []; + if (templates.length === 0) { + container.innerHTML = '
No templates found.
'; + } + else { + let html = ''; + templates.forEach((t) => { + const isCocos = t.name === 'CocosEditor'; + const delBtn = isCocos + ? `` // No delete for Cocos + : ` + + `; + const headerText = `${t.name} (${t.call_template_type})`; + html += ` + +
+ ${headerText} + ${delBtn} +
+
+ +
+ + `; + }); + container.innerHTML = html; + // Now populate the code values correctly + templates.forEach((t) => { + const el = container.querySelector(`#code-${t.name}`); + if (el) + el.textContent = JSON.stringify(t, null, 2); + }); + } + }, + addBridgeTemplate() { + const input = this.$.newTemplateJson; + if (!input) + return; + const content = input.value.trim(); + if (!content) + return; + try { + let newTpl = JSON.parse(content); + // Validate with @utcp/sdk or simple schema + if (!newTpl.name || !newTpl.call_template_type) { + alert('Invalid template. Must have name and call_template_type.'); + return; + } + const configManager = (0, config_manager_1.getConfigManager)(); + const config = configManager.readConfig(); + // Check duplicates + if (config.manual_call_templates.find((t) => t.name === newTpl.name)) { + alert(`Template ${newTpl.name} already exists.`); + return; + } + config.manual_call_templates.push(newTpl); + configManager.writeConfig(config); + input.value = ''; + this.fetchBridgeList(); + } + catch (e) { + alert('Invalid JSON: ' + e.message); + } + }, + removeBridge(name) { + if (name === 'CocosEditor') + return; + if (!confirm(`Remove template ${name}?`)) + return; + const configManager = (0, config_manager_1.getConfigManager)(); + const config = configManager.readConfig(); + if (config.manual_call_templates) { + config.manual_call_templates = config.manual_call_templates.filter((t) => t.name !== name); + configManager.writeConfig(config); + this.fetchBridgeList(); + } + }, + }, + ready() { + this.loadSettings(); + // Listeners + const savePort = this.$.savePortBtn; + if (savePort) + savePort.addEventListener('click', () => this.updatePort()); + const savePath = this.$.utcpConfigPathSaveBtn; + if (savePath) + savePath.addEventListener('click', () => this.saveSettings()); + const addBtn = this.$.addBridgeBtn; + if (addBtn) + addBtn.addEventListener('click', () => this.addBridgeTemplate()); + const list = this.$.bridgeList; + if (list) { + list.addEventListener('click', (e) => { + // Handle delete clicks + const btn = e.target.closest('.remove-btn'); + if (btn) { + // In new structure, btn is inside .bridge-item-content inside ui-section + const section = btn.closest('.bridge-item-section'); + if (section && section.dataset.name) { + this.removeBridge(section.dataset.name); + } + } + }); + } + }, + beforeClose() { }, + close() { }, +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/panels/configuration/index.ts"],"names":[],"mappings":"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","sourcesContent":["import packageJSON from '../../../package.json';\nimport { readFileSync } from 'fs-extra';\nimport { join } from 'path';\nimport { getConfigManager } from '../../utcp/config-manager';\n\nmodule.exports = Editor.Panel.define({\n    listeners: {\n        show() { console.log('show'); },\n        hide() { console.log('hide'); },\n    },\n    template: readFileSync(join(__dirname, '../../../static/template/configuration/index.html'), 'utf-8'),\n    style: readFileSync(join(__dirname, '../../../static/style/configuration/index.css'), 'utf-8'),\n    $: {\n        app: '.panel',\n        portInput: '#port-input',\n        savePortBtn: '#save-port-btn',\n\n        // MCP Integration\n        mcpConfigCode: '#mcp-config-code',\n        \n        // UTCP Config\n        utcpConfigPathInput: '#utcp-config-path',\n        utcpConfigPathSaveBtn: '#save-utcp-path-btn',\n        bridgeList: '#bridge-container',\n        addBridgeBtn: '#add-bridge-btn',\n        newTemplateJson: '#new-template-json',\n    },\n\n    methods: {\n        async loadSettings() {\n            const configManager = getConfigManager();\n            await configManager.initialize();\n\n            // Update UI with config path\n            if (this.$.utcpConfigPathInput) {\n                (this.$.utcpConfigPathInput as any).value = configManager.getConfigPath();\n            }\n\n            // Load Port\n            const port = await configManager.getCurrentPort();\n            if (this.$.portInput) {\n                (this.$.portInput as any).value = port || 0;\n            }\n\n            this.updateMcpCodeBlock();\n            this.fetchBridgeList();\n        },\n\n        async saveSettings() {\n            const newPath = (this.$.utcpConfigPathInput as any).value;\n            if (newPath) {\n                const configManager = getConfigManager();\n                await configManager.setConfigPath(newPath);\n                this.updateMcpCodeBlock();\n                this.fetchBridgeList(); // Reload templates from new path\n                console.log('Saved UTCP Config Path:', newPath);\n            }\n        },\n\n        async updatePort() {\n            const portVal = (this.$.portInput as any).value;\n            const port = parseInt(portVal);\n            console.log(`Updating port to: ${port}`);\n            // Send message to main process to restart server\n            Editor.Message.send(packageJSON.name, 'restart-server', port);\n        },\n\n        updateMcpCodeBlock() {\n            const codeEl = this.$.mcpConfigCode as HTMLElement;\n            if (!codeEl) return;\n\n            const configManager = getConfigManager();\n            const configPath = configManager.getConfigPath();\n\n            const config = {\n                \"mcpServers\": {\n                    \"code-mode\": {\n                        \"command\": \"npx\",\n                        \"args\": [\"-y\", \"@utcp/code-mode-mcp\"],\n                        \"env\": {\n                            \"UTCP_CONFIG_FILE\": configPath\n                        }\n                    }\n                }\n            };\n\n            codeEl.textContent = JSON.stringify(config, null, 2);\n        },\n\n        fetchBridgeList() {\n            const container = this.$.bridgeList as HTMLElement;\n            if (!container) {\n                console.warn('Bridge Config Container not found');\n                return;\n            }\n\n            // Clear \"Loading...\" or previous content\n            container.innerHTML = '';\n\n            const configManager = getConfigManager();\n            const config = configManager.readConfig();\n            const templates = config.manual_call_templates || [];\n\n            if (templates.length === 0) {\n                container.innerHTML = '<div style=\"padding:10px; color: #888;\">No templates found.</div>';\n            } else {\n                let html = '';\n                templates.forEach((t: any) => {\n                    const isCocos = t.name === 'CocosEditor';\n                    const delBtn = isCocos\n                        ? `` // No delete for Cocos\n                        : `<ui-button slot=\"header\" type=\"danger\" class=\"remove-btn\" tooltip=\"Remove Template\">\n                             <ui-icon value=\"del\"></ui-icon>\n                           </ui-button>`;\n\n                    const headerText = `${t.name} (${t.call_template_type})`;\n\n                    html += `\n                    <ui-section class=\"bridge-item-section\" data-name=\"${t.name}\">\n                        <div slot=\"header\" style=\"display: flex; justify-content: space-between; align-items: center; width: 100%; padding-right: 10px;\">\n                            <ui-label>${headerText}</ui-label>\n                            ${delBtn}\n                        </div>\n                        <div class=\"bridge-item-content\">\n                             <ui-code language=\"json\" readonly id=\"code-${t.name}\"></ui-code>\n                        </div>\n                    </ui-section>\n                    `;\n                });\n                container.innerHTML = html;\n\n                // Now populate the code values correctly\n                templates.forEach((t: any) => {\n                    const el = container.querySelector(`#code-${t.name}`) as any;\n                    if (el) el.textContent = JSON.stringify(t, null, 2);\n                });\n            }\n        },\n\n        addBridgeTemplate() {\n            const input = this.$.newTemplateJson as any;\n            if (!input) return;\n            const content = input.value.trim();\n            if (!content) return;\n\n            try {\n                let newTpl = JSON.parse(content);\n                // Validate with @utcp/sdk or simple schema\n                if (!newTpl.name || !newTpl.call_template_type) {\n                    alert('Invalid template. Must have name and call_template_type.');\n                    return;\n                }\n\n                const configManager = getConfigManager();\n                const config = configManager.readConfig();\n\n                // Check duplicates\n                if (config.manual_call_templates.find((t: any) => t.name === newTpl.name)) {\n                    alert(`Template ${newTpl.name} already exists.`);\n                    return;\n                }\n\n                config.manual_call_templates.push(newTpl);\n                configManager.writeConfig(config);\n                input.value = '';\n                this.fetchBridgeList();\n\n            } catch (e: any) {\n                alert('Invalid JSON: ' + e.message);\n            }\n        },\n\n        removeBridge(name: string) {\n            if (name === 'CocosEditor') return;\n            if (!confirm(`Remove template ${name}?`)) return;\n\n            const configManager = getConfigManager();\n            const config = configManager.readConfig();\n            if (config.manual_call_templates) {\n                config.manual_call_templates = config.manual_call_templates.filter((t: any) => t.name !== name);\n                configManager.writeConfig(config);\n                this.fetchBridgeList();\n            }\n        },\n    },\n    ready() {\n        this.loadSettings();\n\n        // Listeners\n        const savePort = this.$.savePortBtn as HTMLElement;\n        if (savePort) savePort.addEventListener('click', () => this.updatePort());\n\n        const savePath = this.$.utcpConfigPathSaveBtn as HTMLElement;\n        if (savePath) savePath.addEventListener('click', () => this.saveSettings());\n\n        const addBtn = this.$.addBridgeBtn as HTMLElement;\n        if (addBtn) addBtn.addEventListener('click', () => this.addBridgeTemplate());\n\n        const list = this.$.bridgeList as HTMLElement;\n        if (list) {\n            list.addEventListener('click', (e: any) => {\n                // Handle delete clicks\n                const btn = e.target.closest('.remove-btn');\n                if (btn) {\n                    // In new structure, btn is inside .bridge-item-content inside ui-section\n                    const section = btn.closest('.bridge-item-section');\n                    if (section && section.dataset.name) {\n                        this.removeBridge(section.dataset.name);\n                    }\n                }\n            });\n        }\n    },\n    beforeClose() { },\n    close() { },\n});"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/panels/default/index.js b/extensions/cocos-code-mode/dist/panels/default/index.js new file mode 100644 index 0000000..b81525c --- /dev/null +++ b/extensions/cocos-code-mode/dist/panels/default/index.js @@ -0,0 +1,204 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +const config_manager_1 = require("../../utcp/config-manager"); +/** + * @zh 如果希望兼容 3.3 之前的版本可以使用下方的代码 + * @en You can add the code below if you want compatibility with versions prior to 3.3 + */ +// Editor.Panel.define = Editor.Panel.define || function(options: any) { return options } +module.exports = Editor.Panel.define({ + listeners: { + show() { console.log('show'); }, + hide() { console.log('hide'); }, + }, + template: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/template/default/index.html'), 'utf-8'), + style: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/style/default/index.css'), 'utf-8'), + $: { + app: '.panel', + portInput: '#port-input', + savePortBtn: '#save-port-btn', + // MCP Integration + mcpConfigCode: '#mcp-config-code', + // UTCP Config + utcpConfigPathInput: '#utcp-config-path', + utcpConfigPathSaveBtn: '#save-utcp-path-btn', + bridgeList: '#bridge-container', + addBridgeBtn: '#add-bridge-btn', + newTemplateJson: '#new-template-json', + }, + methods: { + async loadSettings() { + const configManager = (0, config_manager_1.getConfigManager)(); + await configManager.initialize(); + // Update UI with config path + if (this.$.utcpConfigPathInput) { + this.$.utcpConfigPathInput.value = configManager.getConfigPath(); + } + // Load Port + const port = await configManager.getCurrentPort(); + if (this.$.portInput) { + this.$.portInput.value = port || 0; + } + this.updateMcpCodeBlock(); + this.fetchBridgeList(); + }, + async saveSettings() { + const newPath = this.$.utcpConfigPathInput.value; + if (newPath) { + const configManager = (0, config_manager_1.getConfigManager)(); + await configManager.setConfigPath(newPath); + this.updateMcpCodeBlock(); + this.fetchBridgeList(); // Reload templates from new path + console.log('Saved UTCP Config Path:', newPath); + } + }, + async updatePort() { + const portVal = this.$.portInput.value; + const port = parseInt(portVal); + console.log(`Updating port to: ${port}`); + // Send message to main process to restart server + Editor.Message.send('cocos-code-mode-ai', 'restart-server', port); + }, + updateMcpCodeBlock() { + const codeEl = this.$.mcpConfigCode; + if (!codeEl) + return; + const configManager = (0, config_manager_1.getConfigManager)(); + const configPath = configManager.getConfigPath(); + const config = { + "mcpServers": { + "code-mode": { + "command": "npx", + "args": ["-y", "@utcp/code-mode-mcp"], + "env": { + "UTCP_CONFIG_FILE": configPath + } + } + } + }; + codeEl.textContent = JSON.stringify(config, null, 2); + }, + // Renamed from fetchBridgeList to be more generic 'renderTemplates' logic + fetchBridgeList() { + const container = this.$.bridgeList; + if (!container) { + console.warn('Bridge Config Container not found'); + return; + } + // Clear "Loading..." or previous content + container.innerHTML = ''; + const configManager = (0, config_manager_1.getConfigManager)(); + const config = configManager.readConfig(); + const templates = config.manual_call_templates || []; + console.log('Rendering templates:', templates.length); + if (templates.length === 0) { + container.innerHTML = '
No templates found.
'; + } + else { + let html = ''; + templates.forEach((t) => { + const isCocos = t.name === 'CocosEditor'; + const delBtn = isCocos + ? `` // No delete for Cocos + : ` + + `; + const headerText = `${t.name} (${t.call_template_type})`; + html += ` + +
+ ${headerText} + ${delBtn} +
+
+ +
+ + `; + }); + container.innerHTML = html; + // Now populate the code values correctly + templates.forEach((t) => { + const el = container.querySelector(`#code-${t.name}`); + if (el) + el.textContent = JSON.stringify(t, null, 2); + }); + } + }, + addBridgeTemplate() { + const input = this.$.newTemplateJson; + if (!input) + return; + const content = input.value.trim(); + if (!content) + return; + try { + let newTpl = JSON.parse(content); + // Validate with @utcp/sdk or simple schema + if (!newTpl.name || !newTpl.call_template_type) { + alert('Invalid template. Must have name and call_template_type.'); + return; + } + const configManager = (0, config_manager_1.getConfigManager)(); + const config = configManager.readConfig(); + // Check duplicates + if (config.manual_call_templates.find((t) => t.name === newTpl.name)) { + alert(`Template ${newTpl.name} already exists.`); + return; + } + config.manual_call_templates.push(newTpl); + configManager.writeConfig(config); + input.value = ''; + this.fetchBridgeList(); + } + catch (e) { + alert('Invalid JSON: ' + e.message); + } + }, + removeBridge(name) { + if (name === 'CocosEditor') + return; + if (!confirm(`Remove template ${name}?`)) + return; + const configManager = (0, config_manager_1.getConfigManager)(); + const config = configManager.readConfig(); + if (config.manual_call_templates) { + config.manual_call_templates = config.manual_call_templates.filter((t) => t.name !== name); + configManager.writeConfig(config); + this.fetchBridgeList(); + } + }, + }, + ready() { + this.loadSettings(); + // Listeners + const savePort = this.$.savePortBtn; + if (savePort) + savePort.addEventListener('click', () => this.updatePort()); + const savePath = this.$.utcpConfigPathSaveBtn; + if (savePath) + savePath.addEventListener('click', () => this.saveSettings()); + const addBtn = this.$.addBridgeBtn; + if (addBtn) + addBtn.addEventListener('click', () => this.addBridgeTemplate()); + const list = this.$.bridgeList; + if (list) { + list.addEventListener('click', (e) => { + // Handle delete clicks + const btn = e.target.closest('.remove-btn'); + if (btn) { + // In new structure, btn is inside .bridge-item-content inside ui-section + const section = btn.closest('.bridge-item-section'); + if (section && section.dataset.name) { + this.removeBridge(section.dataset.name); + } + } + }); + } + }, + beforeClose() { }, + close() { }, +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/panels/default/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync } from 'fs-extra';\nimport { join } from 'path';\nimport { getConfigManager } from '../../utcp/config-manager';\nimport { CallTemplateSerializer } from '@utcp/sdk';\n\n/**\n * @zh 如果希望兼容 3.3 之前的版本可以使用下方的代码\n * @en You can add the code below if you want compatibility with versions prior to 3.3\n */\n// Editor.Panel.define = Editor.Panel.define || function(options: any) { return options }\n\nmodule.exports = Editor.Panel.define({\n    listeners: {\n        show() { console.log('show'); },\n        hide() { console.log('hide'); },\n    },\n    template: readFileSync(join(__dirname, '../../../static/template/default/index.html'), 'utf-8'),\n    style: readFileSync(join(__dirname, '../../../static/style/default/index.css'), 'utf-8'),\n    $: {\n        app: '.panel',\n        portInput: '#port-input',\n        savePortBtn: '#save-port-btn',\n\n        // MCP Integration\n        mcpConfigCode: '#mcp-config-code',\n\n        // UTCP Config\n        utcpConfigPathInput: '#utcp-config-path',\n        utcpConfigPathSaveBtn: '#save-utcp-path-btn',\n        bridgeList: '#bridge-container',\n        addBridgeBtn: '#add-bridge-btn',\n        newTemplateJson: '#new-template-json',\n    },\n\n    methods: {\n        async loadSettings() {\n            const configManager = getConfigManager();\n            await configManager.initialize();\n\n            // Update UI with config path\n            if (this.$.utcpConfigPathInput) {\n                (this.$.utcpConfigPathInput as any).value = configManager.getConfigPath();\n            }\n\n            // Load Port\n            const port = await configManager.getCurrentPort();\n            if (this.$.portInput) {\n                (this.$.portInput as any).value = port || 0;\n            }\n\n            this.updateMcpCodeBlock();\n            this.fetchBridgeList();\n        },\n\n        async saveSettings() {\n            const newPath = (this.$.utcpConfigPathInput as any).value;\n            if (newPath) {\n                const configManager = getConfigManager();\n                await configManager.setConfigPath(newPath);\n                this.updateMcpCodeBlock();\n                this.fetchBridgeList(); // Reload templates from new path\n                console.log('Saved UTCP Config Path:', newPath);\n            }\n        },\n\n        async updatePort() {\n            const portVal = (this.$.portInput as any).value;\n            const port = parseInt(portVal);\n            console.log(`Updating port to: ${port}`);\n            // Send message to main process to restart server\n            Editor.Message.send('cocos-code-mode-ai', 'restart-server', port);\n        },\n\n        updateMcpCodeBlock() {\n            const codeEl = this.$.mcpConfigCode as HTMLElement;\n            if (!codeEl) return;\n\n            const configManager = getConfigManager();\n            const configPath = configManager.getConfigPath();\n\n            const config = {\n                \"mcpServers\": {\n                    \"code-mode\": {\n                        \"command\": \"npx\",\n                        \"args\": [\"-y\", \"@utcp/code-mode-mcp\"],\n                        \"env\": {\n                            \"UTCP_CONFIG_FILE\": configPath\n                        }\n                    }\n                }\n            };\n\n            codeEl.textContent = JSON.stringify(config, null, 2);\n        },\n\n        // Renamed from fetchBridgeList to be more generic 'renderTemplates' logic\n        fetchBridgeList() {\n            const container = this.$.bridgeList as HTMLElement;\n            if (!container) {\n                console.warn('Bridge Config Container not found');\n                return;\n            }\n\n            // Clear \"Loading...\" or previous content\n            container.innerHTML = '';\n\n            const configManager = getConfigManager();\n            const config = configManager.readConfig();\n            const templates = config.manual_call_templates || [];\n\n            console.log('Rendering templates:', templates.length);\n\n            if (templates.length === 0) {\n                container.innerHTML = '<div style=\"padding:10px; color: #888;\">No templates found.</div>';\n            } else {\n                let html = '';\n                templates.forEach((t: any) => {\n                    const isCocos = t.name === 'CocosEditor';\n                    const delBtn = isCocos\n                        ? `` // No delete for Cocos\n                        : `<ui-button slot=\"header\" type=\"danger\" class=\"remove-btn\" tooltip=\"Remove Template\">\n                             <ui-icon value=\"del\"></ui-icon>\n                           </ui-button>`;\n\n                    const headerText = `${t.name} (${t.call_template_type})`;\n\n                    html += `\n                    <ui-section class=\"bridge-item-section\" data-name=\"${t.name}\">\n                        <div slot=\"header\" style=\"display: flex; justify-content: space-between; align-items: center; width: 100%; padding-right: 10px;\">\n                            <ui-label>${headerText}</ui-label>\n                            ${delBtn}\n                        </div>\n                        <div class=\"bridge-item-content\">\n                             <ui-code language=\"json\" readonly id=\"code-${t.name}\"></ui-code>\n                        </div>\n                    </ui-section>\n                    `;\n                });\n                container.innerHTML = html;\n\n                // Now populate the code values correctly\n                templates.forEach((t: any) => {\n                    const el = container.querySelector(`#code-${t.name}`) as any;\n                    if (el) el.textContent = JSON.stringify(t, null, 2);\n                });\n            }\n        },\n\n        addBridgeTemplate() {\n            const input = this.$.newTemplateJson as any;\n            if (!input) return;\n            const content = input.value.trim();\n            if (!content) return;\n\n            try {\n                let newTpl = JSON.parse(content);\n                // Validate with @utcp/sdk or simple schema\n                if (!newTpl.name || !newTpl.call_template_type) {\n                    alert('Invalid template. Must have name and call_template_type.');\n                    return;\n                }\n\n                const configManager = getConfigManager();\n                const config = configManager.readConfig();\n\n                // Check duplicates\n                if (config.manual_call_templates.find((t: any) => t.name === newTpl.name)) {\n                    alert(`Template ${newTpl.name} already exists.`);\n                    return;\n                }\n\n                config.manual_call_templates.push(newTpl);\n                configManager.writeConfig(config);\n                input.value = '';\n                this.fetchBridgeList();\n\n            } catch (e: any) {\n                alert('Invalid JSON: ' + e.message);\n            }\n        },\n\n        removeBridge(name: string) {\n            if (name === 'CocosEditor') return;\n            if (!confirm(`Remove template ${name}?`)) return;\n\n            const configManager = getConfigManager();\n            const config = configManager.readConfig();\n            if (config.manual_call_templates) {\n                config.manual_call_templates = config.manual_call_templates.filter((t: any) => t.name !== name);\n                configManager.writeConfig(config);\n                this.fetchBridgeList();\n            }\n        },\n    },\n    ready() {\n        this.loadSettings();\n\n        // Listeners\n        const savePort = this.$.savePortBtn as HTMLElement;\n        if (savePort) savePort.addEventListener('click', () => this.updatePort());\n\n        const savePath = this.$.utcpConfigPathSaveBtn as HTMLElement;\n        if (savePath) savePath.addEventListener('click', () => this.saveSettings());\n\n        const addBtn = this.$.addBridgeBtn as HTMLElement;\n        if (addBtn) addBtn.addEventListener('click', () => this.addBridgeTemplate());\n\n        const list = this.$.bridgeList as HTMLElement;\n        if (list) {\n            list.addEventListener('click', (e: any) => {\n                // Handle delete clicks\n                const btn = e.target.closest('.remove-btn');\n                if (btn) {\n                    // In new structure, btn is inside .bridge-item-content inside ui-section\n                    const section = btn.closest('.bridge-item-section');\n                    if (section && section.dataset.name) {\n                        this.removeBridge(section.dataset.name);\n                    }\n                }\n            });\n        }\n    },\n    beforeClose() { },\n    close() { },\n});"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/panels/preview/index.js b/extensions/cocos-code-mode/dist/panels/preview/index.js new file mode 100644 index 0000000..3ea8981 --- /dev/null +++ b/extensions/cocos-code-mode/dist/panels/preview/index.js @@ -0,0 +1,93 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_1 = require("fs"); +const path_1 = require("path"); +const templateRaw = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/template/preview/index.html'), 'utf-8'); +const styleRaw = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/style/preview/index.css'), 'utf-8'); +module.exports = Editor.Panel.define({ + template: templateRaw, + style: styleRaw, + $: { + container: '#preview-container', + }, + listeners: {}, + methods: { + async generatePreview(uuid, width = 512, height = 512, jpegQuality = 80) { + try { + const info = await Editor.Message.request('asset-db', 'query-asset-info', uuid); + if (!info) + throw new Error("Asset info not found"); + let previewType = ''; + let queryMethod = ''; + switch (info.importer) { + case 'prefab': + case 'fbx': + case 'gltf': + case 'gltf-skeleton': + previewType = 'scene:prefab-preview'; + queryMethod = 'query-prefab-preview-data'; + break; + case 'material': + previewType = 'scene:material-preview'; + queryMethod = 'query-material-preview-data'; + break; + case 'gltf-mesh': + case 'mesh': + previewType = 'scene:mesh-preview'; + queryMethod = 'query-mesh-preview-data'; + break; + case 'spine': + previewType = 'scene:spine-preview'; + queryMethod = 'query-spine-preview-data'; + break; + default: + previewType = 'scene:mini-preview'; + queryMethod = 'query-scene-preview-data'; + break; + } + // @ts-ignore + const GLPreview = Editor._Module.require('PreviewExtends').default; + const glPreview = new GLPreview(previewType, queryMethod); + const canvas = document.createElement('canvas'); + canvas.width = width; + canvas.height = height; + await glPreview.init({ width, height }); + await glPreview.initGL(canvas, { width, height }); + await glPreview.resizeGL(width, height); + // Set Target + const call = async (func, ...args) => { + return await Editor.Message.request('scene', 'call-preview-function', previewType, func, ...args); + }; + if (info.importer === 'prefab' || info.importer === 'scene' || info.importer === 'fbx' || info.importer === 'gltf') { + await call('setPrefab', uuid); + } + else if (info.importer === 'material') { + // Match Inspector implementation + await call('resetCamera'); + await call('setLightEnable', true); + await call('setPrimitive', 'sphere'); + await Editor.Message.request('scene', 'preview-material', uuid); + } + else if (info.importer === 'gltf-mesh') { + await call('setModel', uuid); + } + else if (info.importer === 'spine') { + await call('setSpine', uuid); + } + else { + await call('setScene', uuid); + } + // Draw + const data = await glPreview.queryPreviewData({ width, height }); + glPreview.drawGL(data); + const dataURL = canvas.toDataURL('image/jpeg', jpegQuality); + return dataURL.replace(/^data:image\/\w+;base64,/, ''); + } + catch (error) { + console.error(`[Preview] Error:`, error); + throw new Error(`Generaton failed: ${error.message}`); + } + }, + } +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/panels/preview/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync } from 'fs';\nimport { join } from 'path';\n\nconst templateRaw = readFileSync(join(__dirname, '../../../static/template/preview/index.html'), 'utf-8');\nconst styleRaw = readFileSync(join(__dirname, '../../../static/style/preview/index.css'), 'utf-8');\n\nmodule.exports = Editor.Panel.define({\n    template: templateRaw,\n    style: styleRaw,\n    $: {\n        container: '#preview-container',\n    },\n    \n    listeners: {\n    },\n    \n    methods: {\n        async generatePreview(uuid: string, width: number = 512, height: number = 512, jpegQuality: number = 80): Promise<string> {\n            try {\n                const info = await Editor.Message.request('asset-db', 'query-asset-info', uuid);\n                if (!info) throw new Error(\"Asset info not found\");\n    \n                let previewType = '';\n                let queryMethod = '';\n                \n                switch (info.importer) {\n                    case 'prefab':\n                    case 'fbx':\n                    case 'gltf':\n                    case 'gltf-skeleton':\n                        previewType = 'scene:prefab-preview';\n                        queryMethod = 'query-prefab-preview-data';\n                        break;\n                    case 'material':\n                        previewType = 'scene:material-preview';\n                        queryMethod = 'query-material-preview-data';\n                        break;\n                    case 'gltf-mesh':\n                    case 'mesh':\n                        previewType = 'scene:mesh-preview';\n                        queryMethod = 'query-mesh-preview-data';\n                        break;\n                    case 'spine':\n                        previewType = 'scene:spine-preview';\n                        queryMethod = 'query-spine-preview-data';\n                        break;\n                    default:\n                        previewType = 'scene:mini-preview';\n                        queryMethod = 'query-scene-preview-data';\n                        break;\n                }\n                \n                // @ts-ignore\n                const GLPreview = Editor._Module.require('PreviewExtends').default;\n                const glPreview = new GLPreview(previewType, queryMethod);\n                \n                const canvas = document.createElement('canvas');\n                canvas.width = width;\n                canvas.height = height;\n                \n                await glPreview.init({ width, height });\n                await glPreview.initGL(canvas, { width, height });\n                await glPreview.resizeGL(width, height);\n    \n                // Set Target\n                const call = async (func: string, ...args: any[]) => { \n                    return await Editor.Message.request('scene', 'call-preview-function', previewType, func, ...args); \n                };\n    \n                if (info.importer === 'prefab' || info.importer === 'scene' || info.importer === 'fbx' || info.importer === 'gltf') {\n                    await call('setPrefab', uuid);\n                } else if (info.importer === 'material') {\n                    // Match Inspector implementation\n                    await call('resetCamera');\n                    await call('setLightEnable', true);\n                    await call('setPrimitive', 'sphere');\n                    await Editor.Message.request('scene', 'preview-material', uuid);\n                } else if (info.importer === 'gltf-mesh') {\n                    await call('setModel', uuid);\n                } else if (info.importer === 'spine') {\n                    await call('setSpine', uuid);\n                } else {\n                     await call('setScene', uuid);\n                }\n    \n                // Draw\n                const data = await glPreview.queryPreviewData({ width, height });\n                \n                glPreview.drawGL(data);\n    \n                const dataURL = canvas.toDataURL('image/jpeg', jpegQuality);\n\n                return dataURL.replace(/^data:image\\/\\w+;base64,/, '');\n    \n            } catch (error: any) {\n                console.error(`[Preview] Error:`, error);\n                throw new Error(`Generaton failed: ${error.message}`);\n            }\n        },\n    }\n} as any);\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/scene.js b/extensions/cocos-code-mode/dist/scene.js new file mode 100644 index 0000000..f18b3f3 --- /dev/null +++ b/extensions/cocos-code-mode/dist/scene.js @@ -0,0 +1,168 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.methods = void 0; +exports.load = load; +exports.unload = unload; +function load() { } +function unload() { } +let _originalConsoleError = () => { }; +let _caughtLogs = []; +exports.methods = { + async startCatchLogging() { + _caughtLogs = []; + _originalConsoleError = console.error; + console.error = (...data) => { + const msg = data.map(a => a instanceof Error ? a.message : a).join(' '); + _caughtLogs.push(msg); + _originalConsoleError(...data); + }; + }, + async stopCatchLogging() { + console.error = _originalConsoleError; + return _caughtLogs; + }, + async createPrefabFromNode(nodeUuid, path) { + const cce = globalThis['cce']; + if (!cce || !cce.Prefab || !cce.Prefab.createPrefabAssetFromNode) { + throw new Error('CCE API not found'); + } + return await cce.Prefab.createPrefabAssetFromNode(nodeUuid, path); + }, + async applyPrefabByNode(nodeUuid) { + try { + const cce = globalThis['cce']; + if (!cce || !cce.Prefab || !cce.Prefab.applyPrefab) { + throw new Error('CCE API not found'); + } + const success = await cce.Prefab.applyPrefab(nodeUuid); + if (!success) { + throw new Error('Failed to apply prefab'); + } + else { + return null; + } + } + catch (error) { + return error instanceof Error ? error.message : String(error); + } + }, + async unlinkPrefabByNode(nodeUuid, recursive) { + try { + const cce = globalThis['cce']; + if (!cce || !cce.Prefab || !cce.Prefab.unWrapPrefabInstance) { + throw new Error('CCE API not found'); + } + const success = await cce.Prefab.unWrapPrefabInstance(nodeUuid, recursive); + if (!success) { + throw new Error('Failed to unlink prefab'); + } + else { + return null; + } + } + catch (error) { + return error instanceof Error ? error.message : String(error); + } + }, + async createOffscreenCanvas(width, height) { + const canvas = document.createElement('canvas'); + canvas.width = width; + canvas.height = height; + return canvas; + }, + async captureScreenshot(imageSize = { width: 512, height: 512 }, jpegQuality = 80, cameraPosition, targetPosition, orthographic = false, orthographicSize = 10) { + return new Promise((resolve, reject) => { + var _a, _b, _c, _d, _e, _f, _g, _h; + const cce = globalThis['cce']; + const cc = globalThis['cc']; + let prevWidth; + let prevHeight; + // Optional: Save camera state + let prevCamPos; + let prevCamRot; + let prevProjection; + let prevOrthoSize; + // Apply Camera Changes + try { + if (cce && cce.Camera && cce.Camera.camera) { + const camNode = cce.Camera.camera.node; + if (camNode) { + prevCamPos = camNode.position.clone(); + prevCamRot = camNode.rotation.clone(); + prevProjection = cce.Camera.camera.projection; + prevOrthoSize = cce.Camera.camera.orthoSize; + cce.Camera.camera.projection = orthographic ? + cc.Camera.ProjectionType.ORTHO : cc.Camera.ProjectionType.PERSPECTIVE; + if (orthographic) { + cce.Camera.camera.orthoSize = orthographicSize; + } + if (cameraPosition) { + camNode.setPosition(new cc.Vec3((_a = cameraPosition.x) !== null && _a !== void 0 ? _a : 0, (_b = cameraPosition.y) !== null && _b !== void 0 ? _b : 0, (_c = cameraPosition.z) !== null && _c !== void 0 ? _c : 0)); + } + if (targetPosition) { + camNode.lookAt(new cc.Vec3((_d = targetPosition.x) !== null && _d !== void 0 ? _d : 0, (_e = targetPosition.y) !== null && _e !== void 0 ? _e : 0, (_f = targetPosition.z) !== null && _f !== void 0 ? _f : 0)); + } + if (cce.Camera.refresh) + cce.Camera.refresh(); + } + } + } + catch (e) { + console.warn("[captureScreenshot] Failed to modify camera:", e); + } + if (cc.director && cc.director.root) { + prevWidth = ((_g = cc.director.root.mainWindow) === null || _g === void 0 ? void 0 : _g.width) || 0; + prevHeight = ((_h = cc.director.root.mainWindow) === null || _h === void 0 ? void 0 : _h.height) || 0; + cc.director.root.resize(imageSize.width, imageSize.height); + } + else { + return reject(new Error("cc.game.canvas not found or is not an HTMLCanvasElement")); + } + try { + if (cce && cce.Engine) { + cce.Engine.repaintInEditMode(); + } + } + catch (e) { + console.warn("Failed to repaintInEditMode:", e); + } + cc.director.once(cc.Director.EVENT_AFTER_RENDER, () => { + try { + if (cc.game && cc.game.canvas && (cc.game.canvas instanceof HTMLCanvasElement)) { + const dataURL = cc.game.canvas.toDataURL('image/jpeg', jpegQuality / 100); + const base64 = dataURL.replace(/^data:image\/\w+;base64,/, ''); + resolve(base64); + } + else { + reject(new Error("cc.game.canvas not found or is not an HTMLCanvasElement")); + } + } + catch (error) { + reject(new Error(error.message || String(error))); + } + finally { + // Restore previous size + if (cc.director && cc.director.root) { + cc.director.root.resize(prevWidth, prevHeight); + } + // Restore camera + setTimeout(() => { + if (cce && cce.Camera && cce.Camera.camera && cce.Camera.camera.node) { + if (prevCamPos) + cce.Camera.camera.node.setPosition(prevCamPos); + if (prevCamRot) + cce.Camera.camera.node.setRotation(prevCamRot); + if (prevProjection !== undefined) + cce.Camera.camera.projection = prevProjection; + if (prevOrthoSize !== undefined) + cce.Camera.camera.orthoSize = prevOrthoSize; + if (cce.Camera.refresh) + cce.Camera.refresh(); + } + }, 50); + } + }); + }); + } +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene.js","sourceRoot":"","sources":["../source/scene.ts"],"names":[],"mappings":"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","sourcesContent":["export function load() { }\nexport function unload() { }\nlet _originalConsoleError: (...data: unknown[]) => void = () => { };\nlet _caughtLogs: string[] = [];\n\nexport const methods = {\n    async startCatchLogging() {\n        _caughtLogs = [];\n        _originalConsoleError = console.error;\n        console.error = (...data: unknown[]) => {\n            const msg = data.map(a => a instanceof Error ? a.message : a).join(' ');\n            _caughtLogs.push(msg);\n            _originalConsoleError(...data);\n        }\n    },\n\n    async stopCatchLogging(): Promise<string[]> {\n        console.error = _originalConsoleError;\n        return _caughtLogs;\n    },\n\n    async createPrefabFromNode(nodeUuid: string, path: string): Promise<string> {\n        const cce = (globalThis as any)['cce'];\n        \n        if (!cce || !cce.Prefab || !cce.Prefab.createPrefabAssetFromNode) {\n            throw new Error('CCE API not found');\n        }\n\n        return await cce.Prefab.createPrefabAssetFromNode(nodeUuid, path);\n    },\n\n    async applyPrefabByNode(nodeUuid: string): Promise<string | null> {\n        try {\n            const cce = (globalThis as any)['cce'];\n            if (!cce || !cce.Prefab || !cce.Prefab.applyPrefab) {\n                throw new Error('CCE API not found');\n            }\n\n            const success: boolean = await cce.Prefab.applyPrefab(nodeUuid);\n            if (!success) {\n                throw new Error('Failed to apply prefab');\n            } else {\n                return null;\n            }\n        } catch (error) {\n            return error instanceof Error ? error.message : String(error);\n        }\n    },\n\n    async unlinkPrefabByNode(nodeUuid: string, recursive: boolean): Promise<string | null> {\n        try {\n            const cce = (globalThis as any)['cce'];\n            if (!cce || !cce.Prefab || !cce.Prefab.unWrapPrefabInstance) {\n                throw new Error('CCE API not found');\n            }\n\n            const success: boolean = await cce.Prefab.unWrapPrefabInstance(nodeUuid, recursive);\n            if (!success) {\n                throw new Error('Failed to unlink prefab');\n            } else {\n                return null;\n            }\n        } catch (error) {\n             return error instanceof Error ? error.message : String(error);\n        }\n    },\n\n    async createOffscreenCanvas(width: number, height: number): Promise<HTMLCanvasElement> {\n        const canvas = document.createElement('canvas');\n        canvas.width = width;\n        canvas.height = height;\n        return canvas;\n    },\n\n    async captureScreenshot(\n        imageSize: { width: number, height: number } = { width: 512, height: 512 }, \n        jpegQuality: number = 80,\n        cameraPosition?: { x: number, y: number, z: number },\n        targetPosition?: { x: number, y: number, z: number },\n        orthographic: boolean = false,\n        orthographicSize: number = 10\n    ): Promise<string> {\n        return new Promise((resolve, reject) => {\n            const cce = (globalThis as any)['cce'];\n            const cc = (globalThis as any)['cc'];\n\n            let prevWidth: number;\n            let prevHeight: number;\n\n            // Optional: Save camera state\n            let prevCamPos: any;\n            let prevCamRot: any;\n            let prevProjection: number;\n            let prevOrthoSize: number;\n            \n            // Apply Camera Changes\n            try {\n                if (cce && cce.Camera && cce.Camera.camera) {\n                    const camNode = cce.Camera.camera.node;\n\n                    if (camNode) {\n                        prevCamPos = camNode.position.clone();\n                        prevCamRot = camNode.rotation.clone();\n                        prevProjection = cce.Camera.camera.projection;\n                        prevOrthoSize = cce.Camera.camera.orthoSize;\n\n                        cce.Camera.camera.projection = orthographic ? \n                            cc.Camera.ProjectionType.ORTHO : cc.Camera.ProjectionType.PERSPECTIVE;\n\n                        if (orthographic) {\n                            cce.Camera.camera.orthoSize = orthographicSize;\n                        }\n\n                        if (cameraPosition) {\n                            camNode.setPosition(new cc.Vec3(cameraPosition.x ?? 0, cameraPosition.y ?? 0, cameraPosition.z ?? 0));\n                        }\n                        if (targetPosition) {\n                            camNode.lookAt(new cc.Vec3(targetPosition.x ?? 0, targetPosition.y ?? 0, targetPosition.z ?? 0));\n                        }\n                        \n                        if (cce.Camera.refresh) cce.Camera.refresh();\n                    }\n                }\n            } catch (e) {\n                console.warn(\"[captureScreenshot] Failed to modify camera:\", e);\n            }\n\n            if (cc.director && cc.director.root) {\n                prevWidth = cc.director.root.mainWindow?.width || 0;\n                prevHeight = cc.director.root.mainWindow?.height || 0;\n                cc.director.root.resize(imageSize.width, imageSize.height);\n            } else {\n                return reject(new Error(\"cc.game.canvas not found or is not an HTMLCanvasElement\"));\n            }\n            \n            try {\n                if (cce && cce.Engine) {\n                    cce.Engine.repaintInEditMode();\n                }\n            } catch (e) { console.warn(\"Failed to repaintInEditMode:\", e); }\n\n            cc.director.once(cc.Director.EVENT_AFTER_RENDER, () => {\n                try {\n                    if (cc.game && cc.game.canvas && (cc.game.canvas instanceof HTMLCanvasElement)) {\n                        const dataURL = cc.game.canvas.toDataURL('image/jpeg', jpegQuality / 100);\n                        const base64 = dataURL.replace(/^data:image\\/\\w+;base64,/, '');\n                        resolve(base64);\n                    } else {\n                        reject(new Error(\"cc.game.canvas not found or is not an HTMLCanvasElement\"));\n                    }\n                } catch (error: any) {\n                     reject(new Error(error.message || String(error)));\n                } finally {\n                    // Restore previous size\n                    if (cc.director && cc.director.root) {\n                        cc.director.root.resize(prevWidth, prevHeight);\n                    }\n                    // Restore camera\n                    setTimeout(() => {\n                        if (cce && cce.Camera && cce.Camera.camera && cce.Camera.camera.node) {\n                            if (prevCamPos) cce.Camera.camera.node.setPosition(prevCamPos);\n                            if (prevCamRot) cce.Camera.camera.node.setRotation(prevCamRot);\n                            if (prevProjection !== undefined) cce.Camera.camera.projection = prevProjection;\n                            if (prevOrthoSize !== undefined) cce.Camera.camera.orthoSize = prevOrthoSize;\n                            if (cce.Camera.refresh) cce.Camera.refresh();\n                        }\n                    }, 50);\n                }\n            });\n        });\n    }\n};\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/config-manager.js b/extensions/cocos-code-mode/dist/utcp/config-manager.js new file mode 100644 index 0000000..32103f6 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/config-manager.js @@ -0,0 +1,121 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.UtcpConfigManager = void 0; +exports.getConfigManager = getConfigManager; +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +const os_1 = require("os"); +// @ts-ignore +const package_json_1 = __importDefault(require("../../package.json")); +class UtcpConfigManager { + constructor() { + this.configPath = ''; + } + static getInstance() { + if (!UtcpConfigManager.instance) { + UtcpConfigManager.instance = new UtcpConfigManager(); + } + return UtcpConfigManager.instance; + } + async initialize() { + const savedPath = await Editor.Profile.getConfig(package_json_1.default.name, 'utcpConfigPath'); + if (savedPath && typeof savedPath === 'string') { + this.configPath = savedPath; + } + else { + this.configPath = (0, path_1.join)((0, os_1.homedir)(), '.utcp_config.json'); + } + console.log(`[UtcpConfigManager] Initialized with config path: ${this.configPath}`); + } + getConfigPath() { + if (!this.configPath) { + this.configPath = (0, path_1.join)((0, os_1.homedir)(), '.utcp_config.json'); + } + return this.configPath; + } + async setConfigPath(path) { + this.configPath = path; + await Editor.Profile.setConfig(package_json_1.default.name, 'utcpConfigPath', path); + console.log(`[UtcpConfigManager] Config path updated to: ${path}`); + } + readConfig() { + const path = this.getConfigPath(); + if (path && (0, fs_extra_1.existsSync)(path)) { + try { + const content = (0, fs_extra_1.readFileSync)(path, 'utf-8'); + return JSON.parse(content); + } + catch (e) { + console.error('[UtcpConfigManager] Failed to parse UTCP config:', e); + return { manual_call_templates: [] }; + } + } + return { manual_call_templates: [] }; + } + writeConfig(config) { + const path = this.getConfigPath(); + if (!path) { + console.error('[UtcpConfigManager] Config path is not set'); + return; + } + try { + (0, fs_extra_1.writeFileSync)(path, JSON.stringify(config, null, 2)); + console.log(`[UtcpConfigManager] Saved UTCP config to ${path}`); + } + catch (e) { + console.error('[UtcpConfigManager] Failed to write UTCP config:', e); + } + } + async ensureCocosEditorTemplate(port) { + if (!port || port <= 0) { + console.warn('[UtcpConfigManager] Invalid port provided:', port); + return false; + } + const expectedUrl = `http://localhost:${port}/utcp`; + const config = this.readConfig(); + if (!config.manual_call_templates) { + config.manual_call_templates = []; + } + const templates = config.manual_call_templates; + const idx = templates.findIndex((t) => t.name === 'CocosEditor'); + let changed = false; + if (idx === -1) { + templates.push({ + name: 'CocosEditor', + call_template_type: 'http', + url: expectedUrl, + http_method: 'GET', + content_type: 'application/json', + }); + changed = true; + console.log(`[UtcpConfigManager] Created CocosEditor template with port ${port}`); + } + else { + if (templates[idx].url !== expectedUrl) { + templates[idx].url = expectedUrl; + changed = true; + console.log(`[UtcpConfigManager] Updated CocosEditor template port to ${port}`); + } + } + if (changed) { + this.writeConfig(config); + } + return changed; + } + async getCurrentPort() { + const port = await Editor.Profile.getConfig(package_json_1.default.name, 'serverPort'); + return typeof port === 'number' ? port : 0; + } + async updatePort(port) { + await Editor.Profile.setConfig(package_json_1.default.name, 'serverPort', port); + await this.ensureCocosEditorTemplate(port); + } +} +exports.UtcpConfigManager = UtcpConfigManager; +function getConfigManager() { + return UtcpConfigManager.getInstance(); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-manager.js","sourceRoot":"","sources":["../../source/utcp/config-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync, writeFileSync, existsSync } from 'fs-extra';\nimport { join } from 'path';\nimport { homedir } from 'os';\n\n// @ts-ignore\nimport packageJSON from '../../package.json';\n\n\nexport class UtcpConfigManager {\n    private static instance: UtcpConfigManager;\n    private configPath: string = '';\n\n    private constructor() {}\n\n    static getInstance(): UtcpConfigManager {\n        if (!UtcpConfigManager.instance) {\n            UtcpConfigManager.instance = new UtcpConfigManager();\n        }\n        return UtcpConfigManager.instance;\n    }\n\n    async initialize(): Promise<void> {\n        const savedPath = await Editor.Profile.getConfig(packageJSON.name, 'utcpConfigPath');\n        if (savedPath && typeof savedPath === 'string') {\n            this.configPath = savedPath;\n        } else {\n            this.configPath = join(homedir(), '.utcp_config.json');\n        }\n        console.log(`[UtcpConfigManager] Initialized with config path: ${this.configPath}`);\n    }\n\n    getConfigPath(): string {\n        if (!this.configPath) {\n            this.configPath = join(homedir(), '.utcp_config.json');\n        }\n        return this.configPath;\n    }\n\n    async setConfigPath(path: string): Promise<void> {\n        this.configPath = path;\n        await Editor.Profile.setConfig(packageJSON.name, 'utcpConfigPath', path);\n        console.log(`[UtcpConfigManager] Config path updated to: ${path}`);\n    }\n\n    readConfig(): any {\n        const path = this.getConfigPath();\n        if (path && existsSync(path)) {\n            try {\n                const content = readFileSync(path, 'utf-8');\n                return JSON.parse(content);\n            } catch (e) {\n                console.error('[UtcpConfigManager] Failed to parse UTCP config:', e);\n                return { manual_call_templates: [] };\n            }\n        }\n        return { manual_call_templates: [] };\n    }\n\n    writeConfig(config: any): void {\n        const path = this.getConfigPath();\n        if (!path) {\n            console.error('[UtcpConfigManager] Config path is not set');\n            return;\n        }\n        try {\n            writeFileSync(path, JSON.stringify(config, null, 2));\n            console.log(`[UtcpConfigManager] Saved UTCP config to ${path}`);\n        } catch (e) {\n            console.error('[UtcpConfigManager] Failed to write UTCP config:', e);\n        }\n    }\n\n    async ensureCocosEditorTemplate(port: number): Promise<boolean> {\n        if (!port || port <= 0) {\n            console.warn('[UtcpConfigManager] Invalid port provided:', port);\n            return false;\n        }\n\n        const expectedUrl = `http://localhost:${port}/utcp`;\n        const config = this.readConfig();\n\n        if (!config.manual_call_templates) {\n            config.manual_call_templates = [];\n        }\n\n        const templates = config.manual_call_templates;\n        const idx = templates.findIndex((t: any) => t.name === 'CocosEditor');\n\n        let changed = false;\n        if (idx === -1) {\n            templates.push({\n                name: 'CocosEditor',\n                call_template_type: 'http',\n                url: expectedUrl,\n                http_method: 'GET',\n                content_type: 'application/json',\n            });\n            changed = true;\n            console.log(`[UtcpConfigManager] Created CocosEditor template with port ${port}`);\n        } else {\n            if (templates[idx].url !== expectedUrl) {\n                templates[idx].url = expectedUrl;\n                changed = true;\n                console.log(`[UtcpConfigManager] Updated CocosEditor template port to ${port}`);\n            }\n        }\n\n        if (changed) {\n            this.writeConfig(config);\n        }\n\n        return changed;\n    }\n\n    async getCurrentPort(): Promise<number> {\n        const port = await Editor.Profile.getConfig(packageJSON.name, 'serverPort');\n        return typeof port === 'number' ? port : 0;\n    }\n\n    async updatePort(port: number): Promise<void> {\n        await Editor.Profile.setConfig(packageJSON.name, 'serverPort', port);\n        await this.ensureCocosEditorTemplate(port);\n    }\n}\n\nexport function getConfigManager(): UtcpConfigManager {\n    return UtcpConfigManager.getInstance();\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/decorators.js b/extensions/cocos-code-mode/dist/utcp/decorators.js new file mode 100644 index 0000000..130b045 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/decorators.js @@ -0,0 +1,39 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ToolRegistry = void 0; +exports.utcpTool = utcpTool; +class ToolRegistry { + static register(options) { + this.tools.set(options.tool.name, options); + } + static getTools() { + return Array.from(this.tools.values()); + } +} +exports.ToolRegistry = ToolRegistry; +ToolRegistry.tools = new Map(); +function utcpTool(name, description, inputs, outputs, httpMethod, tags = []) { + return function (target, propertyKey, descriptor) { + if (!descriptor) + return; + ToolRegistry.register({ + method: descriptor.value, + target, + tool: { + name, + description, + inputs, + outputs, + tags, + tool_call_template: { + call_template_type: "http", + http_method: httpMethod, + request_body_format: "json", + url: `/tools/${name}`, + content_type: "application/json" + }, + } + }); + }; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/schemas.js b/extensions/cocos-code-mode/dist/utcp/schemas.js new file mode 100644 index 0000000..37f0863 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/schemas.js @@ -0,0 +1,31 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SceneTreeItemSchema = exports.AssetTreeItemSchema = exports.Base64ImageSchema = exports.SuccessIndicatorSchema = exports.InstanceReferenceSchema = void 0; +// -=-=-=-=-=- Zod schemas for different result types -=-=-=-=-=- +exports.InstanceReferenceSchema = { type: 'object', properties: { id: { type: 'string' }, type: { type: 'string' } }, required: ['id'] }; +exports.SuccessIndicatorSchema = { type: 'object', properties: { success: { type: 'boolean' }, error: { type: 'string' } }, required: ['success'] }; +exports.Base64ImageSchema = { type: 'object', properties: { type: { type: 'string', const: "image" }, data: { type: 'string' }, mimeType: { type: 'string' } }, required: ['type', 'data', 'mimeType'] }; +exports.AssetTreeItemSchema = { + type: 'object', + properties: { + filesystemPath: { type: 'string' }, + reference: exports.InstanceReferenceSchema, + name: { type: 'string' }, + children: { type: 'array', items: { type: 'object' } } + }, required: ['reference', 'name', 'type', 'children'] +}; +exports.SceneTreeItemSchema = { + type: 'object', + properties: { + path: { type: 'string' }, + reference: exports.InstanceReferenceSchema, + name: { type: 'string' }, + active: { type: 'boolean' }, + components: { + type: 'array', + items: exports.InstanceReferenceSchema + }, + children: { type: 'array', items: { type: 'object' } } + }, required: ['reference', 'name', 'active', 'components', 'children'] +}; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/tools/asset-tools.js b/extensions/cocos-code-mode/dist/utcp/tools/asset-tools.js new file mode 100644 index 0000000..846cd10 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/tools/asset-tools.js @@ -0,0 +1,482 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AssetTools = void 0; +const package_json_1 = __importDefault(require("../../../package.json")); +const sharp_1 = __importDefault(require("sharp")); +const fs_extra_1 = __importDefault(require("fs-extra")); +const decorators_1 = require("../decorators"); +const schemas_1 = require("../schemas"); +const path_1 = __importStar(require("path")); +const os_1 = __importDefault(require("os")); +function normalizePath(p) { + if (!p) + return 'db://assets'; + let path = p.replace(/\\/g, '/').trim(); + // Handle db:// protocol + if (path.startsWith('db://')) { + return path.endsWith('/') && path !== 'db://' ? path.slice(0, -1) : path; + } + // Remove leading slash + if (path.startsWith('/')) { + path = path.slice(1); + } + // Handle root aliases + if (path === '' || path === 'assets') { + return 'db://assets'; + } + // Handle 'assets/' prefix + if (path.startsWith('assets/')) { + const result = 'db://' + path; + return result.endsWith('/') ? result.slice(0, -1) : result; + } + // Treat as relative path under assets + if (path.endsWith('/')) { + path = path.slice(0, -1); + } + return `db://assets/${path}`; +} +class AssetTools { + async assetGetTree(args) { + if (args.reference) { + const info = await Editor.Message.request('asset-db', 'query-asset-info', args.reference.id); + if (!info) { + throw new Error(`Asset with UUID ${args.reference.id} not found.`); + } + args.assetPath = info.url; + } + let rootPath = normalizePath(args.assetPath); + const pattern = `${rootPath}/**`; + const assets = await Editor.Message.request('asset-db', 'query-assets', { pattern }); + const rootUuid = await Editor.Message.request('asset-db', 'query-uuid', rootPath); + const assetsMap = new Map(); + // Create Root Node first + const rootName = rootPath.split('/').pop() || 'assets'; + const rootNode = { + filesystemPath: Editor.Project.path + '/' + rootPath.replace('db://', ''), + reference: { id: rootUuid || 'root', type: 'folder' }, + name: rootName, + children: [] + }; + assetsMap.set(rootPath, rootNode); + // First pass: Map assets + assets.forEach((asset) => { + if (asset.url === rootPath) + return; // Skip root, already created + const type = asset.isDirectory ? 'folder' : asset.type; + const treeItem = { + reference: { id: asset.uuid, type: type }, + name: asset.name, + children: [] + }; + assetsMap.set(asset.url, treeItem); + }); + // Second pass: Build hierarchy + assets.forEach((asset) => { + if (asset.url === rootPath) + return; + const treeItem = assetsMap.get(asset.url); + if (!treeItem) + return; + const parentUrl = asset.url.substring(0, asset.url.lastIndexOf('/')); + const parentItem = assetsMap.get(parentUrl); + if (parentItem) { + parentItem.children.push(treeItem); + } + }); + return rootNode; + } + async assetGetAtPath(args) { + let targetPath = normalizePath(args.assetPath); + console.log(`Looking for asset at path: ${targetPath}`); + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', targetPath); + if (!assetInfo) { + throw new Error(`Asset not found at path: ${targetPath}`); + } + else { + return { reference: { id: assetInfo.uuid, type: assetInfo.type } }; + } + } + async assetCreate(args) { + var _a, _b, _c, _d; + let targetPath = normalizePath(args.assetPath); + // Map 'preset' from schema to 'type' expected by function + const type = args.preset; + const presetMap = { + 'material': 'db://internal/default_file_content/material/default.mtl', + 'effect': 'db://internal/default_file_content/effect/default.effect', + 'scene': 'db://internal/default_file_content/scene/default.scene', + 'prefab': 'db://internal/default_file_content/prefab/default.prefab', + 'animation-clip': 'db://internal/default_file_content/animation-clip/default.anim', + 'render-texture': 'db://internal/default_file_content/render-texture/default.rt', + 'physics-material': 'db://internal/default_file_content/physics-material/default.pmtl', + 'animation-graph': 'db://internal/default_file_content/animation-graph/default.animgraph', + 'animation-graph-variant': 'db://internal/default_file_content/animation-graph-variant/default.animgraphvari', + 'animation-mask': 'db://internal/default_file_content/animation-mask/default.animask', + 'auto-atlas': 'db://internal/default_file_content/auto-atlas/default.pac', + 'effect-header': 'db://internal/default_file_content/effect-header/chunk', + 'label-atlas': 'db://internal/default_file_content/label-atlas/default.labelatlas', + 'terrain': 'db://internal/default_file_content/terrain/default.terrain' + }; + const assetOptions = { + overwrite: (_b = (_a = args.options) === null || _a === void 0 ? void 0 : _a.overwrite) !== null && _b !== void 0 ? _b : false, + rename: (_d = (_c = args.options) === null || _c === void 0 ? void 0 : _c.rename) !== null && _d !== void 0 ? _d : false + }; + if (type === 'folder' || type === 'typescript') { + let content = null; + if (type === 'typescript') { + const currentExtName = (0, path_1.extname)(targetPath); + if (currentExtName !== '.ts') { + targetPath = currentExtName ? targetPath.slice(0, -currentExtName.length) : targetPath; + targetPath += '.ts'; + } + const className = (0, path_1.basename)(targetPath.slice('db://'.length), '.ts'); + content = this.generateTypescriptClassTemplate(className); + } + const result = await Editor.Message.request('asset-db', 'create-asset', targetPath, content, assetOptions); + if (!result) { + throw new Error(`Failed to create folder at ${targetPath}`); + } + else { + return { reference: { id: result.uuid, type: type } }; + } + } + const source = presetMap[type]; + if (!source) { + throw new Error(`Unknown asset preset type: ${type}`); + } + if ((0, path_1.extname)(targetPath) === '' && type !== 'folder') { + targetPath += type == 'chunk' ? '.chunk' : (0, path_1.extname)(presetMap[type]); + } + const assetInfo = await Editor.Message.request('asset-db', 'copy-asset', source, targetPath, assetOptions); + if (!assetInfo) { + throw new Error(`Failed to create asset at ${targetPath}`); + } + else { + return { reference: { id: assetInfo.uuid, type: assetInfo.type } }; + } + } + async assetImport(args) { + var _a, _b, _c, _d; + let targetPath = normalizePath(args.targetAssetPath); + const assetOptions = { + overwrite: (_b = (_a = args.options) === null || _a === void 0 ? void 0 : _a.overwrite) !== null && _b !== void 0 ? _b : false, + rename: (_d = (_c = args.options) === null || _c === void 0 ? void 0 : _c.rename) !== null && _d !== void 0 ? _d : false + }; + // Additional resolving for absolute path + if (args.sourceFilesystemPath.startsWith('~')) { + args.sourceFilesystemPath = path_1.default.join(os_1.default.homedir(), args.sourceFilesystemPath.slice(1)); + } + args.sourceFilesystemPath = path_1.default.resolve(args.sourceFilesystemPath); + args.sourceFilesystemPath = await fs_extra_1.default.realpath(args.sourceFilesystemPath); + // Checking for existing asset at target path + let existingAssetInfo = null; + // If caller tries to import the same file in assets - just reimport + if (`${Editor.Project.path}${targetPath.slice('db:/'.length)}` === args.sourceFilesystemPath) { + await Editor.Message.request('asset-db', 'refresh-asset', targetPath); + existingAssetInfo = await Editor.Message.request('asset-db', 'query-asset-info', targetPath); + } + const assetInfo = existingAssetInfo ? existingAssetInfo : + await Editor.Message.request('asset-db', 'import-asset', args.sourceFilesystemPath, targetPath, assetOptions); + if (!assetInfo) { + throw new Error(`Failed to import asset to ${targetPath}`); + } + else { + if (assetInfo.extends && assetInfo.importer === 'image' && args.imageType) { + // Handle image type override + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (meta && meta.userData) { + let typeToSet = args.imageType; + if (typeToSet === 'normal-map') { + typeToSet = 'normal map'; + } + if (typeToSet === 'texture-cube') { + typeToSet = 'texture cube'; + } + meta.userData.type = typeToSet; + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + } + } + return { reference: { id: assetInfo.uuid, type: assetInfo.type } }; + } + } + async assetOperate(args) { + var _a, _b, _c, _d, _e, _f; + const assetOptions = { + overwrite: (_b = (_a = args.options) === null || _a === void 0 ? void 0 : _a.overwrite) !== null && _b !== void 0 ? _b : false, + rename: (_d = (_c = args.options) === null || _c === void 0 ? void 0 : _c.rename) !== null && _d !== void 0 ? _d : false + }; + args.targetAssetPath = normalizePath(args.targetAssetPath); + let result = null; + switch (args.operation) { + case 'move': + if (!args.targetAssetPath) { + throw new Error('Target is required for move'); + } + result = await Editor.Message.request('asset-db', 'move-asset', args.reference.id, args.targetAssetPath, assetOptions); + break; + case 'copy': + if (!args.targetAssetPath) { + throw new Error('Target is required for copy'); + } + result = await Editor.Message.request('asset-db', 'copy-asset', args.reference.id, args.targetAssetPath, assetOptions); + break; + case 'delete': + result = await Editor.Message.request('asset-db', 'delete-asset', args.reference.id); + break; + case 'open': + await Editor.Message.request('asset-db', 'open-asset', args.reference.id); + result = null; + break; + case 'refresh': + await Editor.Message.request('asset-db', 'refresh-asset', args.reference.id); + result = null; + break; + case 'reimport': + await Editor.Message.request('asset-db', 'reimport-asset', args.reference.id); + result = null; + break; + default: + throw new Error(`Unknown operation: ${args.operation}`); + } + return { reference: { id: (_e = result === null || result === void 0 ? void 0 : result.uuid) !== null && _e !== void 0 ? _e : '', type: (_f = result === null || result === void 0 ? void 0 : result.type) !== null && _f !== void 0 ? _f : '' } }; + } + async assetGetPreview(args) { + const info = await Editor.Message.request('asset-db', 'query-asset-info', args.reference.id); + if (!info) { + throw new Error(`Asset ${args.reference.id} not found.`); + } + if (!info.importer) { + throw new Error(`Asset ${args.reference.id} has no importer and cannot be previewed.`); + } + args.imageSize = args.imageSize || 512; + args.jpegQuality = args.jpegQuality || 80; + args.transparentColor = args.transparentColor || { r: 0, g: 0, b: 0 }; + let importer = info.importer; + const supportedImporters = [ + 'erp-texture-cube', + 'image', + 'sprite-frame', + 'texture', + 'fbx', + 'gltf', + 'gltf-mesh', + 'prefab', + 'material', + 'spine', + 'gltf-skeleton', + 'scene' + ]; + if (!supportedImporters.includes(importer)) { + throw new Error(`Asset preview not supported for asset type: ${info.type}`); + } + if (importer === 'fbx' || importer === 'gltf') { + const mesh = Object.values(info.subAssets).find((sub) => sub.importer === 'gltf-mesh'); + if (!mesh) { + throw new Error(`Asset ${args.reference.id} has no gltf-mesh sub-asset for preview.`); + } + args.reference.id = mesh.uuid; + importer = 'gltf-mesh'; + } + let sourcePath = null; + if (importer === 'gltf-mesh' || importer === 'mesh') { + sourcePath = (await Editor.Message.request('asset-db', 'query-asset-thumbnail', args.reference.id, "origin")).value; + } + else if (['erp-texture-cube', 'image', 'sprite-frame', 'texture'].includes(importer)) { + let fileUuid = args.reference.id; + if (args.reference.id.includes('@')) { + fileUuid = args.reference.id.split('@')[0]; + } + const fileInfo = await Editor.Message.request('asset-db', 'query-asset-info', fileUuid); + if (fileInfo && fileInfo.file) { + sourcePath = fileInfo.file; + } + } + if (sourcePath && fs_extra_1.default.existsSync(sourcePath)) { + try { + const image = (0, sharp_1.default)(sourcePath); + const metadata = await image.metadata(); + const requestedSize = args.imageSize || 512; + let processed = image; + if ((metadata.width && metadata.width > requestedSize) || + (metadata.height && metadata.height > requestedSize)) { + processed = processed.resize(requestedSize, requestedSize, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } }); + } + let buffer; + if ((metadata.format === 'png' || metadata.hasAlpha)) { + buffer = await processed.flatten({ background: args.transparentColor }) + .jpeg({ quality: args.jpegQuality || 80 }) + .toBuffer(); + } + else { + buffer = await processed + .jpeg({ quality: args.jpegQuality || 80 }) + .toBuffer(); + } + return { type: "image", data: buffer.toString('base64'), mimeType: "image/jpeg" }; + } + catch (e) { + console.error(`Failed to process image from ${sourcePath} with sharp:`, e); + } + } + // Open panel to ensure renderer process is alive + await Editor.Panel.openBeside('scene', `${package_json_1.default.name}.preview`); + let base64Image; + try { + // Request generation + base64Image = await Editor.Message.request(package_json_1.default.name, 'generate-preview', args.reference.id, args.imageSize || 512, args.imageSize || 512, (args.jpegQuality || 80) / 100); + } + finally { + // Close panel + await Editor.Panel.close(`${package_json_1.default.name}.preview`); + } + if (!base64Image) { + throw new Error(`Failed to generate preview for asset ${args.reference.id}.`); + } + return { type: "image", data: base64Image, mimeType: "image/jpeg" }; + } + generateTypescriptClassTemplate(className) { + return `import { _decorator, Component, Node } from 'cc'; +const { ccclass, property } = _decorator; + +@ccclass('${className}') +export class ${className} extends Component { + start() { + + } + + update(deltaTime: number) { + + } +}`; + } +} +exports.AssetTools = AssetTools; +__decorate([ + (0, decorators_1.utcpTool)('assetGetTree', 'Get the asset and subAsset hierarchy tree. Children have recursive structure.', { + type: 'object', + properties: { + reference: schemas_1.InstanceReferenceSchema, + assetPath: { type: 'string', description: 'Root path to start from' } + } + }, schemas_1.AssetTreeItemSchema, "GET", ['asset', 'file', 'tree', 'hierarchy', 'folder', 'subasset']) +], AssetTools.prototype, "assetGetTree", null); +__decorate([ + (0, decorators_1.utcpTool)('assetGetAtPath', 'Get asset reference by given local path and name, including extension. Can be used for subassets too. Returns reference to the asset.', { + type: 'object', + properties: { + assetPath: { type: 'string' } + }, + required: ['assetPath'] + }, { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, "GET", ['asset', 'get', 'path', 'look', 'find']) +], AssetTools.prototype, "assetGetAtPath", null); +__decorate([ + (0, decorators_1.utcpTool)('assetCreate', 'Create empty asset or folder of given type. Automatically handles folders creation along the path. Returns reference to the new asset.', { + type: 'object', + properties: { + assetPath: { type: 'string' }, + preset: { + type: 'string', + enum: [ + 'folder', + 'material', + 'effect', + 'scene', + 'prefab', + 'typescript', + 'animation-clip', + 'render-texture', + 'physics-material', + 'animation-graph', + 'animation-graph-variant', + 'animation-mask', + 'auto-atlas', + 'effect-header', + 'label-atlas', + 'terrain' + ], + description: 'Preset type for the new asset' + }, + options: { type: 'object', properties: { overwrite: { type: 'boolean' }, rename: { type: 'boolean' } }, description: 'Additional options for the operation', nullable: true }, + }, + required: ['assetPath', 'preset'] + }, { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, "POST", ['asset', 'create', 'new', 'preset', 'folder', 'typescript']) +], AssetTools.prototype, "assetCreate", null); +__decorate([ + (0, decorators_1.utcpTool)('assetImport', 'Import an external file as an asset into the project. Path must end with the extension. Returns reference to the new asset.', { + type: 'object', + properties: { + sourceFilesystemPath: { type: 'string', description: 'Source filesystem path of the file to import' }, + targetAssetPath: { type: 'string', description: 'Target path in the asset database' }, + imageType: { type: 'string', enum: ['raw', 'texture', 'normal-map', 'sprite-frame', 'texture-cube'], description: 'For image files, specify how to import them' }, + options: { type: 'object', properties: { overwrite: { type: 'boolean' }, rename: { type: 'boolean' } }, description: 'Additional options for the operation' }, + }, + required: ['sourceFilesystemPath', 'targetAssetPath'] + }, { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, "POST", ['asset', 'import', 'file', 'external', 'image']) +], AssetTools.prototype, "assetImport", null); +__decorate([ + (0, decorators_1.utcpTool)('assetOperate', 'Perform operations on assets (move, copy, delete, open). Returns reference to the affected asset (for delete/open returns the source asset reference).', { + type: 'object', + properties: { + operation: { type: 'string', enum: ['move', 'copy', 'delete', 'open', 'refresh', 'reimport'] }, + reference: schemas_1.InstanceReferenceSchema, + targetAssetPath: { type: 'string', description: 'Target path (for move/copy/import)' }, + options: { type: 'object', properties: { overwrite: { type: 'boolean' }, rename: { type: 'boolean' } }, description: 'Additional options for the operation', nullable: true }, + }, + required: ['operation', 'reference'] + }, { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, "POST", ['asset', 'operate', 'move', 'copy', 'delete', 'open', 'refresh', 'reimport']) +], AssetTools.prototype, "assetOperate", null); +__decorate([ + (0, decorators_1.utcpTool)('assetGetPreview', 'Returns preview image of the asset (Prefab, Image, Model or Material is supported). IMPORTANT: To visualize the image, you must return the result of this function DIRECTLY as the final value of your code, do NOT wrap it in an object.', { + type: 'object', + properties: { + reference: schemas_1.InstanceReferenceSchema, + imageSize: { type: 'number', description: 'Size of the preview image (square)', default: 512 }, + jpegQuality: { type: 'integer', description: 'JPEG Quality of the preview image', minimum: 40, maximum: 100, default: 80 }, + transparentColor: { type: 'object', properties: { r: { type: 'integer', minimum: 0, maximum: 255 }, g: { type: 'integer', minimum: 0, maximum: 255 }, b: { type: 'integer', minimum: 0, maximum: 255 } }, required: ['r', 'g', 'b'], description: 'Background color for transparent images in RGB format' } + }, + required: ['reference'] + }, schemas_1.Base64ImageSchema, "GET", ['asset', 'preview', 'screenshot']) +], AssetTools.prototype, "assetGetPreview", null); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-tools.js","sourceRoot":"","sources":["../../../source/utcp/tools/asset-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import packageJSON from '../../../package.json';\nimport sharp from 'sharp';\nimport fs from 'fs-extra';\nimport { utcpTool } from '../decorators';\nimport { AssetInfo, AssetOperationOption } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { AssetTreeItemSchema, IAssetTreeItem, Base64ImageSchema, IBase64Image, SuccessIndicatorSchema, ISuccessIndicator, InstanceReferenceSchema, IInstanceReference } from '../schemas';\nimport path, { basename, extname } from 'path';\nimport os from 'os';\n\nfunction normalizePath(p?: string): string {\n    if (!p) return 'db://assets';\n    let path = p.replace(/\\\\/g, '/').trim();\n\n    // Handle db:// protocol\n    if (path.startsWith('db://')) {\n        return path.endsWith('/') && path !== 'db://' ? path.slice(0, -1) : path;\n    }\n\n    // Remove leading slash\n    if (path.startsWith('/')) {\n        path = path.slice(1);\n    }\n\n    // Handle root aliases\n    if (path === '' || path === 'assets') {\n        return 'db://assets';\n    }\n\n    // Handle 'assets/' prefix\n    if (path.startsWith('assets/')) {\n        const result = 'db://' + path;\n        return result.endsWith('/') ? result.slice(0, -1) : result;\n    }\n\n    // Treat as relative path under assets\n    if (path.endsWith('/')) {\n        path = path.slice(0, -1);\n    }\n\n    return `db://assets/${path}`;\n}\n\nexport class AssetTools {\n\n    @utcpTool(\n        'assetGetTree',\n        'Get the asset and subAsset hierarchy tree. Children have recursive structure.',\n        {\n            type: 'object',\n            properties: {\n                reference: InstanceReferenceSchema,\n                assetPath: { type: 'string', description: 'Root path to start from' }\n            }\n        },\n        AssetTreeItemSchema, \"GET\", ['asset', 'file', 'tree', 'hierarchy', 'folder', 'subasset']\n    )\n    async assetGetTree(args: { reference?: IInstanceReference, assetPath?: string }): Promise<IAssetTreeItem> {\n        if (args.reference) {\n            const info = await Editor.Message.request('asset-db', 'query-asset-info', args.reference.id);\n            if (!info) {\n                throw new Error(`Asset with UUID ${args.reference.id} not found.`);\n            }\n            args.assetPath = info.url;\n        }\n\n        let rootPath = normalizePath(args.assetPath);\n\n        const pattern = `${rootPath}/**`;\n        const assets = await Editor.Message.request('asset-db', 'query-assets', { pattern });\n        const rootUuid = await Editor.Message.request('asset-db', 'query-uuid', rootPath);\n\n        const assetsMap = new Map<string, IAssetTreeItem>();\n\n        // Create Root Node first\n        const rootName = rootPath.split('/').pop() || 'assets';\n        const rootNode: IAssetTreeItem = {\n            filesystemPath: Editor.Project.path + '/' + rootPath.replace('db://', ''),\n            reference: { id: rootUuid || 'root', type: 'folder' },\n            name: rootName,\n            children: []\n        };\n        assetsMap.set(rootPath, rootNode);\n\n        // First pass: Map assets\n        assets.forEach((asset: any) => {\n            if (asset.url === rootPath) return; // Skip root, already created\n\n            const type = asset.isDirectory ? 'folder' : asset.type;\n\n            const treeItem: IAssetTreeItem = {\n                reference: { id: asset.uuid, type: type },\n                name: asset.name,\n                children: []\n            };\n\n            assetsMap.set(asset.url, treeItem);\n        });\n\n        // Second pass: Build hierarchy\n        assets.forEach((asset: any) => {\n            if (asset.url === rootPath) return;\n\n            const treeItem = assetsMap.get(asset.url);\n            if (!treeItem) return;\n\n            const parentUrl = asset.url.substring(0, asset.url.lastIndexOf('/'));\n            const parentItem = assetsMap.get(parentUrl);\n\n            if (parentItem) {\n                parentItem.children.push(treeItem);\n            }\n        });\n\n        return rootNode;\n    }\n\n    @utcpTool(\n        'assetGetAtPath',\n        'Get asset reference by given local path and name, including extension. Can be used for subassets too. Returns reference to the asset.',\n        {\n            type: 'object',\n            properties: {\n                assetPath: { type: 'string' }\n            },\n            required: ['assetPath']\n        },\n        { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] }, \"GET\", ['asset', 'get', 'path', 'look', 'find']\n    )\n    async assetGetAtPath(args: { assetPath: string }): Promise<{ reference: IInstanceReference }> {\n        let targetPath = normalizePath(args.assetPath);\n\n        console.log(`Looking for asset at path: ${targetPath}`);\n\n        const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', targetPath);\n        if (!assetInfo) {\n            throw new Error(`Asset not found at path: ${targetPath}`);\n        } else {\n            return { reference: { id: assetInfo.uuid, type: assetInfo.type } };\n        }\n    }\n\n    @utcpTool(\n        'assetCreate',\n        'Create empty asset or folder of given type. Automatically handles folders creation along the path. Returns reference to the new asset.',\n        {\n            type: 'object',\n            properties: {\n                assetPath: { type: 'string' },\n                preset: {\n                    type: 'string',\n                    enum: [\n                        'folder',\n                        'material',\n                        'effect',\n                        'scene',\n                        'prefab',\n                        'typescript',\n                        'animation-clip',\n                        'render-texture',\n                        'physics-material',\n                        'animation-graph',\n                        'animation-graph-variant',\n                        'animation-mask',\n                        'auto-atlas',\n                        'effect-header',\n                        'label-atlas',\n                        'terrain'\n                    ],\n                    description: 'Preset type for the new asset'\n                },\n                options: { type: 'object', properties: { overwrite: { type: 'boolean' }, rename: { type: 'boolean' } }, description: 'Additional options for the operation', nullable: true },\n            },\n            required: ['assetPath', 'preset']\n        },\n        { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] }, \"POST\", ['asset', 'create', 'new', 'preset', 'folder', 'typescript']\n    )\n    async assetCreate(args: { assetPath: string; preset: string; options?: { overwrite?: boolean, rename?: boolean } }): Promise<{ reference: IInstanceReference }> {\n        let targetPath = normalizePath(args.assetPath);\n\n        // Map 'preset' from schema to 'type' expected by function\n        const type = args.preset;\n        const presetMap: Record<string, string> = {\n            'material': 'db://internal/default_file_content/material/default.mtl',\n            'effect': 'db://internal/default_file_content/effect/default.effect',\n            'scene': 'db://internal/default_file_content/scene/default.scene',\n            'prefab': 'db://internal/default_file_content/prefab/default.prefab',\n            'animation-clip': 'db://internal/default_file_content/animation-clip/default.anim',\n            'render-texture': 'db://internal/default_file_content/render-texture/default.rt',\n            'physics-material': 'db://internal/default_file_content/physics-material/default.pmtl',\n            'animation-graph': 'db://internal/default_file_content/animation-graph/default.animgraph',\n            'animation-graph-variant': 'db://internal/default_file_content/animation-graph-variant/default.animgraphvari',\n            'animation-mask': 'db://internal/default_file_content/animation-mask/default.animask',\n            'auto-atlas': 'db://internal/default_file_content/auto-atlas/default.pac',\n            'effect-header': 'db://internal/default_file_content/effect-header/chunk',\n            'label-atlas': 'db://internal/default_file_content/label-atlas/default.labelatlas',\n            'terrain': 'db://internal/default_file_content/terrain/default.terrain'\n        };\n\n        const assetOptions: AssetOperationOption = {\n            overwrite: args.options?.overwrite ?? false,\n            rename: args.options?.rename ?? false\n        };\n\n        if (type === 'folder' || type === 'typescript') {\n            let content: string | null = null;\n            if (type === 'typescript') {\n                const currentExtName = extname(targetPath);\n                if (currentExtName !== '.ts') {\n                    targetPath = currentExtName ? targetPath.slice(0, -currentExtName.length) : targetPath;\n                    targetPath += '.ts';\n                }\n                const className = basename(targetPath.slice('db://'.length), '.ts');\n                content = this.generateTypescriptClassTemplate(className);\n            }\n\n            const result = await Editor.Message.request('asset-db', 'create-asset', targetPath, content, assetOptions);\n            if (!result) {\n                throw new Error(`Failed to create folder at ${targetPath}`);\n            } else {\n                return { reference: { id: result.uuid, type: type } };\n            }\n        }\n\n        const source = presetMap[type];\n        if (!source) {\n            throw new Error(`Unknown asset preset type: ${type}`);\n        }\n\n        if (extname(targetPath) === '' && type !== 'folder') {\n            targetPath += type == 'chunk' ? '.chunk' : extname(presetMap[type]);\n        }\n\n        const assetInfo = await Editor.Message.request('asset-db', 'copy-asset', source, targetPath, assetOptions);\n        if (!assetInfo) {\n            throw new Error(`Failed to create asset at ${targetPath}`);\n        } else {\n            return { reference: { id: assetInfo.uuid, type: assetInfo.type } };\n        }\n    }\n\n    @utcpTool(\n        'assetImport',\n        'Import an external file as an asset into the project. Path must end with the extension. Returns reference to the new asset.',\n        {\n            type: 'object',\n            properties: {\n                sourceFilesystemPath: { type: 'string', description: 'Source filesystem path of the file to import' },\n                targetAssetPath: { type: 'string', description: 'Target path in the asset database' },\n                imageType: { type: 'string', enum: ['raw', 'texture', 'normal-map', 'sprite-frame', 'texture-cube'], description: 'For image files, specify how to import them' },\n                options: { type: 'object', properties: { overwrite: { type: 'boolean' }, rename: { type: 'boolean' } }, description: 'Additional options for the operation' },\n            },\n            required: ['sourceFilesystemPath', 'targetAssetPath']\n        },\n        { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] }, \"POST\", ['asset', 'import', 'file', 'external', 'image']\n    )\n    async assetImport(args: { sourceFilesystemPath: string, targetAssetPath: string, imageType?: 'raw' | 'texture' | 'normal-map' | 'sprite-frame' | 'texture-cube', options?: { overwrite?: boolean, rename?: boolean } }): Promise<{ reference: IInstanceReference }> {\n        let targetPath = normalizePath(args.targetAssetPath);\n\n        const assetOptions: AssetOperationOption = {\n            overwrite: args.options?.overwrite ?? false,\n            rename: args.options?.rename ?? false\n        };\n\n        // Additional resolving for absolute path\n        if (args.sourceFilesystemPath.startsWith('~')) {\n            args.sourceFilesystemPath = path.join(os.homedir(), args.sourceFilesystemPath.slice(1));\n        }\n        args.sourceFilesystemPath = path.resolve(args.sourceFilesystemPath);\n        args.sourceFilesystemPath = await fs.realpath(args.sourceFilesystemPath);\n\n        // Checking for existing asset at target path\n        let existingAssetInfo: AssetInfo | null = null;\n        // If caller tries to import the same file in assets - just reimport\n        if (`${Editor.Project.path}${targetPath.slice('db:/'.length)}` === args.sourceFilesystemPath) {\n            await Editor.Message.request('asset-db', 'refresh-asset', targetPath);\n            existingAssetInfo = await Editor.Message.request('asset-db', 'query-asset-info', targetPath);\n        }\n\n        const assetInfo = existingAssetInfo ? existingAssetInfo :\n            await Editor.Message.request('asset-db', 'import-asset', args.sourceFilesystemPath, targetPath, assetOptions);\n        if (!assetInfo) {\n            throw new Error(`Failed to import asset to ${targetPath}`);\n        } else {\n            if (assetInfo.extends && assetInfo.importer === 'image' && args.imageType) {\n                // Handle image type override\n                const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n                if (meta && meta.userData) {\n                    let typeToSet: string = args.imageType;\n                    if (typeToSet === 'normal-map') {\n                        typeToSet = 'normal map';\n                    }\n                    if (typeToSet === 'texture-cube') {\n                        typeToSet = 'texture cube';\n                    }\n                    meta.userData.type = typeToSet;\n                    await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta));\n                }\n            }\n\n            return { reference: { id: assetInfo.uuid, type: assetInfo.type } };\n        }\n    }\n\n    @utcpTool(\n        'assetOperate',\n        'Perform operations on assets (move, copy, delete, open). Returns reference to the affected asset (for delete/open returns the source asset reference).',\n        {\n            type: 'object',\n            properties: {\n                operation: { type: 'string', enum: ['move', 'copy', 'delete', 'open', 'refresh', 'reimport'] },\n                reference: InstanceReferenceSchema,\n                targetAssetPath: { type: 'string', description: 'Target path (for move/copy/import)' },\n                options: { type: 'object', properties: { overwrite: { type: 'boolean' }, rename: { type: 'boolean' } }, description: 'Additional options for the operation', nullable: true },\n            },\n            required: ['operation', 'reference']\n        },\n        { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] }, \"POST\", ['asset', 'operate', 'move', 'copy', 'delete', 'open', 'refresh', 'reimport']\n    )\n    async assetOperate(args: { operation: string, reference: IInstanceReference, targetAssetPath?: string, options?: { overwrite?: boolean, rename?: boolean } }): Promise<{ reference: IInstanceReference }> {\n        const assetOptions = {\n            overwrite: args.options?.overwrite ?? false,\n            rename: args.options?.rename ?? false\n        };\n\n        args.targetAssetPath = normalizePath(args.targetAssetPath);\n        let result: AssetInfo | null = null;\n\n        switch (args.operation) {\n            case 'move':\n                if (!args.targetAssetPath) {\n                    throw new Error('Target is required for move');\n                }\n\n                result = await Editor.Message.request('asset-db', 'move-asset', args.reference.id, args.targetAssetPath, assetOptions);\n                break;\n\n            case 'copy':\n                if (!args.targetAssetPath) {\n                    throw new Error('Target is required for copy');\n                }\n                result = await Editor.Message.request('asset-db', 'copy-asset', args.reference.id, args.targetAssetPath, assetOptions);\n                break;\n\n            case 'delete':\n                result = await Editor.Message.request('asset-db', 'delete-asset', args.reference.id);\n                break;\n\n            case 'open':\n                await Editor.Message.request('asset-db', 'open-asset', args.reference.id);\n                result = null;\n                break;\n\n            case 'refresh':\n                await Editor.Message.request('asset-db', 'refresh-asset', args.reference.id);\n                result = null;\n                break;\n            case 'reimport':\n                await Editor.Message.request('asset-db', 'reimport-asset', args.reference.id);\n                result = null;\n                break;\n            default:\n                throw new Error(`Unknown operation: ${args.operation}`);\n        }\n\n        return { reference: { id: result?.uuid ?? '', type: result?.type ?? '' } };\n    }\n\n    @utcpTool(\n        'assetGetPreview',\n        'Returns preview image of the asset (Prefab, Image, Model or Material is supported). IMPORTANT: To visualize the image, you must return the result of this function DIRECTLY as the final value of your code, do NOT wrap it in an object.',\n        {\n            type: 'object',\n            properties: {\n                reference: InstanceReferenceSchema,\n                imageSize: { type: 'number', description: 'Size of the preview image (square)', default: 512 },\n                jpegQuality: { type: 'integer', description: 'JPEG Quality of the preview image', minimum: 40, maximum: 100, default: 80 },\n                transparentColor: { type: 'object', properties: { r: { type: 'integer', minimum: 0, maximum: 255 }, g: { type: 'integer', minimum: 0, maximum: 255 }, b: { type: 'integer', minimum: 0, maximum: 255 } }, required: ['r', 'g', 'b'], description: 'Background color for transparent images in RGB format' }\n            },\n            required: ['reference']\n        },\n        Base64ImageSchema, \"GET\", ['asset', 'preview', 'screenshot']\n    )\n    async assetGetPreview(args: { reference: IInstanceReference, imageSize?: number, jpegQuality?: number, transparentColor?: { r: number, g: number, b: number } }): Promise<IBase64Image> {\n        const info = await Editor.Message.request('asset-db', 'query-asset-info', args.reference.id);\n        if (!info) {\n            throw new Error(`Asset ${args.reference.id} not found.`);\n        }\n        if (!info.importer) {\n            throw new Error(`Asset ${args.reference.id} has no importer and cannot be previewed.`);\n        }\n\n        args.imageSize = args.imageSize || 512;\n        args.jpegQuality = args.jpegQuality || 80;\n        args.transparentColor = args.transparentColor || { r: 0, g: 0, b: 0 };\n        let importer = info.importer;\n\n        const supportedImporters = [\n            'erp-texture-cube',\n            'image',\n            'sprite-frame',\n            'texture',\n            'fbx',\n            'gltf',\n            'gltf-mesh',\n            'prefab',\n            'material',\n            'spine',\n            'gltf-skeleton',\n            'scene'\n        ];\n\n        if (!supportedImporters.includes(importer)) {\n            throw new Error(`Asset preview not supported for asset type: ${info.type}`);\n        }\n\n        if (importer === 'fbx' || importer === 'gltf') {\n            const mesh = Object.values(info.subAssets).find((sub: any) => sub.importer === 'gltf-mesh');\n            if (!mesh) {\n                throw new Error(`Asset ${args.reference.id} has no gltf-mesh sub-asset for preview.`);\n            }\n            args.reference.id = mesh.uuid;\n            importer = 'gltf-mesh';\n        }\n\n        let sourcePath: string | null = null;\n\n        if (importer === 'gltf-mesh' || importer === 'mesh') {\n            sourcePath = (await Editor.Message.request('asset-db', 'query-asset-thumbnail', args.reference.id, \"origin\") as any).value;\n        } else if (['erp-texture-cube', 'image', 'sprite-frame', 'texture'].includes(importer)) {\n            let fileUuid = args.reference.id;\n            if (args.reference.id.includes('@')) {\n                fileUuid = args.reference.id.split('@')[0];\n            }\n\n            const fileInfo = await Editor.Message.request('asset-db', 'query-asset-info', fileUuid);\n            if (fileInfo && fileInfo.file) {\n                sourcePath = fileInfo.file;\n            }\n        }\n\n        if (sourcePath && fs.existsSync(sourcePath)) {\n            try {\n                const image = sharp(sourcePath);\n                const metadata = await image.metadata();\n                const requestedSize = args.imageSize || 512;\n                let processed = image;\n\n                if (\n                    (metadata.width && metadata.width > requestedSize) ||\n                    (metadata.height && metadata.height > requestedSize)\n                ) {\n                    processed = processed.resize(requestedSize, requestedSize, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } });\n                }\n\n                let buffer;\n                if ((metadata.format === 'png' || metadata.hasAlpha)) {\n                    buffer = await processed.flatten({ background: args.transparentColor })\n                        .jpeg({ quality: args.jpegQuality || 80 })\n                        .toBuffer();\n                } else {\n                    buffer = await processed\n                        .jpeg({ quality: args.jpegQuality || 80 })\n                        .toBuffer();\n                }\n                return { type: \"image\", data: buffer.toString('base64'), mimeType: \"image/jpeg\" };\n            } catch (e) {\n                console.error(`Failed to process image from ${sourcePath} with sharp:`, e);\n            }\n        }\n\n        // Open panel to ensure renderer process is alive\n        await Editor.Panel.openBeside('scene', `${packageJSON.name}.preview`);\n\n        let base64Image: string;\n        try {\n            // Request generation\n            base64Image = await Editor.Message.request(packageJSON.name, 'generate-preview', args.reference.id, args.imageSize || 512, args.imageSize || 512, (args.jpegQuality || 80) / 100);\n        } finally {\n            // Close panel\n            await Editor.Panel.close(`${packageJSON.name}.preview`);\n        }\n\n        if (!base64Image) {\n            throw new Error(`Failed to generate preview for asset ${args.reference.id}.`);\n        }\n        return { type: \"image\", data: base64Image, mimeType: \"image/jpeg\" };\n    }\n\n    private generateTypescriptClassTemplate(className: string): string {\n        return `import { _decorator, Component, Node } from 'cc';\nconst { ccclass, property } = _decorator;\n\n@ccclass('${className}')\nexport class ${className} extends Component {\n    start() {\n\n    }\n\n    update(deltaTime: number) {\n        \n    }\n}`;\n    }\n}"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/tools/component-tools.js b/extensions/cocos-code-mode/dist/utcp/tools/component-tools.js new file mode 100644 index 0000000..65a248d --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/tools/component-tools.js @@ -0,0 +1,129 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ComponentTools = void 0; +const package_json_1 = __importDefault(require("../../../package.json")); +const decorators_1 = require("../decorators"); +const schemas_1 = require("../schemas"); +class ComponentTools { + async nodeGetAvailableComponentTypes(args) { + const allComponents = await Editor.Message.request('scene', 'query-components'); + if (!Array.isArray(allComponents)) { + throw new Error('Failed to retrieve component types'); + } + const lowerFilter = args.filter ? args.filter.toLowerCase() : null; + const filtered = allComponents.filter((comp) => { + let matchesFilter = true; + if (lowerFilter) { + matchesFilter = comp.type && comp.type.toLowerCase().includes(lowerFilter); + } + if (!args.includeInternal) { + matchesFilter = matchesFilter && comp.assetUuid && comp.assetUuid.length > 0; + } + return matchesFilter; + }); + const names = filtered.map((comp) => comp.name).filter((name) => typeof name === 'string'); + return { componentTypes: names }; + } + async nodeComponentsGet(args) { + var _a, _b, _c; + const node = await Editor.Message.request('scene', 'query-node', args.reference.id); + if (!node) { + throw new Error(`Node ${args.reference.id} not found`); + } + const components = node.__comps__ || []; + const foundComponents = []; + for (const comp of components) { + const compUuid = (_b = (_a = comp.value) === null || _a === void 0 ? void 0 : _a.uuid) === null || _b === void 0 ? void 0 : _b.value; + if (!args.componentType || ((_c = comp.type) === null || _c === void 0 ? void 0 : _c.includes(args.componentType))) { + foundComponents.push({ id: compUuid, type: comp.type }); + } + } + if (foundComponents.length > 0) { + return { references: foundComponents }; + } + throw new Error(`Components of type ${args.componentType} not found on node ${args.reference.id}`); + } + async nodeComponentRemove(args) { + try { + const component = await Editor.Message.request('scene', 'query-component', args.reference.id); + if (component === null || component === undefined) { + throw new Error(`Component ${args.reference.id} not found`); + } + await Editor.Message.request('scene', 'remove-component', { + uuid: args.reference.id + }); + await Editor.Message.request('scene', 'snapshot'); + return { success: true }; + } + catch (error) { + throw new Error(`Failed to remove component ${args.reference.id}. Reason: ${(error === null || error === void 0 ? void 0 : error.message) || error}`); + } + } + async nodeComponentAdd(args) { + const node = await Editor.Message.request('scene', 'query-node', args.reference.id); + if (!node) { + throw new Error(`Node ${args.reference.id} not found`); + } + const beforeComponents = node.__comps__ ? node.__comps__.map((c) => { var _a, _b, _c; return ((_b = (_a = c.value) === null || _a === void 0 ? void 0 : _a.uuid) === null || _b === void 0 ? void 0 : _b.value) || ((_c = c.value) === null || _c === void 0 ? void 0 : _c.uuid) || c.uuid; }) : []; + const existingUuids = new Set(beforeComponents); + await Editor.Message.request('scene', 'execute-scene-script', { name: package_json_1.default.name, method: 'startCatchLogging', args: [] }); + await Editor.Message.request('scene', 'create-component', { + uuid: args.reference.id, + component: args.componentType + }); + const nodeAfter = await Editor.Message.request('scene', 'query-node', args.reference.id); + const afterComponents = nodeAfter.__comps__ ? + nodeAfter.__comps__.map((c) => { var _a, _b; return { id: (_b = (_a = c.value) === null || _a === void 0 ? void 0 : _a.uuid) === null || _b === void 0 ? void 0 : _b.value, type: c.type }; }) : []; + const caughtLogs = await Editor.Message.request('scene', 'execute-scene-script', { name: package_json_1.default.name, method: 'stopCatchLogging', args: [] }); + const newComponentRef = afterComponents.find(ref => !existingUuids.has(ref.id)); + if (newComponentRef) { + await Editor.Message.request('scene', 'snapshot'); + return { reference: { id: newComponentRef.id, type: newComponentRef.type } }; + } + throw new Error("Failed to add component. Captured logs: " + caughtLogs.join('\n')); + } +} +exports.ComponentTools = ComponentTools; +__decorate([ + (0, decorators_1.utcpTool)('nodeGetAvailableComponentTypes', 'Get list of globally available component types (class names) at the moment.', { + type: 'object', + properties: { + includeInternal: { type: 'boolean', default: false, description: 'Whether to include internal engine components.' }, + filter: { type: 'string', description: 'Optional filter string to match component types or categories (case-insensitive substring match).' } + }, + required: ['includeInternal'] + }, { type: 'object', properties: { componentTypes: { type: 'array', items: { type: 'string' } } }, required: ['componentTypes'] }, "GET", ['scene', 'node', 'component', 'types', 'inspection']) +], ComponentTools.prototype, "nodeGetAvailableComponentTypes", null); +__decorate([ + (0, decorators_1.utcpTool)('nodeComponentsGet', 'Get components of specific type on a node. If componentType is not provided, returns all components on the node.', { + type: 'object', + properties: { + reference: schemas_1.InstanceReferenceSchema, + componentType: { type: 'string' } + }, + required: ['reference'] + }, { type: 'object', properties: { references: { type: 'array', items: schemas_1.InstanceReferenceSchema } }, required: ['references'] }, "GET", ['scene', 'node', 'component', 'get', 'inspection']) +], ComponentTools.prototype, "nodeComponentsGet", null); +__decorate([ + (0, decorators_1.utcpTool)('nodeComponentRemove', 'Remove referenced component from node it is attached to.', { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, schemas_1.SuccessIndicatorSchema, "POST", ['scene', 'node', 'component', 'remove', 'delete']) +], ComponentTools.prototype, "nodeComponentRemove", null); +__decorate([ + (0, decorators_1.utcpTool)('nodeComponentAdd', 'Add a component to a referenced node, returns reference to the new component', { + type: 'object', + properties: { + reference: schemas_1.InstanceReferenceSchema, + componentType: { type: 'string' } + }, + required: ['reference', 'componentType'] + }, { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, "POST", ['scene', 'node', 'component', 'add']) +], ComponentTools.prototype, "nodeComponentAdd", null); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-tools.js","sourceRoot":"","sources":["../../../source/utcp/tools/component-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import packageJSON from '../../../package.json';\nimport { utcpTool } from '../decorators';\nimport { SuccessIndicatorSchema, ISuccessIndicator, InstanceReferenceSchema, IInstanceReference } from '../schemas';\n\nexport class ComponentTools {\n\n    @utcpTool(\n        'nodeGetAvailableComponentTypes',\n        'Get list of globally available component types (class names) at the moment.',\n        {\n            type: 'object',\n            properties: {\n                includeInternal: { type: 'boolean', default: false, description: 'Whether to include internal engine components.' },\n                filter: { type: 'string', description: 'Optional filter string to match component types or categories (case-insensitive substring match).' }\n            },\n            required: ['includeInternal']\n        },\n        { type: 'object', properties: { componentTypes: { type: 'array', items: { type: 'string' } } }, required: ['componentTypes'] }, \"GET\",  ['scene', 'node', 'component', 'types', 'inspection']\n    )\n    async nodeGetAvailableComponentTypes(args: { includeInternal: boolean, filter?: string }): Promise<{ componentTypes: string[] }> {\n        const allComponents = await Editor.Message.request('scene', 'query-components');\n        \n        if (!Array.isArray(allComponents)) {\n            throw new Error('Failed to retrieve component types');\n        }\n\n        const lowerFilter = args.filter ? args.filter.toLowerCase() : null;\n        const filtered = allComponents.filter((comp: any) => {\n            let matchesFilter = true;\n            if (lowerFilter) {\n                matchesFilter = comp.type && comp.type.toLowerCase().includes(lowerFilter);\n            }\n            if (!args.includeInternal) {\n                matchesFilter = matchesFilter && comp.assetUuid && comp.assetUuid.length > 0;\n            }\n            return matchesFilter;\n        });\n\n        const names = filtered.map((comp: any) => comp.name).filter((name: any) => typeof name === 'string');\n\n        return { componentTypes: names };\n    }\n\n    @utcpTool(\n        'nodeComponentsGet',\n        'Get components of specific type on a node. If componentType is not provided, returns all components on the node.',\n        {\n            type: 'object',\n            properties: {\n                reference: InstanceReferenceSchema,\n                componentType: { type: 'string' }\n            },\n            required: ['reference']\n        },\n        { type: 'object', properties: { references: { type: 'array', items: InstanceReferenceSchema } }, required: ['references'] }, \"GET\",  ['scene', 'node', 'component', 'get', 'inspection']\n    )\n    async nodeComponentsGet(args: { reference: IInstanceReference, componentType?: string }): Promise<{ references: IInstanceReference[] }> {\n        const node = await Editor.Message.request('scene', 'query-node', args.reference.id);\n        if (!node) {\n            throw new Error(`Node ${args.reference.id} not found`);\n        }\n\n        const components = node.__comps__ || [];\n        const foundComponents: IInstanceReference[] = [];\n        for (const comp of components) {\n            const compUuid = (comp.value as any)?.uuid?.value;\n            if (!args.componentType || comp.type?.includes(args.componentType)) {\n                foundComponents.push({ id: compUuid, type: comp.type });\n            }\n        }\n\n        if (foundComponents.length > 0) {\n            return { references: foundComponents };\n        }\n\n        throw new Error(`Components of type ${args.componentType} not found on node ${args.reference.id}`);\n    }\n\n    @utcpTool(\n        'nodeComponentRemove',\n        'Remove referenced component from node it is attached to.',\n        { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] },\n        SuccessIndicatorSchema, \"POST\",  ['scene', 'node', 'component', 'remove', 'delete']\n    )\n    async nodeComponentRemove(args: { reference: IInstanceReference }): Promise<ISuccessIndicator> {\n        try {\n            const component = await Editor.Message.request('scene', 'query-component', args.reference.id);\n            if (component === null || component === undefined) {\n                throw new Error(`Component ${args.reference.id} not found`);\n            }\n\n            await Editor.Message.request('scene', 'remove-component', {\n                uuid: args.reference.id\n            });\n\n            await Editor.Message.request('scene', 'snapshot');\n\n            return { success: true };\n        } catch (error: any) {\n            throw new Error(`Failed to remove component ${args.reference.id}. Reason: ${error?.message || error}`);\n        }\n    }\n\n    @utcpTool(\n        'nodeComponentAdd',\n        'Add a component to a referenced node, returns reference to the new component',\n        {\n            type: 'object',\n            properties: {\n                reference: InstanceReferenceSchema,\n                componentType: { type: 'string' }\n            },\n            required: ['reference', 'componentType']\n        },\n        { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] }, \"POST\",  ['scene', 'node', 'component', 'add']\n    )\n    async nodeComponentAdd(args: { reference: IInstanceReference, componentType: string }): Promise<{ reference: IInstanceReference }> {\n        const node = await Editor.Message.request('scene', 'query-node', args.reference.id);\n        if (!node) {\n            throw new Error(`Node ${args.reference.id} not found`);\n        }\n\n        const beforeComponents = node.__comps__ ? node.__comps__.map((c: any) => c.value?.uuid?.value || c.value?.uuid || c.uuid) : [];\n        const existingUuids = new Set(beforeComponents);\n\n        await Editor.Message.request('scene', 'execute-scene-script', \n            { name: packageJSON.name, method: 'startCatchLogging', args: [] });\n\n        await Editor.Message.request('scene', 'create-component', {\n            uuid: args.reference.id,\n            component: args.componentType\n        });\n\n        const nodeAfter = await Editor.Message.request('scene', 'query-node', args.reference.id);\n        const afterComponents: IInstanceReference[] = nodeAfter.__comps__ ? \n            nodeAfter.__comps__.map((c: any) => { return { id: c.value?.uuid?.value, type: c.type } }) : [];\n        \n        const caughtLogs: string[] = await Editor.Message.request('scene', 'execute-scene-script', \n            { name: packageJSON.name, method: 'stopCatchLogging', args: [] });\n\n        const newComponentRef = afterComponents.find(ref => !existingUuids.has(ref.id));\n\n        if (newComponentRef) {\n            await Editor.Message.request('scene', 'snapshot');\n\n            return { reference: { id: newComponentRef.id, type: newComponentRef.type } };\n        }\n\n        throw new Error(\"Failed to add component. Captured logs: \" + caughtLogs.join('\\n'));\n    }\n}"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/tools/editor-tools.js b/extensions/cocos-code-mode/dist/utcp/tools/editor-tools.js new file mode 100644 index 0000000..298d7ae --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/tools/editor-tools.js @@ -0,0 +1,209 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.EditorTools = void 0; +const package_json_1 = __importDefault(require("../../../package.json")); +const decorators_1 = require("../decorators"); +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +const schemas_1 = require("../schemas"); +class EditorTools { + async editorOperate(args) { + switch (args.operation) { + case 'save_scene_or_prefab': + await Editor.Message.request('scene', 'save-scene'); + return { success: true }; + case 'close_scene_or_prefab': + await Editor.Message.request('scene', 'close-scene'); + return { success: true }; + case 'play_preview': + await Editor.Message.request('scene', 'editor-preview-set-play', true); + return { success: true }; + case 'pause': + await Editor.Message.request('scene', 'editor-preview-call-method', 'pause', true); + return { success: true }; + case 'step': + await Editor.Message.request('scene', 'editor-preview-call-method', 'step'); + return { success: true }; + case 'stop': + await Editor.Message.request('scene', 'editor-preview-set-play', false); + return { success: true }; + case 'refresh': + await Editor.Message.request('asset-db', 'refresh-asset', 'db://assets'); + return { success: true }; + default: + throw new Error(`Unknown operation: ${args.operation}`); + } + } + async editorGetLogs(args) { + const projectPath = Editor.Project.path; + const logPath = path.join(projectPath, 'temp', 'logs', 'project.log'); + if (args.showStack === undefined) { + args.showStack = false; + } + if (!fs.existsSync(logPath)) { + throw new Error(`Log file not found at ${logPath}`); + } + const entries = []; + const fd = fs.openSync(logPath, 'r'); + try { + const stats = fs.fstatSync(fd); + const fileSize = stats.size; + const bufferSize = 10 * 1024; // 10KB chunks + const buffer = Buffer.alloc(bufferSize); + let position = fileSize; + let leftover = ''; + let accumulatedBody = ''; // Text belonging to the current (bottom-most) entry being parsed + const regex = /^(\d{1,2}-\d{1,2}-\d{4}\s\d{2}:\d{2}:\d{2}\s-\s(?:log|warn|error|info):\s)/; + const timestampRegex = /^\d{1,2}-\d{1,2}-\d{4}\s\d{2}:\d{2}:\d{2}\s-\s/; + let lastContent = null; + let lastCount = 0; + while (position > 0 && entries.length < args.count) { + const readSize = Math.min(bufferSize, position); + const readPos = position - readSize; + fs.readSync(fd, buffer, 0, readSize, readPos); + position -= readSize; + const chunk = buffer.toString('utf-8', 0, readSize); + const combined = chunk + leftover; + // Split by newline + const lines = combined.split(/\r?\n/); + if (position > 0) { + leftover = lines.shift() || ''; + } + else { + leftover = ''; // Process all + } + // Process lines in reverse (bottom to top of the chunk) + for (let i = lines.length - 1; i >= 0; i--) { + const line = lines[i]; + // Check if this line is a Header (Start of Entry) + if (regex.test(line)) { + let entry = line; + if (args.showStack && accumulatedBody.length > 0) { + entry += '\n' + accumulatedBody; + } + const cleaned = entry.replace(timestampRegex, ''); + if (cleaned === lastContent) { + lastCount++; + entries[entries.length - 1] = `(${lastCount}) ${cleaned}`; + } + else { + if (entries.length >= args.count) { + // Found a new group but we already have enough + position = 0; // Stop reading file loop + break; // Stop lines loop + } + lastContent = cleaned; + lastCount = 1; + entries.push(cleaned); + } + accumulatedBody = ''; // Reset for the next entry (upwards) + } + else { + // This identifies as body text (or empty line) belonging to the entry "above" it + if (args.showStack && accumulatedBody.length > 0) { + accumulatedBody = line + '\n' + accumulatedBody; + } + else { + accumulatedBody = line; + } + } + } + } + } + finally { + fs.closeSync(fd); + } + // We pushed entries in reverse order (newest first). + if (args.order === 'oldest-to-newest') { + return { logLines: entries.reverse() }; + } + return { logLines: entries }; + } + async editorGetScenePreview(args) { + var _a, _b, _c, _d; + const result = await Editor.Message.request('scene', 'execute-scene-script', { + name: package_json_1.default.name, + method: 'captureScreenshot', + args: [(_a = args.imageSize) !== null && _a !== void 0 ? _a : { width: 512, height: 512 }, (_b = args.jpegQuality) !== null && _b !== void 0 ? _b : 80, args.cameraPosition, args.targetPosition, (_c = args.orthographic) !== null && _c !== void 0 ? _c : false, (_d = args.orthographicSize) !== null && _d !== void 0 ? _d : 10] + }); + return { type: 'image', data: result, mimeType: 'image/jpeg' }; + } +} +exports.EditorTools = EditorTools; +__decorate([ + (0, decorators_1.utcpTool)('editorOperate', 'Common editor operations for scene and prefab view, game preview controls and asset database refresh', { + type: 'object', + properties: { + operation: { type: 'string', enum: ['save_scene_or_prefab', 'close_scene_or_prefab', 'play_preview', 'pause', 'step', 'stop', 'refresh'] } + }, + required: ['operation'] + }, schemas_1.SuccessIndicatorSchema, "POST", ['operation', 'editor', 'scene', 'prefab', 'preview', 'asset', 'refresh']) +], EditorTools.prototype, "editorOperate", null); +__decorate([ + (0, decorators_1.utcpTool)('editorGetLogs', 'Get last N editor log entries', { + type: 'object', + properties: { + count: { type: 'number', description: 'Number of log entries to retrieve', default: 10 }, + showStack: { type: 'boolean', description: 'Return full stack trace for each log entry' }, + order: { type: 'string', enum: ['newest-to-oldest', 'oldest-to-newest'], description: 'Order of logs', default: 'newest-to-oldest' } + }, + required: ['count', 'order'] + }, { type: 'object', properties: { logLines: { type: 'array', items: { type: 'string' } } }, required: ['logLines'] }, "GET", ['editor', 'logs', 'debug', 'info']) +], EditorTools.prototype, "editorGetLogs", null); +__decorate([ + (0, decorators_1.utcpTool)('editorGetScenePreview', 'Returns preview image of scene view. IMPORTANT: To visualize the image, you must return the result of this function DIRECTLY as the final value of your code, do NOT wrap it in an object.', { + type: 'object', + properties: { + imageSize: { type: 'object', properties: { width: { type: 'number', default: 512 }, height: { type: 'number', default: 512 } }, nullable: true }, + jpegQuality: { type: 'integer', minimum: 40, maximum: 100, default: 80 }, + cameraPosition: { type: 'object', properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } }, required: ['x', 'y', 'z'], description: 'Camera world position' }, + targetPosition: { type: 'object', properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } }, required: ['x', 'y', 'z'], description: 'Point the camera looks at' }, + orthographic: { type: 'boolean', default: false, description: 'Whether to use orthographic projection' }, + orthographicSize: { type: 'number', default: 10, description: 'Orthographic size (only applies if orthographic is true)' } + }, + required: ['cameraPosition', 'targetPosition'] + }, schemas_1.Base64ImageSchema, "GET", ['scene', 'screenshot', 'preview', 'inspection', 'image']) +], EditorTools.prototype, "editorGetScenePreview", null); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-tools.js","sourceRoot":"","sources":["../../../source/utcp/tools/editor-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import packageJSON from '../../../package.json';\nimport { utcpTool } from '../decorators';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { Base64ImageSchema, IBase64Image, ISuccessIndicator, SuccessIndicatorSchema } from '../schemas';\n\nexport class EditorTools {\n\n    @utcpTool(\n        'editorOperate',\n        'Common editor operations for scene and prefab view, game preview controls and asset database refresh',\n        {\n            type: 'object',\n            properties: {\n                operation: { type: 'string', enum: ['save_scene_or_prefab', 'close_scene_or_prefab', 'play_preview', 'pause', 'step', 'stop', 'refresh'] }\n            },\n            required: ['operation']\n        },\n        SuccessIndicatorSchema, \"POST\",  ['operation', 'editor', 'scene', 'prefab', 'preview', 'asset', 'refresh']\n    )\n    async editorOperate(args: { operation: string }): Promise<ISuccessIndicator> {\n        switch (args.operation) {\n            case 'save_scene_or_prefab':\n                await Editor.Message.request('scene', 'save-scene');\n                return { success: true };\n            case 'close_scene_or_prefab':\n                await Editor.Message.request('scene', 'close-scene');\n                return { success: true };\n            case 'play_preview':\n                await Editor.Message.request('scene', 'editor-preview-set-play', true);\n                return { success: true };\n            case 'pause':\n                await Editor.Message.request('scene', 'editor-preview-call-method', 'pause', true);\n                return { success: true };\n            case 'step':\n                 await Editor.Message.request('scene', 'editor-preview-call-method', 'step');\n                return { success: true };\n            case 'stop':\n                await Editor.Message.request('scene', 'editor-preview-set-play', false);\n                return { success: true };\n            case 'refresh':\n                await Editor.Message.request('asset-db', 'refresh-asset', 'db://assets');\n                return { success: true };\n            default:\n                throw new Error(`Unknown operation: ${args.operation}`);\n        }\n    }\n\n    @utcpTool(\n        'editorGetLogs',\n        'Get last N editor log entries',\n        {\n            type: 'object',\n            properties: {\n                count: { type: 'number', description: 'Number of log entries to retrieve', default: 10 },\n                showStack: { type: 'boolean', description: 'Return full stack trace for each log entry' },\n                order: { type: 'string', enum: ['newest-to-oldest', 'oldest-to-newest'], description: 'Order of logs', default: 'newest-to-oldest' }\n            },\n            required: ['count', 'order']\n        },\n        { type: 'object', properties: { logLines: { type: 'array', items: { type: 'string' } } }, required: ['logLines'] }, \"GET\",  ['editor', 'logs', 'debug', 'info']\n    )\n    async editorGetLogs(args: { count: number, showStack: boolean, order: 'newest-to-oldest' | 'oldest-to-newest' }): Promise<{ logLines: string[] }> {\n        const projectPath = Editor.Project.path;\n        const logPath = path.join(projectPath, 'temp', 'logs', 'project.log');\n\n        if (args.showStack === undefined) {\n            args.showStack = false;\n        }\n\n        if (!fs.existsSync(logPath)) {\n            throw new Error(`Log file not found at ${logPath}`);\n        }\n\n        const entries: string[] = [];\n        const fd = fs.openSync(logPath, 'r');\n        \n        try {\n            const stats = fs.fstatSync(fd);\n            const fileSize = stats.size;\n            const bufferSize = 10 * 1024; // 10KB chunks\n            const buffer = Buffer.alloc(bufferSize);\n            \n            let position = fileSize;\n            let leftover = '';\n            let accumulatedBody = ''; // Text belonging to the current (bottom-most) entry being parsed\n            \n            const regex = /^(\\d{1,2}-\\d{1,2}-\\d{4}\\s\\d{2}:\\d{2}:\\d{2}\\s-\\s(?:log|warn|error|info):\\s)/;\n            const timestampRegex = /^\\d{1,2}-\\d{1,2}-\\d{4}\\s\\d{2}:\\d{2}:\\d{2}\\s-\\s/;\n            \n            let lastContent: string | null = null;\n            let lastCount = 0;\n\n            while (position > 0 && entries.length < args.count) {\n                const readSize = Math.min(bufferSize, position);\n                const readPos = position - readSize;\n                \n                fs.readSync(fd, buffer, 0, readSize, readPos);\n                position -= readSize;\n                \n                const chunk = buffer.toString('utf-8', 0, readSize);\n                const combined = chunk + leftover;\n                \n                // Split by newline\n                const lines = combined.split(/\\r?\\n/);\n                \n                if (position > 0) {\n                    leftover = lines.shift() || '';\n                } else {\n                    leftover = ''; // Process all\n                }\n\n                // Process lines in reverse (bottom to top of the chunk)\n                for (let i = lines.length - 1; i >= 0; i--) {\n                    const line = lines[i];\n                    \n                    // Check if this line is a Header (Start of Entry)\n                    if (regex.test(line)) {\n                        let entry = line;\n                        if (args.showStack && accumulatedBody.length > 0) {\n                            entry += '\\n' + accumulatedBody;\n                        }\n                        \n                        const cleaned = entry.replace(timestampRegex, '');\n                        \n                        if (cleaned === lastContent) {\n                            lastCount++;\n                            entries[entries.length - 1] = `(${lastCount}) ${cleaned}`;\n                        } else {\n                            if (entries.length >= args.count) {\n                                // Found a new group but we already have enough\n                                position = 0; // Stop reading file loop\n                                break; // Stop lines loop\n                            }\n                            lastContent = cleaned;\n                            lastCount = 1;\n                            entries.push(cleaned);\n                        }\n                        \n                        accumulatedBody = ''; // Reset for the next entry (upwards)\n                    } else {\n                        // This identifies as body text (or empty line) belonging to the entry \"above\" it\n                        if (args.showStack && accumulatedBody.length > 0) {\n                            accumulatedBody = line + '\\n' + accumulatedBody;\n                        } else {\n                            accumulatedBody = line;\n                        }\n                    }\n                }\n            }\n            \n        } finally {\n            fs.closeSync(fd);\n        }\n\n        // We pushed entries in reverse order (newest first).\n        if (args.order === 'oldest-to-newest') {\n             return { logLines: entries.reverse() };\n        } \n        \n        return { logLines: entries };\n    }\n\n    @utcpTool(\n        'editorGetScenePreview',\n        'Returns preview image of scene view. IMPORTANT: To visualize the image, you must return the result of this function DIRECTLY as the final value of your code, do NOT wrap it in an object.',\n        {\n            type: 'object',\n            properties: {\n                imageSize: { type: 'object', properties: { width: { type: 'number', default: 512 }, height: { type: 'number', default: 512 } }, nullable: true },\n                jpegQuality: { type: 'integer', minimum: 40, maximum: 100, default: 80 },\n                cameraPosition: { type: 'object', properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } }, required: ['x', 'y', 'z'], description: 'Camera world position'},\n                targetPosition: { type: 'object', properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } }, required: ['x', 'y', 'z'], description: 'Point the camera looks at'},\n                orthographic: { type: 'boolean', default: false, description: 'Whether to use orthographic projection'},\n                orthographicSize: { type: 'number', default: 10, description: 'Orthographic size (only applies if orthographic is true)'}\n            },\n            required: ['cameraPosition', 'targetPosition']\n        },\n        Base64ImageSchema, \"GET\", ['scene', 'screenshot', 'preview', 'inspection', 'image']\n    )\n    async editorGetScenePreview(args: { \n        imageSize?: { width: number, height: number }, \n        jpegQuality?: number, \n        cameraPosition?: { x: number, y: number, z: number }, \n        targetPosition?: { x: number, y: number, z: number },\n        orthographic?: boolean,\n        orthographicSize?: number\n    }): Promise<IBase64Image> {\n\n        const result = await Editor.Message.request('scene', 'execute-scene-script', {\n            name: packageJSON.name,\n            method: 'captureScreenshot',\n            args: [args.imageSize ?? { width: 512, height: 512 }, args.jpegQuality ?? 80, args.cameraPosition , args.targetPosition, args.orthographic ?? false, args.orthographicSize ?? 10]\n        });\n\n        return { type: 'image', data: result, mimeType: 'image/jpeg' };\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/tools/get-properties-tool.js b/extensions/cocos-code-mode/dist/utcp/tools/get-properties-tool.js new file mode 100644 index 0000000..8cbae6c --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/tools/get-properties-tool.js @@ -0,0 +1,37 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GetPropertiesTool = void 0; +const decorators_1 = require("../decorators"); +const schemas_1 = require("../schemas"); +const tools_utils_1 = require("../utils/tools-utils"); +class GetPropertiesTool { + async inspectorGetSettingsProperties(params) { + return await this.inspectorGetProperties({ reference: { id: params.settingsType } }); + } + async inspectorGetProperties(args) { + const info = await tools_utils_1.ToolsUtils.inspectInstance(args.reference.id); + if (!info) { + throw new Error(`Target ${args.reference.id} not found or not supported.`); + } + const { props, type, assetInfo } = info; + if (!props) { + throw new Error(`Could not retrieve properties for ${type} (${args.reference.id}).`); + } + const parsedProps = tools_utils_1.ToolsUtils.unwrapProperties(props); + return { dump: parsedProps }; + } +} +exports.GetPropertiesTool = GetPropertiesTool; +__decorate([ + (0, decorators_1.utcpTool)("inspectorGetSettingsProperties", "Gets plain object of properties for the specific settings.", { type: 'object', properties: { settingsType: { type: 'string', enum: ['CurrentSceneGlobals', 'ProjectSettings'] } }, required: ['settingsType'] }, { type: 'object', properties: { dump: { type: 'object' } }, required: ['dump'] }, "GET", ['inspect', 'scene', 'properties', 'settings', 'config', 'dump']) +], GetPropertiesTool.prototype, "inspectorGetSettingsProperties", null); +__decorate([ + (0, decorators_1.utcpTool)("inspectorGetInstanceProperties", "Gets plain object of properties, with no serialization info for any instance (scene node, component, asset).", { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, { type: 'object', properties: { dump: { type: 'object' } }, required: ['dump'] }, "GET", ['inspect', 'properties', 'dump', 'instance', 'node', 'component', 'asset', 'data']) +], GetPropertiesTool.prototype, "inspectorGetProperties", null); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/tools/scene-tools.js b/extensions/cocos-code-mode/dist/utcp/tools/scene-tools.js new file mode 100644 index 0000000..b5a45d7 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/tools/scene-tools.js @@ -0,0 +1,411 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SceneTools = void 0; +const package_json_1 = __importDefault(require("../../../package.json")); +const decorators_1 = require("../decorators"); +const schemas_1 = require("../schemas"); +class SceneTools { + async nodeGetTree(args) { + var _a; + let treeBase; + if (args.reference) { + treeBase = await Editor.Message.request('scene', 'query-node-tree', args.reference.id); + } + else { + // Default queries the whole scene + treeBase = await Editor.Message.request('scene', 'query-node-tree'); + } + if (!treeBase) { + throw new Error(`Node tree not found for ${((_a = args.reference) === null || _a === void 0 ? void 0 : _a.id) || 'entire scene'}`); + } + const formatNode = (node) => { + const comps = node.components ? node.components.map((c) => ({ + reference: { id: c.value, type: c.type } + })) : []; + let children = []; + children = node.children ? node.children.map(formatNode).filter((c) => c !== null) : []; + return { + reference: { id: node.uuid, type: 'cc.Node' }, + name: node.name, + active: node.active, + components: comps, + children: children + }; + }; + const result = formatNode(treeBase); + result.path = treeBase.path || undefined; + return result; + } + async nodeGetAtPath(args) { + const nodeTree = await Editor.Message.request('scene', 'query-node-tree'); + if (!nodeTree) { + throw new Error(`Scene is empty or could not retrieve scene tree.`); + } + const sceneRootName = nodeTree.name; + if (args.hierarchyPath.startsWith('/')) { + args.hierarchyPath = args.hierarchyPath.slice(1); + } + if (args.hierarchyPath.startsWith(`${sceneRootName}`)) { + args.hierarchyPath = args.hierarchyPath.slice(sceneRootName.length); + } + if (args.hierarchyPath === '') { + return { references: [{ id: nodeTree.uuid }] }; + } + const pathParts = args.hierarchyPath.split('/').filter(p => p.length > 0); + let currentNodes = [nodeTree]; + for (const part of pathParts) { + const nextNodes = []; + for (const node of currentNodes) { + const matchingChildren = (node.children || []).filter((child) => child.name === part); + nextNodes.push(...matchingChildren); + } + currentNodes = nextNodes; + if (currentNodes.length === 0) { + break; + } + } + return { references: currentNodes.map((node) => ({ id: node.uuid, type: 'cc.Node' })) }; + } + async sceneCreatePrimitiveNode(args) { + const primitiveMap = { + 'Capsule': "db://internal/default_prefab/3d/Capsule.prefab", + 'Cone': "db://internal/default_prefab/3d/Cone.prefab", + 'Cube': "db://internal/default_prefab/3d/Cube.prefab", + 'Cylinder': "db://internal/default_prefab/3d/Cylinder.prefab", + 'Plane': "db://internal/default_prefab/3d/Plane.prefab", + 'Quad': "db://internal/default_prefab/3d/Quad.prefab", + 'Sphere': "db://internal/default_prefab/3d/Sphere.prefab", + 'Torus': "db://internal/default_prefab/3d/Torus.prefab", + }; + if (!primitiveMap[args.primitiveType]) { + throw new Error(`Unsupported primitive type: ${args.primitiveType}`); + } + const prefabUrl = primitiveMap[args.primitiveType]; + const assetUuid = await Editor.Message.request('asset-db', 'query-uuid', prefabUrl); + if (!assetUuid) { + throw new Error(`Failed to find asset for primitive type ${args.primitiveType} at ${prefabUrl}`); + } + return await this.sceneCreateNode({ + name: args.name, + parentReference: args.parentReference, + assetReference: { id: assetUuid, type: 'cc.Prefab' }, + unwrapPrefab: true + }); + } + async sceneCreateNode(args) { + const options = { + name: args.name + }; + if (args.parentReference) { + options.parent = args.parentReference.id; + } + else { + // Force root if no parent provided + options.parent = (await Editor.Message.request('scene', 'query-node-tree')).uuid; + } + let assetUuid = null; + // 1. Determine Asset UUID + if ((args.assetReference && 'id' in args.assetReference)) { + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', args.assetReference.id); + if (!assetInfo) { + throw new Error(`Asset reference not found: ${args.assetReference.id}`); + } + let prefabFound = assetInfo.type === 'cc.Prefab'; + // If not a prefab, check if it has a prefab sub-asset (like in case of FBX) + if (!prefabFound) { + for (let subAsset of Object.values(assetInfo.subAssets)) { + if (subAsset.type === 'cc.Prefab') { + assetUuid = subAsset.uuid; + prefabFound = true; + break; + } + } + } + else { + assetUuid = assetInfo.uuid; + } + if (!prefabFound) { + throw new Error(`Provided asset reference ${args.assetReference.id} is not a prefab and does not contain a prefab sub-asset.`); + } + else { + if (!args.unwrapPrefab) { + options.unlinkPrefab = false; + options.type = 'cc.Prefab'; + } + } + } + if (assetUuid) { + options.assetUuid = assetUuid; + } + // 2. Create Node + const result = await Editor.Message.request('scene', 'create-node', options); + const newNodeUuid = Array.isArray(result) ? result[0] : result; + if (!newNodeUuid) { + throw new Error(`Failed to create node ${args.name}${args.assetReference ? ` from asset ${args.assetReference.id}` : ''}.`); + } + await Editor.Message.request('scene', 'snapshot'); + return { reference: { id: newNodeUuid, type: 'cc.Node' } }; + } + async nodeOperate(args) { + if (await Editor.Message.request('scene', 'query-node', args.reference.id) === null) { + throw new Error(`Target node ${args.reference.id} not found`); + } + switch (args.operation) { + case 'move': + if (!args.newParentReference) { + throw new Error("newParentReference required for move"); + } + await Editor.Message.request('scene', 'set-parent', { + parent: args.newParentReference.id, + uuids: args.reference.id, + keepWorldTransform: true + }); + if (args.siblingIndex !== undefined) { + await this.setSiblingIndex(args.reference.id, args.siblingIndex); + } + await Editor.Message.request('scene', 'snapshot'); + return { success: true }; + case 'copy': + const duplicateResult = await Editor.Message.request('scene', 'duplicate-node', [args.reference.id]); + if (!duplicateResult || duplicateResult.length === 0) { + throw new Error(`Node ${args.reference.id} duplication failed`); + } + const newNodes = duplicateResult; + const newNodeId = newNodes[0]; + if (args.newParentReference) { + await Editor.Message.request('scene', 'set-parent', { + parent: args.newParentReference.id, + uuids: newNodes, + keepWorldTransform: true + }); + } + if (args.siblingIndex !== undefined) { + await this.setSiblingIndex(newNodeId, args.siblingIndex); + } + await Editor.Message.request('scene', 'snapshot'); + return { success: true, copiedNodeReference: { id: newNodeId, type: 'cc.Node' } }; + case 'delete': + await Editor.Message.request('scene', 'remove-node', { + uuid: args.reference.id + }); + const nodeCheck = await Editor.Message.request('scene', 'query-node', args.reference.id); + if (nodeCheck !== null && nodeCheck !== undefined) { + throw new Error(`Node ${args.reference.id} still exists after removal`); + } + await Editor.Message.request('scene', 'snapshot'); + return { success: true }; + case 'create_prefab': + if (!args.newPrefabPath) { + throw new Error("newPrefabPath required for create_prefab"); + } + const parentInfo = await this.getParentAndSiblingIndex(args.reference.id); + const createdPrefabUuid = await Editor.Message.request('scene', 'execute-scene-script', { + name: package_json_1.default.name, + method: 'createPrefabFromNode', + args: [args.reference.id, args.newPrefabPath] + }); + if (!createdPrefabUuid) { + throw new Error("Failed to create prefab asset."); + } + const updatedNodeId = await this.getUpdatedUuid(parentInfo.parentUuid, parentInfo.siblingIndex); + await Editor.Message.request('scene', 'snapshot'); + return { success: true, createdPrefabAssetReference: { id: createdPrefabUuid, type: 'cc.Prefab' }, updatedNodeReference: { id: updatedNodeId, type: 'cc.Node' } }; + case 'revert_prefab': + const revertSuccess = await Editor.Message.request('scene', 'restore-prefab', { uuid: args.reference.id }); + await Editor.Message.request('scene', 'snapshot'); + return { success: revertSuccess }; + case 'apply_prefab': + const applyError = await Editor.Message.request('scene', 'execute-scene-script', { + name: package_json_1.default.name, + method: 'applyPrefabByNode', + args: [args.reference.id] + }); + if (applyError != null) { + throw new Error(`Failed to apply prefab: ${applyError}`); + } + await Editor.Message.request('scene', 'snapshot'); + return { success: true }; + case 'unwrap_prefab': + const unwrapError = await Editor.Message.request('scene', 'execute-scene-script', { + name: package_json_1.default.name, + method: 'unlinkPrefabByNode', + args: [args.reference.id, false] + }); + if (unwrapError != null) { + throw new Error(`Failed to unwrap prefab: ${unwrapError}`); + } + await Editor.Message.request('scene', 'snapshot'); + return { success: true }; + case 'unwrap_prefab_completely': + const unwrapAllError = await Editor.Message.request('scene', 'execute-scene-script', { + name: package_json_1.default.name, + method: 'unlinkPrefabByNode', + args: [args.reference.id, true] + }); + if (unwrapAllError != null) { + throw new Error(`Failed to unwrap prefab completely: ${unwrapAllError}`); + } + await Editor.Message.request('scene', 'snapshot'); + return { success: true }; + case 'open_prefab': + const nodeForPrefab = await Editor.Message.request('scene', 'query-node', args.reference.id); + if (!nodeForPrefab) { + throw new Error(`Node ${args.reference.id} not found`); + } + const pInfo = nodeForPrefab.__prefab__ || nodeForPrefab._prefab || (nodeForPrefab.value && (nodeForPrefab.value.__prefab__ || nodeForPrefab.value._prefab)); + const pValue = (pInfo === null || pInfo === void 0 ? void 0 : pInfo.value) || pInfo; + const targetUuid = (pValue === null || pValue === void 0 ? void 0 : pValue.assetUuid) || (pValue === null || pValue === void 0 ? void 0 : pValue.uuid); + if (!targetUuid) { + throw new Error(`Node ${args.reference.id} is not linked to a prefab`); + } + try { + await Editor.Message.request('asset-db', 'open-asset', targetUuid); + } + catch (error) { + throw new Error(`Failed to open prefab asset ${targetUuid}. Reason: ${(error === null || error === void 0 ? void 0 : error.message) || error}`); + } + return { success: true }; + default: + throw new Error(`Unknown scene node operation: ${args.operation}`); + } + } + // Helpers + async getParent(nodeUuid) { + var _a, _b, _c; + const node = await Editor.Message.request('scene', 'query-node', nodeUuid); + if ((_b = (_a = node === null || node === void 0 ? void 0 : node.parent) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.uuid) + return node.parent.value.uuid; + if ((_c = node === null || node === void 0 ? void 0 : node.parent) === null || _c === void 0 ? void 0 : _c.uuid) + return node.parent.uuid; + return await Editor.Message.request('scene', 'query-uuid'); + } + // Helper to set sibling index + async setSiblingIndex(uuid, index) { + // Get parent first + const parentUuid = await this.getParent(uuid); + if (!parentUuid) { + throw new Error(`Node ${uuid} has no parent`); + } + // Get children of parent + const parentNode = await Editor.Message.request('scene', 'query-node', parentUuid); + const childrenArray = parentNode.children; + if (!childrenArray || !Array.isArray(childrenArray)) { + throw new Error(`Parent node ${parentUuid} has no children`); + } + const currentIndex = childrenArray.findIndex((child) => child.value.uuid === uuid); + if (currentIndex === -1) { + throw new Error(`Node ${uuid} not found in parent children`); + } + if (currentIndex === index) + return true; + // Calculate offset + // We need to move the element at currentIndex to targetIndex. + // The API move-array-element works with offset from current position. + // Ensure index is within bounds [0, length-1] + const targetIndex = Math.max(0, Math.min(index, childrenArray.length - 1)); + const offset = targetIndex - currentIndex; + if (offset === 0) + return true; + return await Editor.Message.request('scene', 'move-array-element', { + uuid: parentUuid, + path: 'children', + target: currentIndex, + offset: offset, + }); + } + async getParentAndSiblingIndex(uuid) { + const parentUuid = await this.getParent(uuid); + if (!parentUuid) { + throw new Error(`Node ${uuid} has no parent`); + } + const parentNode = await Editor.Message.request('scene', 'query-node', parentUuid); + const childrenArray = parentNode.children; + if (!childrenArray || !Array.isArray(childrenArray)) { + throw new Error(`Parent node ${parentUuid} has no children`); + } + const index = childrenArray.findIndex((child) => child.value.uuid === uuid); + if (index === -1) { + throw new Error(`Node ${uuid} not found in parent children`); + } + return { parentUuid, siblingIndex: index }; + } + async getUpdatedUuid(parentUuid, siblingIndex) { + const parentNodeInfo = await Editor.Message.request('scene', 'query-node', parentUuid); + if (!parentNodeInfo || !parentNodeInfo.children || !Array.isArray(parentNodeInfo.children) || !parentNodeInfo.children[siblingIndex]) { + throw new Error(`Failed to retrieve updated node info after prefab creation.`); + } + return parentNodeInfo.children[siblingIndex].value.uuid; + } +} +exports.SceneTools = SceneTools; +__decorate([ + (0, decorators_1.utcpTool)('nodeGetTree', 'Get the hierarchy tree of specific node or scene root if no reference is provided. Children have recursive structure.', { + type: 'object', + properties: { + reference: schemas_1.InstanceReferenceSchema + } + }, schemas_1.SceneTreeItemSchema, "GET", ['scene', 'graph', 'node', 'hierarchy', 'tree']) +], SceneTools.prototype, "nodeGetTree", null); +__decorate([ + (0, decorators_1.utcpTool)('nodeGetAtPath', 'Get nodes at specific path in the scene hierarchy. Usually returns one node, but can return multiple nodes with the same name.', { + type: 'object', + properties: { + hierarchyPath: { type: 'string', description: 'Path to the node in the scene hierarchy"' }, + }, + required: ['hierarchyPath'] + }, { type: 'object', properties: { references: { type: 'array', items: schemas_1.InstanceReferenceSchema } } }, "GET", ['scene', 'node', 'get', 'path', 'find', 'look', 'instance', 'hierarchy']) +], SceneTools.prototype, "nodeGetAtPath", null); +__decorate([ + (0, decorators_1.utcpTool)('nodeCreatePrimitive', 'Create a new node with predefined primitive geometry MeshRenderer. If no parent is specified, root node is used. Returns reference to the new node.', { type: 'object', + properties: { + name: { type: 'string' }, + primitiveType: { type: 'string', enum: [ + 'Capsule', 'Cone', 'Cube', 'Cylinder', 'Plane', 'Quad', 'Sphere', 'Torus', + ] }, + parentReference: schemas_1.InstanceReferenceSchema + }, + required: ['name', 'primitiveType'] + }, { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, "POST", ['scene', 'node', 'create', 'add']) +], SceneTools.prototype, "sceneCreatePrimitiveNode", null); +__decorate([ + (0, decorators_1.utcpTool)('nodeCreate', 'Create a new node in the scene. If no parent is specified, root node is used. Returns reference to the new node.', { + type: 'object', + properties: { + name: { type: 'string' }, + parentReference: schemas_1.InstanceReferenceSchema, + assetReference: schemas_1.InstanceReferenceSchema, + unwrapPrefab: { type: 'boolean', default: false } + }, + required: ['name'] + }, { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, "POST", ['scene', 'node', 'create', 'add']) +], SceneTools.prototype, "sceneCreateNode", null); +__decorate([ + (0, decorators_1.utcpTool)('nodeOperate', 'Perform operation on referenced node, including prefab operations.', { + type: 'object', + properties: { + operation: { type: 'string', enum: ['move', 'copy', 'delete', 'create_prefab', 'revert_prefab', 'apply_prefab', 'unwrap_prefab', 'unwrap_prefab_completely', 'open_prefab'] }, + reference: schemas_1.InstanceReferenceSchema, + newParentReference: schemas_1.InstanceReferenceSchema, + newPrefabPath: { type: 'string', description: 'For create_prefab: target db:// path', nullable: true }, + siblingIndex: { type: 'integer', description: 'For move/copy: target index in parent children array', nullable: true } + }, + required: ['operation', 'reference'] + }, { type: 'object', + properties: { + success: { type: 'boolean' }, + createdPrefabAssetReference: schemas_1.InstanceReferenceSchema, + updatedNodeReference: schemas_1.InstanceReferenceSchema, + copiedNodeReference: schemas_1.InstanceReferenceSchema + } + }, "POST", ['scene', 'node', 'remove', 'move', 'copy', 'delete', 'prefab', 'apply', 'revert', 'unwrap', 'create']) +], SceneTools.prototype, "nodeOperate", null); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene-tools.js","sourceRoot":"","sources":["../../../source/utcp/tools/scene-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import packageJSON from '../../../package.json';\nimport { utcpTool } from '../decorators';\nimport { ISceneTreeItem, SceneTreeItemSchema, Base64ImageSchema, IBase64Image, InstanceReferenceSchema, IInstanceReference } from '../schemas';\n\nexport class SceneTools {\n\n    @utcpTool(\n        'nodeGetTree',\n        'Get the hierarchy tree of specific node or scene root if no reference is provided. Children have recursive structure.',\n        {\n            type: 'object',\n            properties: {\n                reference: InstanceReferenceSchema\n            }\n        },\n        SceneTreeItemSchema, \"GET\",  ['scene', 'graph', 'node', 'hierarchy', 'tree']\n    )\n    async nodeGetTree(args: { reference?: IInstanceReference }): Promise<ISceneTreeItem> {\n        let treeBase;\n        if (args.reference) {\n             treeBase = await Editor.Message.request('scene', 'query-node-tree', args.reference.id);\n        } else {\n             // Default queries the whole scene\n             treeBase = await Editor.Message.request('scene', 'query-node-tree');\n        }\n        \n        if (!treeBase) {\n            throw new Error(`Node tree not found for ${args.reference?.id || 'entire scene'}`);\n        }\n\n        const formatNode = (node: any): ISceneTreeItem => {\n\n           const comps = node.components ? node.components.map((c: any) => ({\n               reference: { id: c.value, type: c.type }\n           })) : [];\n\n           let children: ISceneTreeItem[] = [];\n            children = node.children ? node.children.map(formatNode).filter((c: any) => c !== null) : [];\n\n           return {\n                reference: { id: node.uuid, type: 'cc.Node' },\n                name: node.name,\n                active: node.active,\n                components: comps,\n                children: children\n           };\n        };\n        \n        const result: ISceneTreeItem = formatNode(treeBase);\n        result.path = (treeBase as any).path || undefined;\n        return result;\n    }\n\n    @utcpTool(\n        'nodeGetAtPath',\n        'Get nodes at specific path in the scene hierarchy. Usually returns one node, but can return multiple nodes with the same name.',\n        {\n            type: 'object',\n            properties: {\n                hierarchyPath: { type: 'string', description: 'Path to the node in the scene hierarchy\"' },\n            },\n            required: ['hierarchyPath']\n        }, { type: 'object', properties: { references: { type: 'array', items: InstanceReferenceSchema } } }, \"GET\",  ['scene', 'node', 'get', 'path', 'find', 'look', 'instance', 'hierarchy']\n    )\n    async nodeGetAtPath(args: { hierarchyPath: string }): Promise<{ references: IInstanceReference[] }> {\n        const nodeTree = await Editor.Message.request('scene', 'query-node-tree');\n        if (!nodeTree) {\n            throw new Error(`Scene is empty or could not retrieve scene tree.`);\n        }\n\n        const sceneRootName = (nodeTree.name as unknown as string);\n        if (args.hierarchyPath.startsWith('/')) {\n            args.hierarchyPath = args.hierarchyPath.slice(1);\n        }\n        if (args.hierarchyPath.startsWith(`${sceneRootName}`)) {\n            args.hierarchyPath = args.hierarchyPath.slice(sceneRootName.length);\n        }\n        if (args.hierarchyPath === '') {\n            return { references: [{ id: (nodeTree.uuid as unknown as string) }] };\n        }\n\n        const pathParts = args.hierarchyPath.split('/').filter(p => p.length > 0);\n        let currentNodes = [nodeTree];\n        for (const part of pathParts) {\n            const nextNodes: any[] = [];\n            for (const node of currentNodes) {\n                const matchingChildren = (node.children || []).filter((child: any) => child.name === part);\n                nextNodes.push(...matchingChildren);\n            }\n            currentNodes = nextNodes;\n            if (currentNodes.length === 0) {\n                break;\n            }\n        }\n\n        return { references: currentNodes.map((node: any) => ({ id: node.uuid, type: 'cc.Node' })) };\n    }\n\n    @utcpTool(\n        'nodeCreatePrimitive',\n        'Create a new node with predefined primitive geometry MeshRenderer. If no parent is specified, root node is used. Returns reference to the new node.',\n         {  type: 'object',\n            properties: {\n                name: { type: 'string' },\n                primitiveType: { type: 'string', enum: [\n                    'Capsule', 'Cone', 'Cube', 'Cylinder', 'Plane', 'Quad', 'Sphere', 'Torus',\n                ] },\n                parentReference: InstanceReferenceSchema\n            },\n            required: ['name', 'primitiveType']\n         }, \n         { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] }, \"POST\",  ['scene', 'node', 'create', 'add']\n    )\n    async sceneCreatePrimitiveNode(args: { name: string, primitiveType: string, parentReference?: IInstanceReference }): Promise<{ reference: IInstanceReference }> {\n        const primitiveMap: Record<string, string> = {\n            'Capsule': \"db://internal/default_prefab/3d/Capsule.prefab\",\n            'Cone': \"db://internal/default_prefab/3d/Cone.prefab\",\n            'Cube': \"db://internal/default_prefab/3d/Cube.prefab\",\n            'Cylinder': \"db://internal/default_prefab/3d/Cylinder.prefab\",\n            'Plane': \"db://internal/default_prefab/3d/Plane.prefab\",\n            'Quad': \"db://internal/default_prefab/3d/Quad.prefab\",\n            'Sphere': \"db://internal/default_prefab/3d/Sphere.prefab\",\n            'Torus': \"db://internal/default_prefab/3d/Torus.prefab\",\n        };\n\n        if (!primitiveMap[args.primitiveType]) {\n            throw new Error(`Unsupported primitive type: ${args.primitiveType}`);\n        }\n\n        const prefabUrl = primitiveMap[args.primitiveType];\n        const assetUuid = await Editor.Message.request('asset-db', 'query-uuid', prefabUrl);\n        if (!assetUuid) {\n            throw new Error(`Failed to find asset for primitive type ${args.primitiveType} at ${prefabUrl}`);\n        }\n        return await this.sceneCreateNode({\n            name: args.name,\n            parentReference: args.parentReference,\n            assetReference: { id: assetUuid, type: 'cc.Prefab' },\n            unwrapPrefab: true\n        });\n    }\n\n    @utcpTool(\n        'nodeCreate',\n        'Create a new node in the scene. If no parent is specified, root node is used. Returns reference to the new node.',\n        {\n            type: 'object',\n            properties: {\n                name: { type: 'string' },\n                parentReference: InstanceReferenceSchema,\n                assetReference: InstanceReferenceSchema,\n                unwrapPrefab: { type: 'boolean', default: false }\n            },\n            required: ['name']\n        },\n        { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] }, \"POST\",  ['scene', 'node', 'create', 'add']\n    )\n    async sceneCreateNode(args: { name: string, parentReference?: IInstanceReference, assetReference?: IInstanceReference, unwrapPrefab?: boolean }): Promise<{ reference: IInstanceReference }> {\n        const options: any = {\n            name: args.name\n        };\n        if (args.parentReference) {\n            options.parent = args.parentReference.id;\n        } else {\n            // Force root if no parent provided\n            options.parent = (await Editor.Message.request('scene', 'query-node-tree')).uuid;\n        }\n\n        let assetUuid: string | null = null;\n\n        // 1. Determine Asset UUID\n        if ((args.assetReference && 'id' in args.assetReference)) {\n            const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', args.assetReference.id);\n            if (!assetInfo) {\n                throw new Error(`Asset reference not found: ${args.assetReference.id}`);\n            }\n\n            let prefabFound = assetInfo.type === 'cc.Prefab';\n            // If not a prefab, check if it has a prefab sub-asset (like in case of FBX)\n            if (!prefabFound) {\n                for (let subAsset of Object.values(assetInfo.subAssets)) {\n                    if (subAsset.type === 'cc.Prefab') {\n                        assetUuid = subAsset.uuid;\n                        prefabFound = true;\n                        break;\n                    }\n                }\n            } else {\n                assetUuid = assetInfo.uuid;\n            }\n\n            if (!prefabFound) {\n                throw new Error(`Provided asset reference ${args.assetReference.id} is not a prefab and does not contain a prefab sub-asset.`);\n            } else {\n                if (!args.unwrapPrefab) {\n                    options.unlinkPrefab = false;\n                    options.type = 'cc.Prefab';\n                }\n            }\n        }\n\n        if (assetUuid) {\n            options.assetUuid = assetUuid;\n        }\n\n        // 2. Create Node\n        const result = await Editor.Message.request('scene', 'create-node', options);\n        const newNodeUuid = Array.isArray(result) ? result[0] : result;\n\n        if (!newNodeUuid) {\n            throw new Error(`Failed to create node ${args.name}${args.assetReference ? ` from asset ${args.assetReference.id}` : ''}.`);\n        }\n\n        await Editor.Message.request('scene', 'snapshot');\n\n        return { reference: { id: newNodeUuid, type: 'cc.Node' } };\n    }\n\n    @utcpTool(\n        'nodeOperate',\n        'Perform operation on referenced node, including prefab operations.',\n        {\n            type: 'object',\n            properties: {\n                operation: { type: 'string', enum: ['move', 'copy', 'delete', 'create_prefab', 'revert_prefab', 'apply_prefab', 'unwrap_prefab', 'unwrap_prefab_completely', 'open_prefab'] },\n                reference: InstanceReferenceSchema,\n                newParentReference: InstanceReferenceSchema,\n                newPrefabPath: { type: 'string', description: 'For create_prefab: target db:// path', nullable: true },\n                siblingIndex: { type: 'integer', description: 'For move/copy: target index in parent children array', nullable: true }\n            },\n            required: ['operation', 'reference']\n        },\n        { type: 'object', \n            properties: {\n                success: { type: 'boolean' },\n                createdPrefabAssetReference: InstanceReferenceSchema,\n                updatedNodeReference: InstanceReferenceSchema,\n                copiedNodeReference: InstanceReferenceSchema\n            }\n        }, \"POST\",  ['scene', 'node', 'remove', 'move', 'copy', 'delete', 'prefab', 'apply', 'revert', 'unwrap', 'create']\n    )\n    async nodeOperate(args: { operation: string, reference: IInstanceReference, newParentReference?: IInstanceReference, newPrefabPath?: string, siblingIndex?: number }): \n        Promise<{ success?: boolean, createdPrefabAssetReference?: IInstanceReference, updatedNodeReference?: IInstanceReference, copiedNodeReference?: IInstanceReference }> {\n        if (await Editor.Message.request('scene', 'query-node', args.reference.id) === null) {\n            throw new Error(`Target node ${args.reference.id} not found`);\n        }\n\n        switch (args.operation) {\n            case 'move':\n                if (!args.newParentReference) {\n                    throw new Error(\"newParentReference required for move\");\n                }\n\n                await Editor.Message.request('scene', 'set-parent', {\n                    parent: args.newParentReference.id,\n                    uuids: args.reference.id,\n                    keepWorldTransform: true\n                });\n\n                if (args.siblingIndex !== undefined) {\n                    await this.setSiblingIndex(args.reference.id, args.siblingIndex);\n                }\n\n                await Editor.Message.request('scene', 'snapshot');\n                \n                return { success: true };\n\n            case 'copy':\n                 const duplicateResult = await Editor.Message.request('scene', 'duplicate-node', [args.reference.id]);\n                 if (!duplicateResult || duplicateResult.length === 0) {\n                    throw new Error(`Node ${args.reference.id} duplication failed`);\n                 }\n                 \n                 const newNodes = duplicateResult as string[];\n                 const newNodeId = newNodes[0]; \n                 \n                 if (args.newParentReference) {\n                     await Editor.Message.request('scene', 'set-parent', {\n                        parent: args.newParentReference.id,\n                        uuids: newNodes,\n                        keepWorldTransform: true\n                     });\n                 }\n\n                 if (args.siblingIndex !== undefined) {\n                     await this.setSiblingIndex(newNodeId, args.siblingIndex);\n                 }\n\n                 await Editor.Message.request('scene', 'snapshot');\n                 \n                 return { success: true, copiedNodeReference: { id: newNodeId, type: 'cc.Node' } };\n\n            case 'delete':\n                await Editor.Message.request('scene', 'remove-node', {\n                    uuid: args.reference.id\n                });\n\n                const nodeCheck = await Editor.Message.request('scene', 'query-node', args.reference.id);\n                if (nodeCheck !== null && nodeCheck !== undefined) {\n                    throw new Error(`Node ${args.reference.id} still exists after removal`);\n                }\n\n                await Editor.Message.request('scene', 'snapshot');\n\n                return { success: true };\n\n            case 'create_prefab':\n                if (!args.newPrefabPath) {\n                    throw new Error(\"newPrefabPath required for create_prefab\");\n                }\n                const parentInfo = await this.getParentAndSiblingIndex(args.reference.id);\n\n                const createdPrefabUuid = await Editor.Message.request('scene', 'execute-scene-script', {\n                    name: packageJSON.name,\n                    method: 'createPrefabFromNode',\n                    args: [args.reference.id, args.newPrefabPath]\n                });\n                \n                if (!createdPrefabUuid) {\n                    throw new Error(\"Failed to create prefab asset.\");\n                }\n                const updatedNodeId = await this.getUpdatedUuid(parentInfo.parentUuid, parentInfo.siblingIndex);\n\n                await Editor.Message.request('scene', 'snapshot');\n\n                return { success: true, createdPrefabAssetReference: { id: createdPrefabUuid, type: 'cc.Prefab' }, updatedNodeReference: { id: updatedNodeId, type: 'cc.Node' } };\n                 \n            case 'revert_prefab':\n                const revertSuccess = await Editor.Message.request('scene', 'restore-prefab', { uuid: args.reference.id });\n\n                await Editor.Message.request('scene', 'snapshot');\n\n                return { success: revertSuccess };\n\n            case 'apply_prefab':\n                const applyError = await Editor.Message.request('scene', 'execute-scene-script', {\n                    name: packageJSON.name,\n                    method: 'applyPrefabByNode',\n                    args: [args.reference.id]\n                });\n\n                if (applyError != null) {\n                    throw new Error(`Failed to apply prefab: ${applyError}`);\n                }\n\n                await Editor.Message.request('scene', 'snapshot');\n\n                return { success: true };\n\n            case 'unwrap_prefab':\n                const unwrapError = await Editor.Message.request('scene', 'execute-scene-script', {\n                    name: packageJSON.name,\n                    method: 'unlinkPrefabByNode',\n                    args: [args.reference.id, false]\n                });\n                \n                if (unwrapError != null) {\n                    throw new Error(`Failed to unwrap prefab: ${unwrapError}`);\n                }\n\n                await Editor.Message.request('scene', 'snapshot');\n\n                return { success: true };\n\n            case 'unwrap_prefab_completely':\n                const unwrapAllError = await Editor.Message.request('scene', 'execute-scene-script', {\n                    name: packageJSON.name,\n                    method: 'unlinkPrefabByNode',\n                    args: [args.reference.id, true]\n                });\n                \n                if (unwrapAllError != null) {\n                    throw new Error(`Failed to unwrap prefab completely: ${unwrapAllError}`);\n                }\n\n                await Editor.Message.request('scene', 'snapshot');\n\n                return { success: true };\n\n            case 'open_prefab':\n                const nodeForPrefab: any = await Editor.Message.request('scene', 'query-node', args.reference.id);\n                if (!nodeForPrefab) {\n                    throw new Error(`Node ${args.reference.id} not found`);\n                }\n                 \n                const pInfo = nodeForPrefab.__prefab__ || nodeForPrefab._prefab || (nodeForPrefab.value && (nodeForPrefab.value.__prefab__ || nodeForPrefab.value._prefab));\n                const pValue = pInfo?.value || pInfo;\n                const targetUuid = pValue?.assetUuid || pValue?.uuid;\n\n                if (!targetUuid) {\n                    throw new Error(`Node ${args.reference.id} is not linked to a prefab`);\n                }\n\n                try { \n                    await Editor.Message.request('asset-db', 'open-asset', targetUuid);\n                } catch (error: any) {\n                    throw new Error(`Failed to open prefab asset ${targetUuid}. Reason: ${error?.message || error}`);\n                }\n\n                return { success: true };\n\n            default:\n                throw new Error(`Unknown scene node operation: ${args.operation}`);\n        }\n    }\n\n    // Helpers\n\n    private async getParent(nodeUuid: string): Promise<string> {\n        const node = await Editor.Message.request('scene', 'query-node', nodeUuid);\n        if (node?.parent?.value?.uuid) return node.parent.value.uuid;\n        if (node?.parent?.uuid) return node.parent.uuid;\n        return await Editor.Message.request('scene', 'query-uuid');\n    }\n\n    // Helper to set sibling index\n    private async setSiblingIndex(uuid: string, index: number) {\n        // Get parent first\n        const parentUuid = await this.getParent(uuid);\n        if (!parentUuid) {\n            throw new Error(`Node ${uuid} has no parent`);\n        }\n\n        // Get children of parent\n        const parentNode = await Editor.Message.request('scene', 'query-node', parentUuid);\n        const childrenArray = parentNode.children;\n        if (!childrenArray || !Array.isArray(childrenArray)) {\n            throw new Error(`Parent node ${parentUuid} has no children`);\n        }\n\n        const currentIndex = childrenArray.findIndex((child: any) => child.value.uuid === uuid);\n        if (currentIndex === -1) {\n            throw new Error(`Node ${uuid} not found in parent children`);\n        }\n\n        if (currentIndex === index) return true;\n\n        // Calculate offset\n        // We need to move the element at currentIndex to targetIndex.\n        // The API move-array-element works with offset from current position.\n        \n        // Ensure index is within bounds [0, length-1]\n        const targetIndex = Math.max(0, Math.min(index, childrenArray.length - 1));\n        const offset = targetIndex - currentIndex;\n        \n        if (offset === 0) return true;\n\n        return await Editor.Message.request('scene', 'move-array-element', {\n            uuid: parentUuid,\n            path: 'children',\n            target: currentIndex,\n            offset: offset,\n        });\n    }\n\n    private async getParentAndSiblingIndex(uuid: string): Promise<{ parentUuid: string, siblingIndex: number }> {\n        const parentUuid = await this.getParent(uuid);\n        if (!parentUuid) {\n            throw new Error(`Node ${uuid} has no parent`);\n        }\n\n        const parentNode = await Editor.Message.request('scene', 'query-node', parentUuid);\n        const childrenArray = parentNode.children;\n        if (!childrenArray || !Array.isArray(childrenArray)) {\n            throw new Error(`Parent node ${parentUuid} has no children`);\n        }\n        const index = childrenArray.findIndex((child: any) => child.value.uuid === uuid);\n        if (index === -1) {\n            throw new Error(`Node ${uuid} not found in parent children`);\n        }\n        return { parentUuid, siblingIndex: index };\n    }\n    \n    private async getUpdatedUuid(parentUuid: string, siblingIndex: number): Promise<string> {\n        const parentNodeInfo = await Editor.Message.request('scene', 'query-node', parentUuid);\n        if (!parentNodeInfo || !parentNodeInfo.children || !Array.isArray(parentNodeInfo.children) || !parentNodeInfo.children[siblingIndex]) {\n            throw new Error(`Failed to retrieve updated node info after prefab creation.`);\n        }\n        return parentNodeInfo.children[siblingIndex].value.uuid;\n    }\n}"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/tools/set-properties-tool.js b/extensions/cocos-code-mode/dist/utcp/tools/set-properties-tool.js new file mode 100644 index 0000000..92169a8 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/tools/set-properties-tool.js @@ -0,0 +1,272 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SetPropertyTool = void 0; +const decorators_1 = require("../decorators"); +const tools_utils_1 = require("../utils/tools-utils"); +const asset_importers_1 = require("../utils/asset-importers"); +const schemas_1 = require("../schemas"); +class SetPropertyTool { + async setCurrentSceneProperties(params) { + return await this.setInstanceProperties({ + reference: { id: params.settingsType }, propertyPaths: params.propertyPaths, values: params.values + }); + } + async setInstanceProperties(params) { + let { reference: { id: uuid }, propertyPaths, values } = params; + if (!propertyPaths || !values) { + throw new Error(`Property paths and values are required.`); + } + if (propertyPaths.length !== values.length) { + throw new Error(`Property paths count (${propertyPaths.length}) does not match values count (${values.length}).`); + } + let info = await tools_utils_1.ToolsUtils.inspectInstance(uuid, false); + if (!info) { + throw new Error(`Target ${uuid} not found or not supported.`); + } + uuid = info.uuid; + const { type, props, assetInfo } = info; + if (!props) { + throw new Error(`Could not retrieve properties for ${type} of instance ${uuid}.`); + } + for (let i = 0; i < propertyPaths.length; i++) { + await this.setProperty(info, propertyPaths[i], values[i]); + } + return { success: true }; + } + async setProperty({ uuid, type, props, assetInfo }, propertyPath, value) { + var _a; + // Find property definition in the dump + let targetProp = null; + try { + targetProp = this.findPropertyInDump(props, propertyPath); + } + catch (e) { + throw new Error(`Property '${propertyPath}' resolution failed: ${e.message}. Please recheck TypescriptDefinition of ${uuid}. Arrays are reached by indexes.`); + } + if (!targetProp) { + throw new Error(`Property '${propertyPath}' not found on ${type} of instance ${uuid}.`); + } + // Normalize value based on property definition + value = this.normalizeValue(value, targetProp); + if (assetInfo) { + try { + const success = await ((_a = asset_importers_1.ImporterManager.getInstance().getImporter(assetInfo.importer)) === null || _a === void 0 ? void 0 : _a.setProperty(assetInfo, propertyPath, value)); + if (!success) { + throw new Error(`Importer failed to set property.`); + } + } + catch (e) { + throw new Error(`Failed to set property on Asset ${uuid}: ${e}`); + } + return; + } + if (type === 'cc.SceneGlobals') { + // Scene Globals are part of the scene node but under _globals + propertyPath = `_globals.${propertyPath}`; + // uuid is already set to the Scene UUID from inspectInstance + } + else if (type !== 'cc.Node') { + const nodeUuid = props.node.value.uuid; + const nodeInfo = await Editor.Message.request('scene', 'query-node', nodeUuid); + if (!nodeInfo) { + throw new Error(`Parent Node ${nodeUuid} for Component ${uuid} not found.`); + } + const componentIndex = nodeInfo.__comps__.findIndex((comp) => comp.value.uuid.value === uuid); + propertyPath = `__comps__.${componentIndex}.${propertyPath}`; + uuid = nodeUuid; + } + await this.applyValue(uuid, propertyPath, targetProp, value); + } + normalizeValue(value, prop) { + // Try to parse string values into proper types + if (typeof value === 'string') { + const isStringProp = prop.type === 'String'; + if (!isStringProp) { + const t = value.trim(); + if (t === 'true') + return true; + if (t === 'false') + return false; + if (!isNaN(Number(t)) && t !== '') { + return Number(t); + } + if ((t.startsWith('{') || t.startsWith('[')) && (t.endsWith('}') || t.endsWith(']'))) { + try { + return JSON.parse(t); + } + catch (e) { } + } + } + } + return value; + } + findPropertyInDump(root, path) { + if (!path) + return null; + if (!root) + return null; + const parts = path.split('.'); + let current = { value: root }; // Wrap to unify traversal + // Helper to check if object looks like a property definition + const isProperty = (obj) => obj && typeof obj === 'object' && ('type' in obj || 'extends' in obj); + for (let i = 0; i < parts.length; i++) { + const part = parts[i]; + // Current is expected to be an IProperty or object containing IProperty data + let val = current.value; + // If current is just the dictionary (root), use it directly + if (current === root || (typeof current === 'object' && !('value' in current))) { + val = current; + } + if (val === undefined || val === null) + return null; + // 1. Array Index + if (Array.isArray(val)) { + const idx = parseInt(part); + if (!isNaN(idx)) { + // Existing index + if (val[idx] !== undefined) { + const elem = val[idx]; + if (isProperty(elem)) { + current = elem; + } + else if (current.elementTypeData) { + // Hydrate from schema + current = Object.assign(Object.assign({}, current.elementTypeData), { value: elem }); + } + else { + // Fallback for primitive arrays without schema + current = { value: elem, type: 'Unknown' }; + } + continue; + } + // Extending array support: Allow index == length if schema exists. + // Don't allow gaps (idx > length). + if (idx === val.length) { + if (current.elementTypeData) { + current = current.elementTypeData; + continue; + } + else { + throw new Error(`Array extension at '${part}' failed: No elementTypeData.`); + } + } + throw new Error(`Array index '${idx}' out of bounds (length: ${val.length}) at '${part}'.`); + } + throw new Error(`Invalid array index '${part}' at '${path}'.`); + } + // 2. Object Key + if (typeof val === 'object') { + if (part in val) { + const propCandidate = val[part]; + if (isProperty(propCandidate)) { + current = propCandidate; + } + else { + // Not a property, probably a raw value in a struct (like position.x = 0) + // Try to find schema in default value if available + let schema = null; + if (current.default && current.default.value && typeof current.default.value === 'object' && part in current.default.value) { + schema = current.default.value[part]; + } + if (schema) { + current = Object.assign(Object.assign({}, schema), { value: propCandidate }); + } + else { + // No schema found, treat as untyped value + current = { value: propCandidate, type: 'Unknown' }; + } + } + continue; + } + throw new Error(`Key '${part}' not found ${i == 0 ? '' : 'in ' + parts.slice(0, i).join('.')}.`); + } + throw new Error(`Path segment '${part}' '${i == 0 ? '' : 'at ' + parts.slice(0, i).join('.')}' failed resolution.`); + } + return current; + } + async applyValue(uuid, path, prop, value) { + var _a, _b, _c; + // Handle direct references + if ((_a = prop.extends) === null || _a === void 0 ? void 0 : _a.includes('cc.Object')) { + value = await this.convertObjectReferenceToCocos(value, prop); + } + // Handle array of references + if (Array.isArray(value) && ((_c = (_b = prop.elementTypeData) === null || _b === void 0 ? void 0 : _b.extends) === null || _c === void 0 ? void 0 : _c.includes('cc.Object'))) { + const convertedArray = []; + value.forEach(async (item, index) => { + convertedArray[index] = await this.convertObjectReferenceToCocos(item, prop.elementTypeData); + }); + value = convertedArray; + } + const dump = { value, type: prop.type }; + await Editor.Message.request('scene', 'set-property', { + uuid, + path, + dump + }); + await Editor.Message.request('scene', 'snapshot'); + } + async convertObjectReferenceToCocos(value, prop) { + const extendsInfo = prop.extends || []; + // Accept plain UUID string or { uuid: string } structure + if (typeof value === 'string') { + value = { uuid: value }; + } + // Reference object with id is sent + if (typeof value === 'object' && value !== null && 'id' in value) { + value = { uuid: value.id }; + } + // Special case for asset subtype check + if (extendsInfo.includes('cc.Asset')) { + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', value.uuid); + if (!assetInfo) { + throw new Error(`Asset with id ${value.uuid} not found.`); + } + let foundSubAsset = false; + if (assetInfo.type !== prop.type) { + Object.values(assetInfo.subAssets || {}).forEach(subAsset => { + if (subAsset.type === prop.type) { + value = { uuid: subAsset.uuid }; + foundSubAsset = true; + } + }); + } + else { + foundSubAsset = true; + } + if (!foundSubAsset && assetInfo.type !== prop.type) { + throw new Error(`Reference type mismatch: expected ${prop.type}, got ${assetInfo.type}.`); + } + } + return value; + } +} +exports.SetPropertyTool = SetPropertyTool; +__decorate([ + (0, decorators_1.utcpTool)("inspectorSetSettingsProperties", "Sets a property on the specific settings. If a property path or type is not confirmed via inspectorGet* tools, you MUST NOT call any setter.", { type: 'object', + properties: { + settingsType: { type: 'string', enum: ['CurrentSceneGlobals', 'ProjectSettings'] }, + propertyPath: { type: 'string', description: "Plain path to the property (e.g., 'ambient.skyLightingColor.r'). Don't support code execution." }, + value: { type: ['array', 'object', 'string', 'number', 'boolean', 'null'], additionalProperties: true } + }, + required: ['settingsType', 'propertyPath', 'value'] + }, schemas_1.SuccessIndicatorSchema, "POST", ['property', 'set', 'scene', 'settings', 'project', 'modify', 'config']) +], SetPropertyTool.prototype, "setCurrentSceneProperties", null); +__decorate([ + (0, decorators_1.utcpTool)("inspectorSetInstanceProperties", "Sets a property on instance of Node, Component or Asset. If a property path or type is not confirmed via inspectorGet* tools, you MUST NOT call any setter.", { + type: 'object', + properties: { + reference: schemas_1.InstanceReferenceSchema, + propertyPaths: { type: 'array', items: { type: 'string' }, description: "Plain paths to the properties (e.g., ['position.x', 'rotation.y']). Don't support code execution. Arrays are reached by indexes. (e.g. 'sharedMaterials.0')" }, + values: { type: 'array', items: { type: ['array', 'object', 'string', 'number', 'boolean', 'null'], additionalProperties: true } } + }, + required: ['reference', 'propertyPaths', 'values'] + }, schemas_1.SuccessIndicatorSchema, "POST", ['property', 'set', 'instance', 'node', 'component', 'asset', 'modify', 'meta']) +], SetPropertyTool.prototype, "setInstanceProperties", null); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"set-properties-tool.js","sourceRoot":"","sources":["../../../source/utcp/tools/set-properties-tool.ts"],"names":[],"mappings":"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","sourcesContent":["import { utcpTool } from '../decorators';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\nimport { ToolsUtils } from '../utils/tools-utils';\nimport { ImporterManager } from '../utils/asset-importers';\nimport { AssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IInstanceReference, InstanceReferenceSchema, ISuccessIndicator, SuccessIndicatorSchema } from '../schemas';\n\ndeclare const Editor: any;\n\nexport class SetPropertyTool {\n    @utcpTool(\n        \"inspectorSetSettingsProperties\",\n        \"Sets a property on the specific settings. If a property path or type is not confirmed via inspectorGet* tools, you MUST NOT call any setter.\",\n        { type: 'object',\n            properties: {\n                settingsType: { type: 'string', enum: ['CurrentSceneGlobals', 'ProjectSettings'] },\n                propertyPath: { type: 'string', description: \"Plain path to the property (e.g., 'ambient.skyLightingColor.r'). Don't support code execution.\" },\n                value: { type: ['array', 'object', 'string', 'number', 'boolean', 'null'], additionalProperties: true }\n            },\n            required: ['settingsType', 'propertyPath', 'value']\n        },\n        SuccessIndicatorSchema, \"POST\", ['property', 'set', 'scene', 'settings', 'project', 'modify', 'config']\n    )\n    async setCurrentSceneProperties(params: { settingsType: string, propertyPaths: string[], values: any[] }): Promise<ISuccessIndicator> {\n        return await this.setInstanceProperties({\n            reference: { id: params.settingsType }, propertyPaths: params.propertyPaths, values: params.values\n        });\n    }\n\n\n    @utcpTool(\n        \"inspectorSetInstanceProperties\",\n        \"Sets a property on instance of Node, Component or Asset. If a property path or type is not confirmed via inspectorGet* tools, you MUST NOT call any setter.\",\n        {\n            type: 'object',\n            properties: {\n                reference: InstanceReferenceSchema,\n                propertyPaths: { type: 'array', items: { type: 'string' }, description: \"Plain paths to the properties (e.g., ['position.x', 'rotation.y']). Don't support code execution. Arrays are reached by indexes. (e.g. 'sharedMaterials.0')\" },\n                values: { type: 'array', items: { type: ['array', 'object', 'string', 'number', 'boolean', 'null'], additionalProperties: true } }\n            },\n            required: ['reference', 'propertyPaths', 'values']\n        },\n        SuccessIndicatorSchema, \"POST\", ['property', 'set', 'instance', 'node', 'component', 'asset', 'modify', 'meta']\n    )\n    async setInstanceProperties(params: { reference: IInstanceReference, propertyPaths: string[], values: any[] }): Promise<ISuccessIndicator> {\n        let { reference: { id: uuid }, propertyPaths, values } = params;\n\n        if (!propertyPaths || !values) {\n            throw new Error(`Property paths and values are required.`);\n        }\n\n        if (propertyPaths.length !== values.length) {\n            throw new Error(`Property paths count (${propertyPaths.length}) does not match values count (${values.length}).`);\n        }\n\n        let info = await ToolsUtils.inspectInstance(uuid, false);\n        if (!info) {\n            throw new Error(`Target ${uuid} not found or not supported.`);\n        }\n\n        uuid = info.uuid;\n\n        const { type, props, assetInfo } = info;\n\n        if (!props) {\n            throw new Error(`Could not retrieve properties for ${type} of instance ${uuid}.`);\n        }\n\n        for (let i = 0; i < propertyPaths.length; i++) {\n            await this.setProperty(info, propertyPaths[i], values[i]);\n        }\n\n        return { success: true };\n    }\n\n    private async setProperty({ uuid, type, props, assetInfo }: { uuid: string, type: string, props: { [key: string]: IPropertyValueType } | null, assetInfo: AssetInfo | null }, propertyPath: string, value: any): Promise<void> {\n        // Find property definition in the dump\n        let targetProp: IProperty | null = null;\n        try {\n            targetProp = this.findPropertyInDump(props, propertyPath);\n        } catch (e: any) {\n            throw new Error(`Property '${propertyPath}' resolution failed: ${e.message}. Please recheck TypescriptDefinition of ${uuid}. Arrays are reached by indexes.`);\n        }\n\n        if (!targetProp) {\n            throw new Error(`Property '${propertyPath}' not found on ${type} of instance ${uuid}.`);\n        }\n\n        // Normalize value based on property definition\n        value = this.normalizeValue(value, targetProp);\n\n        if (assetInfo) {\n            try {\n                const success: boolean | undefined = await ImporterManager.getInstance().getImporter(assetInfo.importer)?.setProperty(assetInfo, propertyPath, value);\n                if (!success) {\n                    throw new Error(`Importer failed to set property.`);\n                }\n            } catch (e) {\n                throw new Error(`Failed to set property on Asset ${uuid}: ${e}`);\n            }\n            return;\n        }\n\n        if (type === 'cc.SceneGlobals') {\n            // Scene Globals are part of the scene node but under _globals\n            propertyPath = `_globals.${propertyPath}`;\n            // uuid is already set to the Scene UUID from inspectInstance\n        } else if (type !== 'cc.Node') {\n            const nodeUuid = (props as any).node.value.uuid;\n            const nodeInfo = await Editor.Message.request('scene', 'query-node', nodeUuid);\n            if (!nodeInfo) {\n                throw new Error(`Parent Node ${nodeUuid} for Component ${uuid} not found.`);\n            }\n            const componentIndex = nodeInfo.__comps__.findIndex((comp: any) => comp.value.uuid.value === uuid);\n            propertyPath = `__comps__.${componentIndex}.${propertyPath}`;\n            uuid = nodeUuid;\n        }\n\n        await this.applyValue(uuid, propertyPath, targetProp, value);\n    }\n\n    private normalizeValue(value: any, prop: IProperty): any {\n        // Try to parse string values into proper types\n        if (typeof value === 'string') {\n            const isStringProp = prop.type === 'String';\n            if (!isStringProp) {\n                const t = value.trim();\n                if (t === 'true') return true;\n                if (t === 'false') return false;\n\n                if (!isNaN(Number(t)) && t !== '') {\n                    return Number(t);\n                }\n\n                if ((t.startsWith('{') || t.startsWith('[')) && (t.endsWith('}') || t.endsWith(']'))) {\n                    try { return JSON.parse(t); } catch (e) { }\n                }\n            }\n        }\n        return value;\n    }\n\n    private findPropertyInDump(root: { [key: string]: IPropertyValueType } | AssetInfo | null, path: string): IProperty | null {\n        if (!path) return null;\n        if (!root) return null;\n\n        const parts = path.split('.');\n\n        let current: any = { value: root }; // Wrap to unify traversal\n\n        // Helper to check if object looks like a property definition\n        const isProperty = (obj: any) => obj && typeof obj === 'object' && ('type' in obj || 'extends' in obj);\n\n        for (let i = 0; i < parts.length; i++) {\n            const part = parts[i];\n\n            // Current is expected to be an IProperty or object containing IProperty data\n            let val = current.value;\n            // If current is just the dictionary (root), use it directly\n            if (current === root || (typeof current === 'object' && !('value' in current))) {\n                val = current;\n            }\n\n            if (val === undefined || val === null) return null;\n\n            // 1. Array Index\n            if (Array.isArray(val)) {\n                const idx = parseInt(part);\n                if (!isNaN(idx)) {\n                    // Existing index\n                    if (val[idx] !== undefined) {\n                        const elem = val[idx];\n                        if (isProperty(elem)) {\n                            current = elem;\n                        } else if (current.elementTypeData) {\n                            // Hydrate from schema\n                            current = { ...current.elementTypeData, value: elem };\n                        } else {\n                            // Fallback for primitive arrays without schema\n                            current = { value: elem, type: 'Unknown' };\n                        }\n                        continue;\n                    }\n                    // Extending array support: Allow index == length if schema exists.\n                    // Don't allow gaps (idx > length).\n                    if (idx === val.length) {\n                        if (current.elementTypeData) {\n                            current = current.elementTypeData;\n                            continue;\n                        } else {\n                            throw new Error(`Array extension at '${part}' failed: No elementTypeData.`);\n                        }\n                    }\n                    throw new Error(`Array index '${idx}' out of bounds (length: ${val.length}) at '${part}'.`);\n                }\n                throw new Error(`Invalid array index '${part}' at '${path}'.`);\n            }\n\n            // 2. Object Key\n            if (typeof val === 'object') {\n                if (part in val) {\n                    const propCandidate = val[part as keyof typeof val];\n                    if (isProperty(propCandidate)) {\n                        current = propCandidate;\n                    } else {\n                        // Not a property, probably a raw value in a struct (like position.x = 0)\n                        // Try to find schema in default value if available\n                        let schema = null;\n                        if (current.default && current.default.value && typeof current.default.value === 'object' && part in current.default.value) {\n                            schema = current.default.value[part];\n                        }\n\n                        if (schema) {\n                            current = { ...schema, value: propCandidate };\n                        } else {\n                            // No schema found, treat as untyped value\n                            current = { value: propCandidate, type: 'Unknown' };\n                        }\n                    }\n                    continue;\n                }\n                throw new Error(`Key '${part}' not found ${i == 0 ? '' : 'in ' + parts.slice(0, i).join('.')}.`);\n            }\n\n            throw new Error(`Path segment '${part}' '${i == 0 ? '' : 'at ' + parts.slice(0, i).join('.')}' failed resolution.`);\n        }\n\n        return current as IProperty;\n    }\n\n    private async applyValue(uuid: string, path: string, prop: IProperty, value: any) {\n        // Handle direct references\n        if (prop.extends?.includes('cc.Object')) {\n            value = await this.convertObjectReferenceToCocos(value, prop);\n        }\n\n        // Handle array of references\n        if (Array.isArray(value) && prop.elementTypeData?.extends?.includes('cc.Object')) {\n            const convertedArray: any[] = [];\n            value.forEach(async (item, index) => {\n                convertedArray[index] = await this.convertObjectReferenceToCocos(item, prop.elementTypeData!);\n            });\n            value = convertedArray;\n        }\n\n        const dump = { value, type: prop.type };\n\n        await Editor.Message.request('scene', 'set-property', {\n            uuid,\n            path,\n            dump\n        });\n\n        await Editor.Message.request('scene', 'snapshot');\n    }\n\n    private async convertObjectReferenceToCocos(value: any, prop: IProperty): Promise<{ uuid: string }> {\n        const extendsInfo = prop.extends || [];\n\n        // Accept plain UUID string or { uuid: string } structure\n        if (typeof value === 'string') {\n            value = { uuid: value };\n        }\n        \n        // Reference object with id is sent\n        if (typeof value === 'object' && value !== null && 'id' in value) {\n            value = { uuid: value.id };\n        }\n\n        // Special case for asset subtype check\n        if (extendsInfo.includes('cc.Asset')) {\n            const assetInfo: AssetInfo | null = await Editor.Message.request('asset-db', 'query-asset-info', value.uuid);\n            if (!assetInfo) {\n                throw new Error(`Asset with id ${value.uuid} not found.`);\n            }\n            let foundSubAsset = false;\n            if (assetInfo.type !== prop.type) {\n                Object.values(assetInfo.subAssets || {}).forEach(subAsset => {\n                    if (subAsset.type === prop.type) {\n                        value = { uuid: subAsset.uuid };\n                        foundSubAsset = true;\n                    }\n                });\n            } else {\n                foundSubAsset = true;\n            }\n\n            if (!foundSubAsset && assetInfo.type !== prop.type) {\n                throw new Error(`Reference type mismatch: expected ${prop.type}, got ${assetInfo.type}.`);\n            }\n        }\n        return value;\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/tools/set-property-tool.js b/extensions/cocos-code-mode/dist/utcp/tools/set-property-tool.js new file mode 100644 index 0000000..f88ee8e --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/tools/set-property-tool.js @@ -0,0 +1,266 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SetPropertyTool = void 0; +const decorators_1 = require("../decorators"); +const tools_utils_1 = require("../utils/tools-utils"); +const asset_importers_1 = require("../utils/asset-importers"); +const schemas_1 = require("../schemas"); +class SetPropertyTool { + async setCurrentSceneProperties(params) { + return await this.setInstanceProperties({ + reference: { id: params.settingsType }, propertyPaths: params.propertyPaths, values: params.values + }); + } + async setInstanceProperties(params) { + let { reference: { id: uuid }, propertyPaths, values } = params; + let info = await tools_utils_1.ToolsUtils.inspectInstance(uuid, false); + if (!info) { + throw new Error(`Target ${uuid} not found or not supported.`); + } + uuid = info.uuid; + const { type, props, assetInfo } = info; + if (!props) { + throw new Error(`Could not retrieve properties for ${type} of instance ${uuid}.`); + } + for (let i = 0; i < propertyPaths.length; i++) { + await this.setProperty(info, propertyPaths[i], values[i]); + } + return { success: true }; + } + async setProperty({ uuid, type, props, assetInfo }, propertyPath, value) { + var _a; + // Find property definition in the dump + let targetProp = null; + try { + targetProp = this.findPropertyInDump(props, propertyPath); + } + catch (e) { + throw new Error(`Property '${propertyPath}' resolution failed: ${e.message}. Please recheck TypescriptDefinition of ${uuid}. Arrays are reached by indexes.`); + } + if (!targetProp) { + throw new Error(`Property '${propertyPath}' not found on ${type} of instance ${uuid}.`); + } + // Normalize value based on property definition + value = this.normalizeValue(value, targetProp); + if (assetInfo) { + try { + const success = await ((_a = asset_importers_1.ImporterManager.getInstance().getImporter(assetInfo.importer)) === null || _a === void 0 ? void 0 : _a.setProperty(assetInfo, propertyPath, value)); + if (!success) { + throw new Error(`Importer failed to set property.`); + } + } + catch (e) { + throw new Error(`Failed to set property on Asset ${uuid}: ${e}`); + } + return; + } + if (type === 'cc.SceneGlobals') { + // Scene Globals are part of the scene node but under _globals + propertyPath = `_globals.${propertyPath}`; + // uuid is already set to the Scene UUID from inspectInstance + } + else if (type !== 'cc.Node') { + const nodeUuid = props.node.value.uuid; + const nodeInfo = await Editor.Message.request('scene', 'query-node', nodeUuid); + if (!nodeInfo) { + throw new Error(`Parent Node ${nodeUuid} for Component ${uuid} not found.`); + } + const componentIndex = nodeInfo.__comps__.findIndex((comp) => comp.value.uuid.value === uuid); + propertyPath = `__comps__.${componentIndex}.${propertyPath}`; + uuid = nodeUuid; + } + await this.applyValue(uuid, propertyPath, targetProp, value); + } + normalizeValue(value, prop) { + // Try to parse string values into proper types + if (typeof value === 'string') { + const isStringProp = prop.type === 'String'; + if (!isStringProp) { + const t = value.trim(); + if (t === 'true') + return true; + if (t === 'false') + return false; + if (!isNaN(Number(t)) && t !== '') { + return Number(t); + } + if ((t.startsWith('{') || t.startsWith('[')) && (t.endsWith('}') || t.endsWith(']'))) { + try { + return JSON.parse(t); + } + catch (e) { } + } + } + } + return value; + } + findPropertyInDump(root, path) { + if (!path) + return null; + if (!root) + return null; + const parts = path.split('.'); + let current = { value: root }; // Wrap to unify traversal + // Helper to check if object looks like a property definition + const isProperty = (obj) => obj && typeof obj === 'object' && ('type' in obj || 'extends' in obj); + for (let i = 0; i < parts.length; i++) { + const part = parts[i]; + // Current is expected to be an IProperty or object containing IProperty data + let val = current.value; + // If current is just the dictionary (root), use it directly + if (current === root || (typeof current === 'object' && !('value' in current))) { + val = current; + } + if (val === undefined || val === null) + return null; + // 1. Array Index + if (Array.isArray(val)) { + const idx = parseInt(part); + if (!isNaN(idx)) { + // Existing index + if (val[idx] !== undefined) { + const elem = val[idx]; + if (isProperty(elem)) { + current = elem; + } + else if (current.elementTypeData) { + // Hydrate from schema + current = Object.assign(Object.assign({}, current.elementTypeData), { value: elem }); + } + else { + // Fallback for primitive arrays without schema + current = { value: elem, type: 'Unknown' }; + } + continue; + } + // Extending array support: Allow index == length if schema exists. + // Don't allow gaps (idx > length). + if (idx === val.length) { + if (current.elementTypeData) { + current = current.elementTypeData; + continue; + } + else { + throw new Error(`Array extension at '${part}' failed: No elementTypeData.`); + } + } + throw new Error(`Array index '${idx}' out of bounds (length: ${val.length}) at '${part}'.`); + } + throw new Error(`Invalid array index '${part}' at '${path}'.`); + } + // 2. Object Key + if (typeof val === 'object') { + if (part in val) { + const propCandidate = val[part]; + if (isProperty(propCandidate)) { + current = propCandidate; + } + else { + // Not a property, probably a raw value in a struct (like position.x = 0) + // Try to find schema in default value if available + let schema = null; + if (current.default && current.default.value && typeof current.default.value === 'object' && part in current.default.value) { + schema = current.default.value[part]; + } + if (schema) { + current = Object.assign(Object.assign({}, schema), { value: propCandidate }); + } + else { + // No schema found, treat as untyped value + current = { value: propCandidate, type: 'Unknown' }; + } + } + continue; + } + throw new Error(`Key '${part}' not found ${i == 0 ? '' : 'in ' + parts.slice(0, i).join('.')}.`); + } + throw new Error(`Path segment '${part}' '${i == 0 ? '' : 'at ' + parts.slice(0, i).join('.')}' failed resolution.`); + } + return current; + } + async applyValue(uuid, path, prop, value) { + var _a, _b, _c; + // Handle direct references + if ((_a = prop.extends) === null || _a === void 0 ? void 0 : _a.includes('cc.Object')) { + value = await this.convertObjectReferenceToCocos(value, prop); + } + // Handle array of references + if (Array.isArray(value) && ((_c = (_b = prop.elementTypeData) === null || _b === void 0 ? void 0 : _b.extends) === null || _c === void 0 ? void 0 : _c.includes('cc.Object'))) { + const convertedArray = []; + value.forEach(async (item, index) => { + convertedArray[index] = await this.convertObjectReferenceToCocos(item, prop.elementTypeData); + }); + value = convertedArray; + } + const dump = { value, type: prop.type }; + await Editor.Message.request('scene', 'set-property', { + uuid, + path, + dump + }); + await Editor.Message.request('scene', 'snapshot'); + } + async convertObjectReferenceToCocos(value, prop) { + const extendsInfo = prop.extends || []; + // Accept plain UUID string or { uuid: string } structure + if (typeof value === 'string') { + value = { uuid: value }; + } + // Reference object with id is sent + if (typeof value === 'object' && value !== null && 'id' in value) { + value = { uuid: value.id }; + } + // Special case for asset subtype check + if (extendsInfo.includes('cc.Asset')) { + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', value.uuid); + if (!assetInfo) { + throw new Error(`Asset with id ${value.uuid} not found.`); + } + let foundSubAsset = false; + if (assetInfo.type !== prop.type) { + Object.values(assetInfo.subAssets || {}).forEach(subAsset => { + if (subAsset.type === prop.type) { + value = { uuid: subAsset.uuid }; + foundSubAsset = true; + } + }); + } + else { + foundSubAsset = true; + } + if (!foundSubAsset && assetInfo.type !== prop.type) { + throw new Error(`Reference type mismatch: expected ${prop.type}, got ${assetInfo.type}.`); + } + } + return value; + } +} +exports.SetPropertyTool = SetPropertyTool; +__decorate([ + (0, decorators_1.utcpTool)("inspectorSetSettingsProperties", "Sets a property on the specific settings. If a property path or type is not confirmed via inspectorGet* tools, you MUST NOT call any setter.", { type: 'object', + properties: { + settingsType: { type: 'string', enum: ['CurrentSceneGlobals', 'ProjectSettings'] }, + propertyPath: { type: 'string', description: "Plain path to the property (e.g., 'ambient.skyLightingColor.r'). Don't support code execution." }, + value: { type: ['array', 'object', 'string', 'number', 'boolean', 'null'], additionalProperties: true } + }, + required: ['settingsType', 'propertyPath', 'value'] + }, schemas_1.SuccessIndicatorSchema, "POST", ['property', 'set', 'scene', 'settings', 'project', 'modify', 'config']) +], SetPropertyTool.prototype, "setCurrentSceneProperties", null); +__decorate([ + (0, decorators_1.utcpTool)("inspectorSetInstanceProperties", "Sets a property on instance of Node, Component or Asset. If a property path or type is not confirmed via inspectorGet* tools, you MUST NOT call any setter.", { + type: 'object', + properties: { + reference: schemas_1.InstanceReferenceSchema, + propertyPaths: { type: 'array', items: { type: 'string' }, description: "Plain paths to the properties (e.g., ['position.x', 'rotation.y']). Don't support code execution. Arrays are reached by indexes. (e.g. 'sharedMaterials.0')" }, + values: { type: 'array', items: { type: ['array', 'object', 'string', 'number', 'boolean', 'null'], additionalProperties: true } } + }, + required: ['reference', 'propertyPaths', 'values'] + }, schemas_1.SuccessIndicatorSchema, "POST", ['property', 'set', 'instance', 'node', 'component', 'asset', 'modify', 'meta']) +], SetPropertyTool.prototype, "setInstanceProperties", null); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"set-property-tool.js","sourceRoot":"","sources":["../../../source/utcp/tools/set-property-tool.ts"],"names":[],"mappings":"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","sourcesContent":["import { utcpTool } from '../decorators';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\nimport { ToolsUtils } from '../utils/tools-utils';\nimport { ImporterManager } from '../utils/asset-importers';\nimport { AssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IInstanceReference, InstanceReferenceSchema, ISuccessIndicator, SuccessIndicatorSchema } from '../schemas';\n\ndeclare const Editor: any;\n\nexport class SetPropertyTool {\n    @utcpTool(\n        \"inspectorSetSettingsProperties\",\n        \"Sets a property on the specific settings. If a property path or type is not confirmed via inspectorGet* tools, you MUST NOT call any setter.\",\n        { type: 'object',\n            properties: {\n                settingsType: { type: 'string', enum: ['CurrentSceneGlobals', 'ProjectSettings'] },\n                propertyPath: { type: 'string', description: \"Plain path to the property (e.g., 'ambient.skyLightingColor.r'). Don't support code execution.\" },\n                value: { type: ['array', 'object', 'string', 'number', 'boolean', 'null'], additionalProperties: true }\n            },\n            required: ['settingsType', 'propertyPath', 'value']\n        },\n        SuccessIndicatorSchema, \"POST\", ['property', 'set', 'scene', 'settings', 'project', 'modify', 'config']\n    )\n    async setCurrentSceneProperties(params: { settingsType: string, propertyPaths: string[], values: any[] }): Promise<ISuccessIndicator> {\n        return await this.setInstanceProperties({\n            reference: { id: params.settingsType }, propertyPaths: params.propertyPaths, values: params.values\n        });\n    }\n\n\n    @utcpTool(\n        \"inspectorSetInstanceProperties\",\n        \"Sets a property on instance of Node, Component or Asset. If a property path or type is not confirmed via inspectorGet* tools, you MUST NOT call any setter.\",\n        {\n            type: 'object',\n            properties: {\n                reference: InstanceReferenceSchema,\n                propertyPaths: { type: 'array', items: { type: 'string' }, description: \"Plain paths to the properties (e.g., ['position.x', 'rotation.y']). Don't support code execution. Arrays are reached by indexes. (e.g. 'sharedMaterials.0')\" },\n                values: { type: 'array', items: { type: ['array', 'object', 'string', 'number', 'boolean', 'null'], additionalProperties: true } }\n            },\n            required: ['reference', 'propertyPaths', 'values']\n        },\n        SuccessIndicatorSchema, \"POST\", ['property', 'set', 'instance', 'node', 'component', 'asset', 'modify', 'meta']\n    )\n    async setInstanceProperties(params: { reference: IInstanceReference, propertyPaths: string[], values: any[] }): Promise<ISuccessIndicator> {\n        let { reference: { id: uuid }, propertyPaths, values } = params;\n\n        let info = await ToolsUtils.inspectInstance(uuid, false);\n        if (!info) {\n            throw new Error(`Target ${uuid} not found or not supported.`);\n        }\n\n        uuid = info.uuid;\n\n        const { type, props, assetInfo } = info;\n\n        if (!props) {\n            throw new Error(`Could not retrieve properties for ${type} of instance ${uuid}.`);\n        }\n\n        for (let i = 0; i < propertyPaths.length; i++) {\n            await this.setProperty(info, propertyPaths[i], values[i]);\n        }\n\n        return { success: true };\n    }\n\n    private async setProperty({ uuid, type, props, assetInfo }: { uuid: string, type: string, props: { [key: string]: IPropertyValueType } | null, assetInfo: AssetInfo | null }, propertyPath: string, value: any): Promise<void> {\n        // Find property definition in the dump\n        let targetProp: IProperty | null = null;\n        try {\n            targetProp = this.findPropertyInDump(props, propertyPath);\n        } catch (e: any) {\n            throw new Error(`Property '${propertyPath}' resolution failed: ${e.message}. Please recheck TypescriptDefinition of ${uuid}. Arrays are reached by indexes.`);\n        }\n\n        if (!targetProp) {\n            throw new Error(`Property '${propertyPath}' not found on ${type} of instance ${uuid}.`);\n        }\n\n        // Normalize value based on property definition\n        value = this.normalizeValue(value, targetProp);\n\n        if (assetInfo) {\n            try {\n                const success: boolean | undefined = await ImporterManager.getInstance().getImporter(assetInfo.importer)?.setProperty(assetInfo, propertyPath, value);\n                if (!success) {\n                    throw new Error(`Importer failed to set property.`);\n                }\n            } catch (e) {\n                throw new Error(`Failed to set property on Asset ${uuid}: ${e}`);\n            }\n            return;\n        }\n\n        if (type === 'cc.SceneGlobals') {\n            // Scene Globals are part of the scene node but under _globals\n            propertyPath = `_globals.${propertyPath}`;\n            // uuid is already set to the Scene UUID from inspectInstance\n        } else if (type !== 'cc.Node') {\n            const nodeUuid = (props as any).node.value.uuid;\n            const nodeInfo = await Editor.Message.request('scene', 'query-node', nodeUuid);\n            if (!nodeInfo) {\n                throw new Error(`Parent Node ${nodeUuid} for Component ${uuid} not found.`);\n            }\n            const componentIndex = nodeInfo.__comps__.findIndex((comp: any) => comp.value.uuid.value === uuid);\n            propertyPath = `__comps__.${componentIndex}.${propertyPath}`;\n            uuid = nodeUuid;\n        }\n\n        await this.applyValue(uuid, propertyPath, targetProp, value);\n    }\n\n    private normalizeValue(value: any, prop: IProperty): any {\n        // Try to parse string values into proper types\n        if (typeof value === 'string') {\n            const isStringProp = prop.type === 'String';\n            if (!isStringProp) {\n                const t = value.trim();\n                if (t === 'true') return true;\n                if (t === 'false') return false;\n\n                if (!isNaN(Number(t)) && t !== '') {\n                    return Number(t);\n                }\n\n                if ((t.startsWith('{') || t.startsWith('[')) && (t.endsWith('}') || t.endsWith(']'))) {\n                    try { return JSON.parse(t); } catch (e) { }\n                }\n            }\n        }\n        return value;\n    }\n\n    private findPropertyInDump(root: { [key: string]: IPropertyValueType } | AssetInfo | null, path: string): IProperty | null {\n        if (!path) return null;\n        if (!root) return null;\n\n        const parts = path.split('.');\n\n        let current: any = { value: root }; // Wrap to unify traversal\n\n        // Helper to check if object looks like a property definition\n        const isProperty = (obj: any) => obj && typeof obj === 'object' && ('type' in obj || 'extends' in obj);\n\n        for (let i = 0; i < parts.length; i++) {\n            const part = parts[i];\n\n            // Current is expected to be an IProperty or object containing IProperty data\n            let val = current.value;\n            // If current is just the dictionary (root), use it directly\n            if (current === root || (typeof current === 'object' && !('value' in current))) {\n                val = current;\n            }\n\n            if (val === undefined || val === null) return null;\n\n            // 1. Array Index\n            if (Array.isArray(val)) {\n                const idx = parseInt(part);\n                if (!isNaN(idx)) {\n                    // Existing index\n                    if (val[idx] !== undefined) {\n                        const elem = val[idx];\n                        if (isProperty(elem)) {\n                            current = elem;\n                        } else if (current.elementTypeData) {\n                            // Hydrate from schema\n                            current = { ...current.elementTypeData, value: elem };\n                        } else {\n                            // Fallback for primitive arrays without schema\n                            current = { value: elem, type: 'Unknown' };\n                        }\n                        continue;\n                    }\n                    // Extending array support: Allow index == length if schema exists.\n                    // Don't allow gaps (idx > length).\n                    if (idx === val.length) {\n                        if (current.elementTypeData) {\n                            current = current.elementTypeData;\n                            continue;\n                        } else {\n                            throw new Error(`Array extension at '${part}' failed: No elementTypeData.`);\n                        }\n                    }\n                    throw new Error(`Array index '${idx}' out of bounds (length: ${val.length}) at '${part}'.`);\n                }\n                throw new Error(`Invalid array index '${part}' at '${path}'.`);\n            }\n\n            // 2. Object Key\n            if (typeof val === 'object') {\n                if (part in val) {\n                    const propCandidate = val[part as keyof typeof val];\n                    if (isProperty(propCandidate)) {\n                        current = propCandidate;\n                    } else {\n                        // Not a property, probably a raw value in a struct (like position.x = 0)\n                        // Try to find schema in default value if available\n                        let schema = null;\n                        if (current.default && current.default.value && typeof current.default.value === 'object' && part in current.default.value) {\n                            schema = current.default.value[part];\n                        }\n\n                        if (schema) {\n                            current = { ...schema, value: propCandidate };\n                        } else {\n                            // No schema found, treat as untyped value\n                            current = { value: propCandidate, type: 'Unknown' };\n                        }\n                    }\n                    continue;\n                }\n                throw new Error(`Key '${part}' not found ${i == 0 ? '' : 'in ' + parts.slice(0, i).join('.')}.`);\n            }\n\n            throw new Error(`Path segment '${part}' '${i == 0 ? '' : 'at ' + parts.slice(0, i).join('.')}' failed resolution.`);\n        }\n\n        return current as IProperty;\n    }\n\n    private async applyValue(uuid: string, path: string, prop: IProperty, value: any) {\n        // Handle direct references\n        if (prop.extends?.includes('cc.Object')) {\n            value = await this.convertObjectReferenceToCocos(value, prop);\n        }\n\n        // Handle array of references\n        if (Array.isArray(value) && prop.elementTypeData?.extends?.includes('cc.Object')) {\n            const convertedArray: any[] = [];\n            value.forEach(async (item, index) => {\n                convertedArray[index] = await this.convertObjectReferenceToCocos(item, prop.elementTypeData!);\n            });\n            value = convertedArray;\n        }\n\n        const dump = { value, type: prop.type };\n\n        await Editor.Message.request('scene', 'set-property', {\n            uuid,\n            path,\n            dump\n        });\n\n        await Editor.Message.request('scene', 'snapshot');\n    }\n\n    private async convertObjectReferenceToCocos(value: any, prop: IProperty): Promise<{ uuid: string }> {\n        const extendsInfo = prop.extends || [];\n\n        // Accept plain UUID string or { uuid: string } structure\n        if (typeof value === 'string') {\n            value = { uuid: value };\n        }\n        \n        // Reference object with id is sent\n        if (typeof value === 'object' && value !== null && 'id' in value) {\n            value = { uuid: value.id };\n        }\n\n        // Special case for asset subtype check\n        if (extendsInfo.includes('cc.Asset')) {\n            const assetInfo: AssetInfo | null = await Editor.Message.request('asset-db', 'query-asset-info', value.uuid);\n            if (!assetInfo) {\n                throw new Error(`Asset with id ${value.uuid} not found.`);\n            }\n            let foundSubAsset = false;\n            if (assetInfo.type !== prop.type) {\n                Object.values(assetInfo.subAssets || {}).forEach(subAsset => {\n                    if (subAsset.type === prop.type) {\n                        value = { uuid: subAsset.uuid };\n                        foundSubAsset = true;\n                    }\n                });\n            } else {\n                foundSubAsset = true;\n            }\n\n            if (!foundSubAsset && assetInfo.type !== prop.type) {\n                throw new Error(`Reference type mismatch: expected ${prop.type}, got ${assetInfo.type}.`);\n            }\n        }\n        return value;\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/tools/typescript-defenition.js b/extensions/cocos-code-mode/dist/utcp/tools/typescript-defenition.js new file mode 100644 index 0000000..1b215f5 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/tools/typescript-defenition.js @@ -0,0 +1,308 @@ +"use strict"; +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GetClassInfoTool = void 0; +const decorators_1 = require("../decorators"); +const tools_utils_1 = require("../utils/tools-utils"); +const schemas_1 = require("../schemas"); +class GetClassInfoTool { + constructor() { + this._definitions = []; + this._definedNames = new Set(); + this._commonTypesDefinition = 'interface IExposedAttributes { type?: string, visible?: boolean, multiline?: boolean, min?: number, max?: number, step?: number, unit?: string, radian?: boolean }\n' + + 'function property(options: IExposedAttributes) {}\n' + + 'type InstanceReference = { id: string; type: string };\n' + + 'class Vec2 { x: number; y: number; }\n' + + 'class Vec3 { x: number; y: number; z: number; }\n' + + 'class Vec4 { x: number; y: number; z: number; w: number; }\n' + + 'class Color { r: number; g: number; b: number; a: number; }\n' + + 'class Rect { x: number; y: number; width: number; height: number; }\n' + + 'class Size { width: number; height: number; }\n' + + 'class Quat { x: number; y: number; z: number; w: number; }\n' + + 'class Mat3 { m00: number; m01: number; m02: number;\n' + + '\tm03: number; m04: number; m05: number;\n' + + '\tm06: number; m07: number; m08: number; }\n' + + 'class Mat4 { m00: number; m01: number; m02: number; m03: number;\n' + + '\tm04: number; m05: number; m06: number; m07: number;\n' + + '\tm08: number; m09: number; m10: number; m11: number;\n' + + '\tm12: number; m13: number; m14: number; m15: number; }\n' + + 'class Gradient { alphaKeys: Array<{ alpha: number, time: number }>, colorKeys: Array<{ /* always 3 elements: r, g and b values */color: Array, time: number }>, mode: number }'; + } + async inspectorGetSettingsDefinition(params) { + switch (params.settingsType) { + case 'CommonTypes': + return { definition: this._commonTypesDefinition }; + case 'CurrentSceneGlobals': + return this.inspectorGetInstanceDefinition({ reference: { id: 'CurrentSceneGlobals' } }); + case 'ProjectSettings': + return this.inspectorGetInstanceDefinition({ reference: { id: 'ProjectSettings' } }); + default: + throw new Error(`Unknown settings type: '${params.settingsType}'.`); + } + } + async inspectorGetInstanceDefinition(params) { + this._definitions = []; + this._definedNames.clear(); + let props = undefined; + let className = params.reference.id; + const instanceInfo = await tools_utils_1.ToolsUtils.inspectInstance(params.reference.id); + if (instanceInfo) { + className = instanceInfo.type; + if (instanceInfo.assetInfo) { + className += 'Importer'; + } + if (instanceInfo.props) { + props = instanceInfo.props; + } + this.processClass(className, props); + } + else { + throw new Error(`Class, Instance or special keyword not found: '${params.reference.id}'.`); + } + return { definition: this._definitions.join('\n') }; + } + processClass(className, providedProps, extendsClass) { + if (this._definedNames.has(className)) { + return; + } + this._definedNames.add(className); + if (!providedProps) + return; + // Don't let AI mess out with UUID + if ('uuid' in providedProps && this.isProperty(providedProps.uuid)) { + providedProps.uuid.readonly = true; + } + // Collect fields first to potentially hoist nested definitions + const fields = []; + for (const propName of Object.keys(providedProps)) { + const prop = providedProps[propName]; + // Filter out primitive properties which can't be inspected or invisible ones + if (prop === undefined || prop === null || + (this.isProperty(prop) && 'visible' in prop && !prop.visible)) + continue; + // IProperty Handling (Complex types, Metadata) + if (this.isProperty(prop)) { + const p = prop; + const decoratorParts = []; + const isArray = !!p.isArray; + // Determine item definition for Arrays + let itemDef = p; + if (isArray) { + if (p.elementTypeData) { + itemDef = p.elementTypeData; + } + else if (Array.isArray(p.value) && p.value.length > 0) { + // Try to infer from first element + itemDef = p.value[0]; + } + else { + // Cannot infer structure for empty array without schema + // Fallback to basic type handling + itemDef = null; + } + } + // Analyze Identity (based on itemDef if array, or p if single) + const defToAnalyze = itemDef || p; + const itemExtends = defToAnalyze.extends || []; + const rawType = defToAnalyze.type || 'any'; + const isValueType = itemExtends.includes('cc.ValueType'); + const isReference = itemExtends.includes('cc.Object') || + (!isValueType && (rawType === 'Node' || rawType === 'Component' || rawType === 'cc.Node' || rawType === 'cc.Component')); + let tsType = this.resolveTsType(rawType).replace(/^cc\./, ''); + // Process Enum/BitMask + const targetList = defToAnalyze.enumList || defToAnalyze.bitmaskList; + if ((rawType === 'Enum' || rawType === 'BitMask') && targetList) { + const cleanClassName = className.replace(/^cc\./, '').replace(/[^a-zA-Z0-9_]/g, '_'); + if (p.displayName && typeof p.displayName === 'string') { + if (p.displayName.startsWith('i18n:')) { + p.displayName = Editor.I18n.t(p.displayName.slice(5)); // Remove 'i18n:' prefix + } + if (p.displayName.trim().length === 0) { + p.displayName = propName; + } + } + else { + p.displayName = propName.charAt(0).toUpperCase() + propName.slice(1); + } + let enumName = `${cleanClassName}${p.displayName.replace(/[^a-zA-Z0-9_]/g, '')}${rawType}`; + if (defToAnalyze.userData && typeof defToAnalyze.userData === 'object' && 'enumName' in defToAnalyze.userData) { + enumName = defToAnalyze.userData['enumName']; + } + this.generateEnumDefinition(enumName, targetList); + tsType = enumName; + } + // Process Struct or Standard Type + else { + // Recursion: Only recurse if we have a valid item definition (itemDef) + // If isArray is true but itemDef is undefined, we skip recursion (treat as Array or Array) + if (itemDef && !isReference && !isValueType && !this.isPrimitiveType(rawType) && itemDef.value && typeof itemDef.value === 'object') { + let nestedName = tsType; + if (!nestedName || nestedName === 'Object' || nestedName === 'any') { + const suffix = isArray ? 'Item' : 'Type'; + nestedName = `${className}${propName.charAt(0).toUpperCase() + propName.slice(1)}${suffix}`; + } + const extendsForNested = itemDef.extends && itemDef.extends.length > 0 ? itemDef.extends[0].replace(/^cc\./, '') : undefined; + this.processClass(nestedName, itemDef.value, extendsForNested !== nestedName ? extendsForNested : undefined); + tsType = nestedName; + } + } + // Wrap reference type + if (isReference) { + if (tsType === 'any') + tsType = 'Object'; + tsType = `InstanceReference<${tsType}>`; + } + // Wrap array type + if (isArray) { + tsType = `Array<${tsType}>`; + } + // Decorators & Attributes + let decoratorType = null; + // Valuable types for decorators is only CCInteger and CCFloat + if (p.type === 'Integer') + decoratorType = 'CCInteger'; + else if (p.type === 'Float' || p.type === 'Number') + decoratorType = 'CCFloat'; + if (decoratorType) { + decoratorParts.push(isArray ? `type: [${decoratorType}]` : `type: ${decoratorType}`); + } + // Attributes that can help AI get more context + const attrs = ['min', 'max', 'step', 'unit', 'radian', 'multiline']; + attrs.forEach(attr => { + const val = p[attr]; + if (val !== undefined && val !== null) + decoratorParts.push(`${attr}: ${val}`); + }); + if (p.tooltip) { + let tooltip = p.tooltip; + if (tooltip.startsWith('i18n:')) { + tooltip = Editor.I18n.t(tooltip.slice(5)); // Remove 'i18n:' prefix + } + if (tooltip.trim().length > 0) { + if (tooltip.match(//i) || tooltip.includes('\n')) { + const lines = tooltip.split(/|\n/i).map(l => l.trim()).filter(l => l.length > 0); + if (lines.length > 0) { + fields.push(`\t/**`); + lines.forEach(line => fields.push(`\t * ${line}`)); + fields.push(`\t */`); + } + } + else { + fields.push(`\t/** ${tooltip} */`); + } + } + } + if (decoratorParts.length > 0) { + fields.push(`\t@property({ ${decoratorParts.join(', ')} })`); + } + const prefix = !!p.readonly ? 'readonly ' : ''; + fields.push(`\t${prefix}${propName}: ${tsType};`); + continue; + } + // Raw Value Handling (Primitives and simple objects) + if (this.isPrimitive(prop)) { + fields.push(`\t${propName}: ${typeof prop};`); + continue; + } + // Array Handling + if (Array.isArray(prop)) { + if (prop.length === 0) { + fields.push(`\t${propName}: Array;`); + } + else { + const firstItem = prop[0]; + if (this.isPrimitive(firstItem)) { + fields.push(`\t${propName}: Array<${typeof firstItem}>;`); + } + else if (typeof firstItem === 'object') { + // Raw object in array -> Recursion + const nestedClassName = `${className}${propName.charAt(0).toUpperCase() + propName.slice(1)}Item`; + this.processClass(nestedClassName, firstItem); + fields.push(`\t${propName}: Array<${nestedClassName}>;`); + } + else { + fields.push(`\t${propName}: Array;`); + } + } + continue; + } + // Fallback for raw object (struct) + if (typeof prop === 'object') { + const cleanClassName = className.replace(/^cc\./, '').replace(/[^a-zA-Z0-9_]/g, '_'); + const nestedClassName = `${cleanClassName}${propName.charAt(0).toUpperCase() + propName.slice(1)}Type`; + this.processClass(nestedClassName, prop); + fields.push(`\t${propName}: ${nestedClassName};`); + } + } + const shortName = className.includes('.') ? className.split('.').pop() : className; + const classDef = [ + `export class ${shortName} ${extendsClass ? `extends ${extendsClass}` : ''} {`, + ...fields, + `}` + ].join('\n'); + this._definitions.push(classDef); + } + // Type Guard for IProperty + isProperty(val) { + return val && typeof val === 'object' && 'value' in val; + } + // Based on info from CCClass + isPrimitiveType(type) { + return ['Integer', 'Float', 'Number', 'String', 'Boolean'].includes(type); + } + // Check if value is primitive + isPrimitive(value) { + return value === null || (typeof value !== "object" && typeof value !== "function"); + } + // Helper for Enum or BitMask generation + generateEnumDefinition(name, items) { + if (this._definedNames.has(name)) + return; + this._definedNames.add(name); + const lines = []; + lines.push(`export enum ${name} {`); + items.forEach((item) => { + let cleanName = item.name.replace(/[^a-zA-Z0-9_]/g, '_'); + if (/^[0-9]/.test(cleanName)) { + cleanName = `_${cleanName}`; + } + if (typeof item.value === 'string') { + lines.push(`\t${cleanName} = '${item.value}',`); + } + else { + lines.push(`\t${cleanName} = ${item.value},`); + } + }); + lines.push(`}`); + this._definitions.unshift(lines.join('\n')); + } + resolveTsType(type) { + switch (type) { + case 'Integer': + case 'Float': + case 'Number': + case 'Enum': // Enums handled specifically, but fallback for safety + case 'BitMask': + return 'number'; + case 'String': + return 'string'; + case 'Boolean': + return 'boolean'; + default: + return type; // e.g. Vec3, Color, Node + } + } +} +exports.GetClassInfoTool = GetClassInfoTool; +__decorate([ + (0, decorators_1.utcpTool)("inspectorGetSettingsDefinition", "Generates TypeScript definition for specific settings.", { type: 'object', properties: { settingsType: { type: 'string', enum: ['CommonTypes', 'CurrentSceneGlobals', 'ProjectSettings'] } }, required: ['settingsType'] }, { type: 'object', properties: { definition: { type: 'string' } }, required: ['definition'] }, "GET", ['code', 'typescript', 'inspection', 'definition', 'common', 'types', 'settings', 'scene', 'globals', 'project']) +], GetClassInfoTool.prototype, "inspectorGetSettingsDefinition", null); +__decorate([ + (0, decorators_1.utcpTool)("inspectorGetInstanceDefinition", "Generates TypeScript definition based on properties and descriptions of instance (Node, Component, Asset).", { type: 'object', properties: { reference: schemas_1.InstanceReferenceSchema }, required: ['reference'] }, { type: 'object', properties: { definition: { type: 'string' } }, required: ['definition'] }, "GET", ['code', 'typescript', 'inspection', 'definition', 'class', 'info', 'meta', 'instance', 'node', 'component', 'asset', 'data']) +], GetClassInfoTool.prototype, "inspectorGetInstanceDefinition", null); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript-defenition.js","sourceRoot":"","sources":["../../../source/utcp/tools/typescript-defenition.ts"],"names":[],"mappings":"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","sourcesContent":["import { utcpTool } from '../decorators';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\nimport { ToolsUtils } from '../utils/tools-utils';\nimport { IInstanceReference, InstanceReferenceSchema } from '../schemas';\n\nexport class GetClassInfoTool {\n\n    private _definitions: string[] = [];\n    private _definedNames: Set<string> = new Set();\n    private _commonTypesDefinition: string = \n        'interface IExposedAttributes { type?: string, visible?: boolean, multiline?: boolean, min?: number, max?: number, step?: number, unit?: string, radian?: boolean }\\n' +\n        'function property(options: IExposedAttributes) {}\\n' +\n        'type InstanceReference<T> = { id: string; type: string };\\n' +\n        'class Vec2 { x: number; y: number; }\\n' +\n        'class Vec3 { x: number; y: number; z: number; }\\n' +\n        'class Vec4 { x: number; y: number; z: number; w: number; }\\n' +\n        'class Color { r: number; g: number; b: number; a: number; }\\n' +\n        'class Rect { x: number; y: number; width: number; height: number; }\\n' +\n        'class Size { width: number; height: number; }\\n' +\n        'class Quat { x: number; y: number; z: number; w: number; }\\n' +\n        'class Mat3 { m00: number; m01: number; m02: number;\\n' +\n        '\\tm03: number; m04: number; m05: number;\\n' +\n        '\\tm06: number; m07: number; m08: number; }\\n' +\n        'class Mat4 { m00: number; m01: number; m02: number; m03: number;\\n' +\n        '\\tm04: number; m05: number; m06: number; m07: number;\\n' +\n        '\\tm08: number; m09: number; m10: number; m11: number;\\n' +\n        '\\tm12: number; m13: number; m14: number; m15: number; }\\n' +\n        'class Gradient { alphaKeys: Array<{ alpha: number, time: number }>, colorKeys: Array<{ /* always 3 elements: r, g and b values */color: Array<number>, time: number }>, mode: number }';\n\n    @utcpTool(\n        \"inspectorGetSettingsDefinition\",\n        \"Generates TypeScript definition for specific settings.\",\n        { type: 'object' , properties: { settingsType: { type: 'string', enum: ['CommonTypes', 'CurrentSceneGlobals', 'ProjectSettings'] } }, required: ['settingsType'] },\n        { type: 'object', properties: { definition: { type: 'string' } }, required: ['definition'] }, \n        \"GET\",  ['code', 'typescript', 'inspection', 'definition', 'common', 'types', 'settings', 'scene', 'globals', 'project']\n    )\n    async inspectorGetSettingsDefinition(params: { settingsType: string }): Promise<{ definition: string }> {\n        switch (params.settingsType) {\n            case 'CommonTypes':\n                return { definition: this._commonTypesDefinition };\n            case 'CurrentSceneGlobals':\n                return this.inspectorGetInstanceDefinition({ reference: { id: 'CurrentSceneGlobals' } });\n            case 'ProjectSettings':\n                return this.inspectorGetInstanceDefinition({ reference: { id: 'ProjectSettings' } });\n            default:\n                throw new Error(`Unknown settings type: '${params.settingsType}'.`);\n        }\n    }\n    \n    @utcpTool(\n        \"inspectorGetInstanceDefinition\",\n        \"Generates TypeScript definition based on properties and descriptions of instance (Node, Component, Asset).\",\n        { type: 'object', properties: { reference: InstanceReferenceSchema }, required: ['reference'] },\n        { type: 'object', properties: { definition: { type: 'string' } }, required: ['definition'] }, \n        \"GET\",  ['code', 'typescript', 'inspection', 'definition', 'class', 'info', 'meta', 'instance', 'node', 'component', 'asset', 'data']\n    )\n    async inspectorGetInstanceDefinition(params: { reference: IInstanceReference }): Promise<{ definition: string }> {\n        this._definitions = [];\n        this._definedNames.clear();\n\n        let props: { [key: string]: IPropertyValueType } | undefined = undefined;\n        let className = params.reference.id;\n        const instanceInfo = await ToolsUtils.inspectInstance(params.reference.id);\n        if (instanceInfo) {\n            className = instanceInfo.type;\n            if (instanceInfo.assetInfo) {\n                className += 'Importer';\n            }\n            if (instanceInfo.props) {\n                props = instanceInfo.props;\n            }\n            this.processClass(className, props);\n        } else {\n            throw new Error(`Class, Instance or special keyword not found: '${params.reference.id}'.`);\n        }\n\n        return { definition: this._definitions.join('\\n') };\n    }\n\n    private processClass(className: string, providedProps?: { [key: string]: IPropertyValueType }, extendsClass?: string) {\n        if (this._definedNames.has(className)) {\n            return;\n        }\n\n        this._definedNames.add(className);\n\n        if (!providedProps) return;\n\n        // Don't let AI mess out with UUID\n        if ('uuid' in providedProps && this.isProperty(providedProps.uuid)) {\n            providedProps.uuid.readonly = true;\n        }\n\n        // Collect fields first to potentially hoist nested definitions\n        const fields: string[] = [];\n\n        for (const propName of Object.keys(providedProps)) {\n            const prop = providedProps[propName];\n            \n            // Filter out primitive properties which can't be inspected or invisible ones\n            if (prop === undefined || prop === null || \n                (this.isProperty(prop) && 'visible' in prop && !prop.visible)) continue;\n\n            // IProperty Handling (Complex types, Metadata)\n            if (this.isProperty(prop)) {\n                const p = prop as IProperty;\n                const decoratorParts: string[] = [];\n                const isArray = !!p.isArray;\n                \n                // Determine item definition for Arrays\n                let itemDef: any = p;\n                if (isArray) {\n                    if (p.elementTypeData) {\n                        itemDef = p.elementTypeData;\n                    } else if (Array.isArray(p.value) && p.value.length > 0) {\n                         // Try to infer from first element\n                         itemDef = p.value[0];\n                    } else {\n                        // Cannot infer structure for empty array without schema\n                        // Fallback to basic type handling\n                        itemDef = null; \n                    }\n                }\n                \n                // Analyze Identity (based on itemDef if array, or p if single)\n                const defToAnalyze = itemDef || p;\n                const itemExtends = defToAnalyze.extends || [];\n                const rawType = defToAnalyze.type || 'any';\n                \n                const isValueType = itemExtends.includes('cc.ValueType');\n                const isReference = itemExtends.includes('cc.Object') || \n                                    (!isValueType && (rawType === 'Node' || rawType === 'Component' || rawType === 'cc.Node' || rawType === 'cc.Component'));\n                \n                let tsType = this.resolveTsType(rawType).replace(/^cc\\./, '');\n\n                // Process Enum/BitMask\n                const targetList = defToAnalyze.enumList || defToAnalyze.bitmaskList;\n                if ((rawType === 'Enum' || rawType === 'BitMask') && targetList) {\n                     const cleanClassName = className.replace(/^cc\\./, '').replace(/[^a-zA-Z0-9_]/g, '_');\n\n                     if (p.displayName && typeof p.displayName === 'string') {\n                        if (p.displayName.startsWith('i18n:')) {\n                             p.displayName = Editor.I18n.t(p.displayName.slice(5)); // Remove 'i18n:' prefix\n                        }\n                        if (p.displayName.trim().length === 0) {\n                            p.displayName = propName;\n                        }\n                     } else {\n                        p.displayName = propName.charAt(0).toUpperCase() + propName.slice(1);\n                     }\n                     \n                     let enumName = `${cleanClassName}${p.displayName.replace(/[^a-zA-Z0-9_]/g, '')}${rawType}`;\n\n                     if (defToAnalyze.userData && typeof defToAnalyze.userData === 'object' && 'enumName' in defToAnalyze.userData) {\n                         enumName = defToAnalyze.userData['enumName'];\n                     }\n                     \n                     this.generateEnumDefinition(enumName, targetList);\n                     tsType = enumName;\n                } \n                // Process Struct or Standard Type\n                else {\n                    // Recursion: Only recurse if we have a valid item definition (itemDef)\n                    // If isArray is true but itemDef is undefined, we skip recursion (treat as Array<any> or Array<p.type>)\n                    if (itemDef && !isReference && !isValueType && !this.isPrimitiveType(rawType) && itemDef.value && typeof itemDef.value === 'object') {\n                         let nestedName = tsType;\n                         if (!nestedName || nestedName === 'Object' || nestedName === 'any') {\n                             const suffix = isArray ? 'Item' : 'Type';\n                             nestedName = `${className}${propName.charAt(0).toUpperCase() + propName.slice(1)}${suffix}`;\n                         }\n                         \n                         const extendsForNested = itemDef.extends && itemDef.extends.length > 0 ? itemDef.extends[0].replace(/^cc\\./, '') : undefined;\n                         this.processClass(nestedName, itemDef.value as any, extendsForNested !== nestedName ? extendsForNested : undefined);\n                         tsType = nestedName;\n                    }\n                }\n                \n                // Wrap reference type\n                if (isReference) {\n                    if (tsType === 'any') tsType = 'Object';\n                    tsType = `InstanceReference<${tsType}>`;\n                }\n                \n                // Wrap array type\n                if (isArray) {\n                     tsType = `Array<${tsType}>`;\n                }\n\n                // Decorators & Attributes\n                let decoratorType = null;\n\n                // Valuable types for decorators is only CCInteger and CCFloat\n                if (p.type === 'Integer') decoratorType = 'CCInteger';\n                else if (p.type === 'Float' || p.type === 'Number') decoratorType = 'CCFloat';\n                \n                if (decoratorType) {\n                     decoratorParts.push(isArray ? `type: [${decoratorType}]` : `type: ${decoratorType}`);\n                }\n\n                // Attributes that can help AI get more context\n                const attrs = ['min', 'max', 'step', 'unit', 'radian', 'multiline'];\n                attrs.forEach(attr => { \n                    const val = (p as any)[attr];\n                    if (val !== undefined && val !== null) decoratorParts.push(`${attr}: ${val}`);\n                });\n\n                if (p.tooltip) {\n                    let tooltip = p.tooltip;\n                    if (tooltip.startsWith('i18n:')) {\n                        tooltip = Editor.I18n.t(tooltip.slice(5)); // Remove 'i18n:' prefix\n                    }\n                    \n                    if (tooltip.trim().length > 0) {\n                        if (tooltip.match(/<br\\s*\\/?>/i) || tooltip.includes('\\n')) {\n                            const lines = tooltip.split(/<br\\s*\\/?>|\\n/i).map(l => l.trim()).filter(l => l.length > 0);\n                            if (lines.length > 0) {\n                                fields.push(`\\t/**`);\n                                lines.forEach(line => fields.push(`\\t * ${line}`));\n                                fields.push(`\\t */`);\n                            }\n                        } else {\n                            fields.push(`\\t/** ${tooltip} */`);\n                        }\n                    }\n                }\n\n                if (decoratorParts.length > 0) {\n                    fields.push(`\\t@property({ ${decoratorParts.join(', ')} })`);\n                }\n\n                const prefix = !!p.readonly ? 'readonly ' : '';\n                fields.push(`\\t${prefix}${propName}: ${tsType};`);\n                continue;\n            }\n\n            // Raw Value Handling (Primitives and simple objects)\n            if (this.isPrimitive(prop)) {\n                fields.push(`\\t${propName}: ${typeof prop};`);\n                continue;\n            }\n\n            // Array Handling\n            if (Array.isArray(prop)) {\n                if (prop.length === 0) {\n                    fields.push(`\\t${propName}: Array<any>;`);\n                } else {\n                    const firstItem = prop[0];\n                    if (this.isPrimitive(firstItem)) {\n                         fields.push(`\\t${propName}: Array<${typeof firstItem}>;`);\n                    } else if (typeof firstItem === 'object') {\n                         // Raw object in array -> Recursion\n                         const nestedClassName = `${className}${propName.charAt(0).toUpperCase() + propName.slice(1)}Item`;\n                         this.processClass(nestedClassName, firstItem as unknown as { [key: string]: IPropertyValueType });\n                         fields.push(`\\t${propName}: Array<${nestedClassName}>;`);\n                    } else {\n                         fields.push(`\\t${propName}: Array<any>;`);\n                    }\n                }\n                continue;\n            }\n             \n            // Fallback for raw object (struct)\n             if (typeof prop === 'object') {\n                const cleanClassName = className.replace(/^cc\\./, '').replace(/[^a-zA-Z0-9_]/g, '_');\n                const nestedClassName = `${cleanClassName}${propName.charAt(0).toUpperCase() + propName.slice(1)}Type`;\n                this.processClass(nestedClassName, prop as unknown as { [key: string]: IPropertyValueType });                 \n                fields.push(`\\t${propName}: ${nestedClassName};`);\n            }\n        }\n\n        const shortName = className.includes('.') ? className.split('.').pop()! : className;\n        const classDef = [\n            `export class ${shortName} ${extendsClass ? `extends ${extendsClass}` : ''} {`,\n            ...fields,\n            `}`\n        ].join('\\n');\n\n        this._definitions.push(classDef);\n    }\n\n    // Type Guard for IProperty\n    private isProperty(val: any): val is IProperty {\n         return val && typeof val === 'object' && 'value' in val;\n    }\n\n    // Based on info from CCClass\n    private isPrimitiveType(type: string): boolean {\n        return ['Integer', 'Float', 'Number', 'String', 'Boolean'].includes(type);\n    }\n\n    // Check if value is primitive\n    private isPrimitive(value: unknown): boolean {\n        return value === null || (typeof value !== \"object\" && typeof value !== \"function\");\n    }\n\n    // Helper for Enum or BitMask generation\n    private generateEnumDefinition(name: string, items: any[]) {\n        if (this._definedNames.has(name)) return;\n        this._definedNames.add(name);\n\n        const lines: string[] = [];\n        lines.push(`export enum ${name} {`);\n        items.forEach((item) => {\n            let cleanName = item.name.replace(/[^a-zA-Z0-9_]/g, '_');\n            if (/^[0-9]/.test(cleanName)) {\n                cleanName = `_${cleanName}`;\n            }\n            \n            if (typeof item.value === 'string') {\n                lines.push(`\\t${cleanName} = '${item.value}',`);\n            } else {\n                lines.push(`\\t${cleanName} = ${item.value},`);\n            }\n        });\n        lines.push(`}`);\n        this._definitions.unshift(lines.join('\\n'));\n    }\n    \n    private resolveTsType(type: string): string {\n        switch (type) {\n            case 'Integer':\n            case 'Float':\n            case 'Number':\n            case 'Enum': // Enums handled specifically, but fallback for safety\n            case 'BitMask':\n                return 'number';\n            case 'String':\n                return 'string';\n            case 'Boolean':\n                return 'boolean';\n            default:\n                return type; // e.g. Vec3, Color, Node\n        }\n    }\n\n}\n\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utcp-server.js b/extensions/cocos-code-mode/dist/utcp/utcp-server.js new file mode 100644 index 0000000..bcd5e9a --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utcp-server.js @@ -0,0 +1,129 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.UtcpServerManager = void 0; +const express_1 = __importDefault(require("express")); +const cors_1 = __importDefault(require("cors")); +const decorators_1 = require("./decorators"); +require("./tools/typescript-defenition"); +require("./tools/get-properties-tool"); +require("./tools/set-property-tool"); +require("./tools/asset-tools"); +require("./tools/component-tools"); +require("./tools/scene-tools"); +require("./tools/editor-tools"); +const asset_importers_1 = require("./utils/asset-importers"); +const qs_1 = require("qs"); +class UtcpServerManager { + constructor() { + this.app = (0, express_1.default)(); + (0, asset_importers_1.registerAllImporters)(); + } + async start(port = 3000) { + this.app.use((0, cors_1.default)()); + this.app.use(express_1.default.json()); + this.app.set("query parser", (queryString) => (0, qs_1.parse)(queryString, { + decoder(value, defaultDecoder, charset, type) { + const decoded = defaultDecoder(value); + if (decoded === "true") + return true; + if (decoded === "false") + return false; + if (typeof decoded === "string" && + decoded !== "" && + !Number.isNaN(Number(decoded))) { + return Number(decoded); + } + if (decoded === "__null__") + return null; + return decoded; + } + })); + const tools = decorators_1.ToolRegistry.getTools(); + const toolInstances = new Map(); + const utcpTools = []; + let currentPort = port; + // Let's listen first to get the port if it's 0 + return new Promise((resolve, reject) => { + this.server = this.app.listen(port, "127.0.0.1", () => { + const addr = this.server.address(); + if (addr && typeof addr === 'object') { + currentPort = addr.port; + } + // Now register tools with the correct port + this.registerTools(currentPort, tools, toolInstances, utcpTools); + resolve(currentPort); + }); + this.server.on('error', (err) => { + reject(err); + }); + }); + } + registerTools(port, tools, toolInstances, utcpTools) { + const baseUrl = `http://localhost:${port}`; + // Initialize tool instances and build UTCP definitions + for (const toolMeta of tools) { + const ToolClass = toolMeta.target.constructor; + let instance = toolInstances.get(ToolClass); + if (!instance) { + instance = new ToolClass(); + toolInstances.set(ToolClass, instance); + } + const toolDef = JSON.parse(JSON.stringify(toolMeta.tool)); + const toolUrlPath = toolDef.tool_call_template.url; + toolDef.tool_call_template.url = `${baseUrl}${toolUrlPath}`; + utcpTools.push(toolDef); + // Register specific endpoint + const handler = async (req, res) => { + try { + const args = req.query; + let result = await toolMeta.method.apply(instance, [args]); + if (result === undefined || result === null) { + res.json(null); + return; + } + res.json(result); + } + catch (err) { + console.error(`Error in tool ${toolDef.name}:`, err); + res.status(500).json({ error: err.message }); + } + }; + switch (toolDef.tool_call_template.http_method) { + case 'POST': + this.app.post(toolUrlPath, handler); + break; + case 'GET': + this.app.get(toolUrlPath, handler); + break; + case 'DELETE': + this.app.delete(toolUrlPath, handler); + break; + case 'PUT': + this.app.put(toolUrlPath, handler); + break; + default: + // throw new Error(`Unsupported HTTP method: ${toolDef.tool_call_template.http_method}`); + } + } + // Serve UTCP Manual + this.app.get('/utcp', (req, res) => { + const manual = { + utcp_version: "1.0.1", + manual_version: "1.0.0", + tools: utcpTools + }; + res.json(manual); + }); + } + stop() { + if (this.server) { + this.server.close(); + console.log("UTCP Server stopped"); + } + } +} +exports.UtcpServerManager = UtcpServerManager; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utcp-server.js","sourceRoot":"","sources":["../../source/utcp/utcp-server.ts"],"names":[],"mappings":"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","sourcesContent":["import express, { Request, Response } from 'express';\nimport cors from 'cors';\nimport { ToolRegistry } from './decorators';\nimport './tools/typescript-defenition';\nimport './tools/get-properties-tool';\nimport './tools/set-property-tool';\nimport './tools/asset-tools';\nimport './tools/component-tools';\nimport './tools/scene-tools';\nimport './tools/editor-tools';\nimport { registerAllImporters } from './utils/asset-importers';\nimport { Tool, UtcpManual } from '@utcp/sdk';\nimport { parse } from 'qs';\n\nexport class UtcpServerManager {\n    private app: express.Application;\n    private server: any;\n\n    constructor() {\n        this.app = express();\n        registerAllImporters();\n    }\n\n    async start(port: number = 3000): Promise<number> {\n        this.app.use(cors());\n        this.app.use(express.json());\n        this.app.set(\"query parser\", (queryString: string) =>\n            parse(queryString, {\n                decoder(value, defaultDecoder, charset, type) {\n                    const decoded = defaultDecoder(value);\n\n                    if (decoded === \"true\") return true;\n                    if (decoded === \"false\") return false;\n\n                    if (\n                        typeof decoded === \"string\" &&\n                        decoded !== \"\" &&\n                        !Number.isNaN(Number(decoded))\n                    ) {\n                        return Number(decoded);\n                    }\n\n                    if (decoded === \"__null__\") return null;\n\n                    return decoded;\n                }\n            })\n        );\n\n        const tools = ToolRegistry.getTools();\n        const toolInstances = new Map<Function, any>();\n        const utcpTools: Tool[] = [];\n\n        let currentPort = port;\n\n        // Let's listen first to get the port if it's 0\n        return new Promise((resolve, reject) => {\n            this.server = this.app.listen(port, \"127.0.0.1\", () => {\n                const addr = this.server.address();\n                if (addr && typeof addr === 'object') {\n                    currentPort = addr.port;\n                }\n\n                // Now register tools with the correct port\n                this.registerTools(currentPort, tools, toolInstances, utcpTools);\n\n                resolve(currentPort);\n            });\n            this.server.on('error', (err: any) => {\n                reject(err);\n            });\n        });\n    }\n\n    private registerTools(port: number, tools: any[], toolInstances: Map<Function, any>, utcpTools: Tool[]) {\n        const baseUrl = `http://localhost:${port}`;\n\n        // Initialize tool instances and build UTCP definitions\n        for (const toolMeta of tools) {\n            const ToolClass = toolMeta.target.constructor;\n            let instance = toolInstances.get(ToolClass);\n            if (!instance) {\n                instance = new ToolClass();\n                toolInstances.set(ToolClass, instance);\n            }\n\n            const toolDef = JSON.parse(JSON.stringify(toolMeta.tool));\n            const toolUrlPath = toolDef.tool_call_template.url;\n\n            toolDef.tool_call_template.url = `${baseUrl}${toolUrlPath}`;\n\n            utcpTools.push(toolDef);\n\n            // Register specific endpoint\n            const handler = async (req: Request, res: Response) => {\n                try {\n                    const args = req.query;\n\n                    let result = await toolMeta.method.apply(instance, [args]);\n\n                    if (result === undefined || result === null) {\n                        res.json(null);\n                        return;\n                    }\n\n                    res.json(result);\n\n                } catch (err: any) {\n                    console.error(`Error in tool ${toolDef.name}:`, err);\n                    res.status(500).json({ error: err.message });\n                }\n            };\n\n            switch (toolDef.tool_call_template.http_method) {\n                case 'POST':\n                    this.app.post(toolUrlPath, handler);\n                    break;\n                case 'GET':\n                    this.app.get(toolUrlPath, handler);\n                    break;\n                case 'DELETE':\n                    this.app.delete(toolUrlPath, handler);\n                    break;\n                case 'PUT':\n                    this.app.put(toolUrlPath, handler);\n                    break;\n                default:\n                // throw new Error(`Unsupported HTTP method: ${toolDef.tool_call_template.http_method}`);\n            }\n        }\n\n        // Serve UTCP Manual\n        this.app.get('/utcp', (req, res) => {\n            const manual: UtcpManual = {\n                utcp_version: \"1.0.1\",\n                manual_version: \"1.0.0\",\n                tools: utcpTools\n            };\n            res.json(manual);\n        });\n    }\n\n    stop() {\n        if (this.server) {\n            this.server.close();\n            console.log(\"UTCP Server stopped\");\n        }\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/auto-atlas-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/auto-atlas-importer.js new file mode 100644 index 0000000..a7c368b --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/auto-atlas-importer.js @@ -0,0 +1,98 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AutoAtlasImporter = void 0; +const base_importer_1 = require("./base-importer"); +const texture_importer_1 = require("./texture-importer"); +class AutoAtlasImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'auto-atlas'; + this.textureImporter = new texture_importer_1.TextureImporter(); + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta || !meta.userData) + return false; + const userData = meta.userData; + let handled = false; + if (path.includes('.')) { + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + if (!current[parts[i]]) + return false; + current = current[parts[i]]; + } + if (current) { + current[parts[parts.length - 1]] = value; + handled = true; + } + } + else { + userData[path] = value; + handled = true; + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + async getProperties(assetInfo) { + const assetMeta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!assetMeta) { + throw new Error(`Asset meta not found for ${assetInfo.uuid}`); + } + const userData = assetMeta.userData; + if (!userData) { + throw new Error(`UserData not found for asset ${assetInfo.uuid}`); + } + return this.parseUserData(userData); + } + parseUserData(userData) { + const propertyContainer = {}; + // Atlas Settings + propertyContainer.maxWidth = { value: userData.maxWidth, type: 'Integer', displayName: 'Max Width' }; + propertyContainer.maxHeight = { value: userData.maxHeight, type: 'Integer', displayName: 'Max Height' }; + propertyContainer.padding = { value: userData.padding, type: 'Integer', displayName: 'Padding' }; + propertyContainer.allowRotation = { value: !!userData.allowRotation, type: 'Boolean', displayName: 'Allow Rotation' }; + propertyContainer.forceSquared = { value: !!userData.forceSquared, type: 'Boolean', displayName: 'Force Squared' }; + propertyContainer.powerOfTwo = { value: !!userData.powerOfTwo, type: 'Boolean', displayName: 'Power of Two' }; + propertyContainer.algorithm = { + value: userData.algorithm, + type: 'Enum', + enumList: [ + { name: 'MaxRects', value: 'MaxRects' }, + { name: 'Basic', value: 'Basic' } + ], + displayName: 'Algorithm' + }; + propertyContainer.format = { + value: userData.format, + type: 'Enum', + enumList: [ + { name: 'png', value: 'png' }, + { name: 'jpg', value: 'jpg' }, + { name: 'webp', value: 'webp' } + ], + displayName: 'Format' + }; + propertyContainer.quality = { + value: userData.quality, + type: 'Number', + displayName: 'Quality', + visible: userData.format === 'jpg' + }; + propertyContainer.contourBleed = { value: !!userData.contourBleed, type: 'Boolean', displayName: 'Contour Bleed' }; + propertyContainer.paddingBleed = { value: !!userData.paddingBleed, type: 'Boolean', displayName: 'Padding Bleed' }; + propertyContainer.filterUnused = { value: !!userData.filterUnused, type: 'Boolean', displayName: 'Filter Unused Resources' }; + // Texture Settings + if (userData.textureSetting) { + const textureProps = this.textureImporter.parseUserData(userData.textureSetting); + Object.assign(propertyContainer, textureProps); + } + return propertyContainer; + } +} +exports.AutoAtlasImporter = AutoAtlasImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auto-atlas-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/auto-atlas-importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAssetImporter } from './base-importer';\nimport { IAssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { TextureImporter } from './texture-importer';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\n\nexport class AutoAtlasImporter extends BaseAssetImporter {\n    name = 'auto-atlas';\n    private textureImporter = new TextureImporter();\n\n    async setProperty(assetInfo: IAssetInfo, path: string, value: any): Promise<boolean> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        if (!meta || !meta.userData) return false;\n        \n        const userData = meta.userData;\n        let handled = false;\n        \n        if (path.includes('.')) {\n            const parts = path.split('.');\n            let current = userData;\n            for (let i = 0; i < parts.length - 1; i++) {\n                if (!current[parts[i]]) return false;\n                current = current[parts[i]];\n            }\n            if (current) {\n                current[parts[parts.length - 1]] = value;\n                handled = true;\n            }\n        } else {\n            userData[path] = value;\n            handled = true;\n        }\n        \n        if (handled) {\n            await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta));\n            return true;\n        }\n        return false;\n    }\n\n    async getProperties(assetInfo: IAssetInfo): Promise<{ [key: string]: IPropertyValueType }> {\n        const assetMeta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        \n        if (!assetMeta) {\n            throw new Error(`Asset meta not found for ${assetInfo.uuid}`);\n        }\n\n        const userData = assetMeta.userData;\n        if (!userData) {\n            throw new Error(`UserData not found for asset ${assetInfo.uuid}`);\n        }\n\n        return this.parseUserData(userData);\n    }\n\n    private parseUserData(userData: any): { [key: string]: IProperty } {\n        const propertyContainer: { [key: string]: IProperty } = {};\n\n        // Atlas Settings\n        propertyContainer.maxWidth = { value: userData.maxWidth, type: 'Integer', displayName: 'Max Width' };\n        propertyContainer.maxHeight = { value: userData.maxHeight, type: 'Integer', displayName: 'Max Height' };\n        propertyContainer.padding = { value: userData.padding, type: 'Integer', displayName: 'Padding' };\n        propertyContainer.allowRotation = { value: !!userData.allowRotation, type: 'Boolean', displayName: 'Allow Rotation' };\n        propertyContainer.forceSquared = { value: !!userData.forceSquared, type: 'Boolean', displayName: 'Force Squared' };\n        propertyContainer.powerOfTwo = { value: !!userData.powerOfTwo, type: 'Boolean', displayName: 'Power of Two' };\n        \n        propertyContainer.algorithm = { \n            value: userData.algorithm, \n            type: 'Enum', \n            enumList: [\n                { name: 'MaxRects', value: 'MaxRects' },\n                { name: 'Basic', value: 'Basic' }\n            ],\n            displayName: 'Algorithm' \n        };\n        \n        propertyContainer.format = { \n            value: userData.format, \n            type: 'Enum', \n            enumList: [\n                { name: 'png', value: 'png' },\n                { name: 'jpg', value: 'jpg' },\n                { name: 'webp', value: 'webp' }\n            ],\n            displayName: 'Format' \n        };\n\n        propertyContainer.quality = { \n            value: userData.quality, \n            type: 'Number', \n            displayName: 'Quality',\n            visible: userData.format === 'jpg'\n        };\n\n        propertyContainer.contourBleed = { value: !!userData.contourBleed, type: 'Boolean', displayName: 'Contour Bleed' };\n        propertyContainer.paddingBleed = { value: !!userData.paddingBleed, type: 'Boolean', displayName: 'Padding Bleed' };\n        propertyContainer.filterUnused = { value: !!userData.filterUnused, type: 'Boolean', displayName: 'Filter Unused Resources' };\n\n        // Texture Settings\n        if (userData.textureSetting) {\n             const textureProps = this.textureImporter.parseUserData(userData.textureSetting);\n             Object.assign(propertyContainer, textureProps);\n        }\n\n        return propertyContainer;\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/base-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/base-importer.js new file mode 100644 index 0000000..d737aef --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/base-importer.js @@ -0,0 +1,15 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BaseAssetImporter = void 0; +class BaseAssetImporter { + get className() { + // Default: Capitalize name + AssetImporter (e.g. image -> ImageAssetImporter) + return this.name.charAt(0).toUpperCase() + this.name.slice(1) + 'AssetImporter'; + } + async setProperty(assetInfo, path, value) { + console.warn(`[BaseAssetImporter] setProperty not implemented for ${this.name}`); + return false; + } +} +exports.BaseAssetImporter = BaseAssetImporter; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/directory-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/directory-importer.js new file mode 100644 index 0000000..43e4be8 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/directory-importer.js @@ -0,0 +1,96 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DirectoryImporter = void 0; +const base_importer_1 = require("./base-importer"); +class DirectoryImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'directory'; + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta) + return false; + // Ensure userData exists + if (!meta.userData) + meta.userData = {}; + const userData = meta.userData; + let handled = false; + if (path.includes('.')) { + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + if (!current[parts[i]]) + current[parts[i]] = {}; // Create object if missing + current = current[parts[i]]; + } + if (current) { + current[parts[parts.length - 1]] = value; + handled = true; + } + } + else { + userData[path] = value; + handled = true; + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + async getProperties(assetInfo) { + const assetMeta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!assetMeta) { + throw new Error(`Asset meta not found for ${assetInfo.uuid}`); + } + const userData = assetMeta.userData; + // Directory might not have userData if it's not a bundle, but let's handle it gracefully + return this.parseUserData(userData || {}); + } + parseUserData(userData) { + const propertyContainer = {}; + propertyContainer.isBundle = { + value: !!userData.isBundle, + type: 'Boolean', + displayName: 'Is Bundle' + }; + if (userData.isBundle) { + propertyContainer.bundleName = { + value: userData.bundleName, + type: 'String', + displayName: 'Bundle Name' + }; + propertyContainer.priority = { + value: userData.priority, + type: 'Integer', + displayName: 'Priority' + }; + // Some bundles might have compression settings, but we only saw these in the sample + if (userData.compressionType !== undefined) { + propertyContainer.compressionType = { + value: userData.compressionType, + type: 'Enum', // Assuming enum + enumList: [ + { name: 'None', value: 'none' }, + { name: 'Merge Depend', value: 'merge_dep' }, + { name: 'Zip', value: 'zip' }, + { name: 'Zip High Compression', value: 'zip_high' }, + { name: 'Zip Store', value: 'zip_store' } + ], + displayName: 'Compression Type' + }; + } + if (userData.target !== undefined) { + propertyContainer.target = { + value: userData.target, + type: 'String', // Could be array of strings (platforms) + displayName: 'Target Platform' + }; + } + } + return propertyContainer; + } +} +exports.DirectoryImporter = DirectoryImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directory-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/directory-importer.ts"],"names":[],"mappings":";;;AAAA,mDAAoD;AAIpD,MAAa,iBAAkB,SAAQ,iCAAiB;IAAxD;;QACI,SAAI,GAAG,WAAW,CAAC;IAgGvB,CAAC;IA9FG,KAAK,CAAC,WAAW,CAAC,SAAqB,EAAE,IAAY,EAAE,KAAU;QAC7D,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAC1F,IAAI,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QAExB,yBAAyB;QACzB,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAE/B,IAAI,OAAO,GAAG,KAAK,CAAC;QAEpB,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,OAAO,GAAG,QAAQ,CAAC;YACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBACxC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,2BAA2B;gBAC3E,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAChC,CAAC;YACD,IAAI,OAAO,EAAE,CAAC;gBACV,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;gBACzC,OAAO,GAAG,IAAI,CAAC;YACnB,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;YACvB,OAAO,GAAG,IAAI,CAAC;QACnB,CAAC;QAED,IAAI,OAAO,EAAE,CAAC;YACV,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,iBAAiB,EAAE,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;YAClG,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,SAAqB;QACrC,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAE/F,IAAI,CAAC,SAAS,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,4BAA4B,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;QAClE,CAAC;QAED,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC;QACpC,yFAAyF;QACzF,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IAC9C,CAAC;IAEO,aAAa,CAAC,QAAa;QAC/B,MAAM,iBAAiB,GAAiC,EAAE,CAAC;QAE3D,iBAAiB,CAAC,QAAQ,GAAG;YACzB,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ;YAC1B,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,WAAW;SAC3B,CAAC;QAEF,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACpB,iBAAiB,CAAC,UAAU,GAAG;gBAC3B,KAAK,EAAE,QAAQ,CAAC,UAAU;gBAC1B,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,aAAa;aAC7B,CAAC;YAEF,iBAAiB,CAAC,QAAQ,GAAG;gBACzB,KAAK,EAAE,QAAQ,CAAC,QAAQ;gBACxB,IAAI,EAAE,SAAS;gBACf,WAAW,EAAE,UAAU;aAC1B,CAAC;YAEF,oFAAoF;YACpF,IAAI,QAAQ,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;gBACxC,iBAAiB,CAAC,eAAe,GAAG;oBACjC,KAAK,EAAE,QAAQ,CAAC,eAAe;oBAC/B,IAAI,EAAE,MAAM,EAAE,gBAAgB;oBAC9B,QAAQ,EAAE;wBACN,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;wBAC/B,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,EAAE;wBAC5C,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE;wBAC7B,EAAE,IAAI,EAAE,sBAAsB,EAAE,KAAK,EAAE,UAAU,EAAE;wBACnD,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE;qBAC5C;oBACD,WAAW,EAAE,kBAAkB;iBAClC,CAAC;YACN,CAAC;YAED,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAC/B,iBAAiB,CAAC,MAAM,GAAG;oBACxB,KAAK,EAAE,QAAQ,CAAC,MAAM;oBACtB,IAAI,EAAE,QAAQ,EAAE,wCAAwC;oBACxD,WAAW,EAAE,iBAAiB;iBACjC,CAAC;YACN,CAAC;QACL,CAAC;QAED,OAAO,iBAAiB,CAAC;IAC7B,CAAC;CACJ;AAjGD,8CAiGC","sourcesContent":["import { BaseAssetImporter } from './base-importer';\nimport { IAssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\n\nexport class DirectoryImporter extends BaseAssetImporter {\n    name = 'directory';\n\n    async setProperty(assetInfo: IAssetInfo, path: string, value: any): Promise<boolean> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        if (!meta) return false;\n        \n        // Ensure userData exists\n        if (!meta.userData) meta.userData = {};\n        const userData = meta.userData;\n        \n        let handled = false;\n        \n        if (path.includes('.')) {\n            const parts = path.split('.');\n            let current = userData;\n            for (let i = 0; i < parts.length - 1; i++) {\n                if (!current[parts[i]]) current[parts[i]] = {}; // Create object if missing\n                current = current[parts[i]];\n            }\n            if (current) {\n                current[parts[parts.length - 1]] = value;\n                handled = true;\n            }\n        } else {\n            userData[path] = value;\n            handled = true;\n        }\n        \n        if (handled) {\n            await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta));\n            return true;\n        }\n        return false;\n    }\n\n    async getProperties(assetInfo: IAssetInfo): Promise<{ [key: string]: IPropertyValueType }> {\n        const assetMeta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        \n        if (!assetMeta) {\n            throw new Error(`Asset meta not found for ${assetInfo.uuid}`);\n        }\n\n        const userData = assetMeta.userData;\n        // Directory might not have userData if it's not a bundle, but let's handle it gracefully\n        return this.parseUserData(userData || {});\n    }\n\n    private parseUserData(userData: any): { [key: string]: IProperty } {\n        const propertyContainer: { [key: string]: IProperty } = {};\n\n        propertyContainer.isBundle = {\n            value: !!userData.isBundle,\n            type: 'Boolean',\n            displayName: 'Is Bundle'\n        };\n\n        if (userData.isBundle) {\n            propertyContainer.bundleName = {\n                value: userData.bundleName,\n                type: 'String',\n                displayName: 'Bundle Name'\n            };\n\n            propertyContainer.priority = {\n                value: userData.priority,\n                type: 'Integer',\n                displayName: 'Priority'\n            };\n            \n            // Some bundles might have compression settings, but we only saw these in the sample\n            if (userData.compressionType !== undefined) {\n                 propertyContainer.compressionType = {\n                    value: userData.compressionType,\n                    type: 'Enum', // Assuming enum\n                    enumList: [\n                        { name: 'None', value: 'none' },\n                        { name: 'Merge Depend', value: 'merge_dep' },\n                        { name: 'Zip', value: 'zip' },\n                        { name: 'Zip High Compression', value: 'zip_high' },\n                        { name: 'Zip Store', value: 'zip_store' }\n                    ],\n                    displayName: 'Compression Type'\n                };\n            }\n            \n            if (userData.target !== undefined) {\n                 propertyContainer.target = {\n                    value: userData.target,\n                    type: 'String', // Could be array of strings (platforms)\n                    displayName: 'Target Platform'\n                };\n            }\n        }\n\n        return propertyContainer;\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/erp-texture-cube-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/erp-texture-cube-importer.js new file mode 100644 index 0000000..d25d4df --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/erp-texture-cube-importer.js @@ -0,0 +1,81 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ErpTextureCubeImporter = void 0; +const base_importer_1 = require("./base-importer"); +const texture_utils_1 = require("../texture-utils"); +class ErpTextureCubeImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'erp-texture-cube'; + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta || !meta.userData) + return false; + const userData = meta.userData; + let handled = false; + if (texture_utils_1.TextureUtils.applyProperties(userData, path, value)) { + handled = true; + } + if (!handled) { + if (path.includes('.')) { + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + if (!current[parts[i]]) + return false; + current = current[parts[i]]; + } + if (current) { + current[parts[parts.length - 1]] = value; + handled = true; + } + } + else { + userData[path] = value; + handled = true; + } + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + async getProperties(assetInfo) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + const userData = meta === null || meta === void 0 ? void 0 : meta.userData; + if (!userData) { + throw new Error(`UserData not found for asset ${assetInfo.uuid}`); + } + return this.parseUserData(userData); + } + parseUserData(userData) { + const propertyContainer = {}; + propertyContainer.anisotropy = { + value: userData.anisotropy, + type: 'Number', + displayName: 'Anisotropy' + }; + propertyContainer.faceSize = { + value: userData.faceSize, + type: 'Number', + displayName: 'Face Size' + }; + // Texture Utils (Filter/Wrap) + texture_utils_1.TextureUtils.injectTextureProperties(userData, propertyContainer); + propertyContainer.generateMipmaps = { + value: userData.mipfilter !== 'none', + type: 'Boolean', + displayName: 'Generate Mipmaps' + }; + propertyContainer.mipBakeMode = { + value: userData.mipBakeMode, + type: 'Boolean', + displayName: 'Mip Bake Mode' + }; + return propertyContainer; + } +} +exports.ErpTextureCubeImporter = ErpTextureCubeImporter; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJwLXRleHR1cmUtY3ViZS1pbXBvcnRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NvdXJjZS91dGNwL3V0aWxzL2Fzc2V0LWltcG9ydGVycy9lcnAtdGV4dHVyZS1jdWJlLWltcG9ydGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1EQUFvRDtBQUNwRCxvREFBZ0Q7QUFJaEQsTUFBYSxzQkFBdUIsU0FBUSxpQ0FBaUI7SUFBN0Q7O1FBQ0ksU0FBSSxHQUFHLGtCQUFrQixDQUFDO0lBZ0Y5QixDQUFDO0lBOUVHLEtBQUssQ0FBQyxXQUFXLENBQUMsU0FBcUIsRUFBRSxJQUFZLEVBQUUsS0FBVTtRQUM3RCxNQUFNLElBQUksR0FBRyxNQUFNLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLFVBQVUsRUFBRSxrQkFBa0IsRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDMUYsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRO1lBQUUsT0FBTyxLQUFLLENBQUM7UUFFMUMsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUMvQixJQUFJLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFFcEIsSUFBSSw0QkFBWSxDQUFDLGVBQWUsQ0FBQyxRQUFRLEVBQUUsSUFBSSxFQUFFLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDdEQsT0FBTyxHQUFHLElBQUksQ0FBQztRQUNuQixDQUFDO1FBRUQsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ1gsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQ3JCLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQzlCLElBQUksT0FBTyxHQUFHLFFBQVEsQ0FBQztnQkFDdkIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEtBQUssQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7b0JBQ3hDLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO3dCQUFFLE9BQU8sS0FBSyxDQUFDO29CQUNyQyxPQUFPLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUNoQyxDQUFDO2dCQUNELElBQUksT0FBTyxFQUFFLENBQUM7b0JBQ1YsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsS0FBSyxDQUFDO29CQUN6QyxPQUFPLEdBQUcsSUFBSSxDQUFDO2dCQUNuQixDQUFDO1lBQ0wsQ0FBQztpQkFBTSxDQUFDO2dCQUNKLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRyxLQUFLLENBQUM7Z0JBQ3ZCLE9BQU8sR0FBRyxJQUFJLENBQUM7WUFDbkIsQ0FBQztRQUNMLENBQUM7UUFFRCxJQUFJLE9BQU8sRUFBRSxDQUFDO1lBQ1YsTUFBTSxNQUFNLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsaUJBQWlCLEVBQUUsU0FBUyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDbEcsT0FBTyxJQUFJLENBQUM7UUFDaEIsQ0FBQztRQUNELE9BQU8sS0FBSyxDQUFDO0lBQ2pCLENBQUM7SUFFRCxLQUFLLENBQUMsYUFBYSxDQUFDLFNBQXFCO1FBQ3JDLE1BQU0sSUFBSSxHQUFHLE1BQU0sTUFBTSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsVUFBVSxFQUFFLGtCQUFrQixFQUFFLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMxRixNQUFNLFFBQVEsR0FBRyxJQUFJLGFBQUosSUFBSSx1QkFBSixJQUFJLENBQUUsUUFBUSxDQUFDO1FBRWhDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNaLE1BQU0sSUFBSSxLQUFLLENBQUMsZ0NBQWdDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQ3RFLENBQUM7UUFFRCxPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDeEMsQ0FBQztJQUVNLGFBQWEsQ0FBQyxRQUFtQztRQUNwRCxNQUFNLGlCQUFpQixHQUFpQyxFQUFFLENBQUM7UUFFM0QsaUJBQWlCLENBQUMsVUFBVSxHQUFHO1lBQzNCLEtBQUssRUFBRSxRQUFRLENBQUMsVUFBVTtZQUMxQixJQUFJLEVBQUUsUUFBUTtZQUNkLFdBQVcsRUFBRSxZQUFZO1NBQzVCLENBQUM7UUFDRixpQkFBaUIsQ0FBQyxRQUFRLEdBQUc7WUFDekIsS0FBSyxFQUFFLFFBQVEsQ0FBQyxRQUFRO1lBQ3hCLElBQUksRUFBRSxRQUFRO1lBQ2QsV0FBVyxFQUFFLFdBQVc7U0FDM0IsQ0FBQztRQUVGLDhCQUE4QjtRQUM5Qiw0QkFBWSxDQUFDLHVCQUF1QixDQUFDLFFBQVEsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO1FBRWxFLGlCQUFpQixDQUFDLGVBQWUsR0FBRztZQUNoQyxLQUFLLEVBQUUsUUFBUSxDQUFDLFNBQVMsS0FBSyxNQUFNO1lBQ3BDLElBQUksRUFBRSxTQUFTO1lBQ2YsV0FBVyxFQUFFLGtCQUFrQjtTQUNsQyxDQUFDO1FBRUYsaUJBQWlCLENBQUMsV0FBVyxHQUFHO1lBQzVCLEtBQUssRUFBRSxRQUFRLENBQUMsV0FBVztZQUMzQixJQUFJLEVBQUUsU0FBUztZQUNmLFdBQVcsRUFBRSxlQUFlO1NBQy9CLENBQUM7UUFFRixPQUFPLGlCQUFpQixDQUFDO0lBQzdCLENBQUM7Q0FDSjtBQWpGRCx3REFpRkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlQXNzZXRJbXBvcnRlciB9IGZyb20gJy4vYmFzZS1pbXBvcnRlcic7XG5pbXBvcnQgeyBUZXh0dXJlVXRpbHMgfSBmcm9tICcuLi90ZXh0dXJlLXV0aWxzJztcbmltcG9ydCB7IElBc3NldEluZm8gfSBmcm9tICdAY29jb3MvY3JlYXRvci10eXBlcy9lZGl0b3IvcGFja2FnZXMvYXNzZXQtZGIvQHR5cGVzL3B1YmxpYyc7XG5pbXBvcnQgeyBJUHJvcGVydHksIElQcm9wZXJ0eVZhbHVlVHlwZSB9IGZyb20gJ0Bjb2Nvcy9jcmVhdG9yLXR5cGVzL2VkaXRvci9wYWNrYWdlcy9zY2VuZS9AdHlwZXMvcHVibGljJztcblxuZXhwb3J0IGNsYXNzIEVycFRleHR1cmVDdWJlSW1wb3J0ZXIgZXh0ZW5kcyBCYXNlQXNzZXRJbXBvcnRlciB7XG4gICAgbmFtZSA9ICdlcnAtdGV4dHVyZS1jdWJlJztcblxuICAgIGFzeW5jIHNldFByb3BlcnR5KGFzc2V0SW5mbzogSUFzc2V0SW5mbywgcGF0aDogc3RyaW5nLCB2YWx1ZTogYW55KTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgICAgIGNvbnN0IG1ldGEgPSBhd2FpdCBFZGl0b3IuTWVzc2FnZS5yZXF1ZXN0KCdhc3NldC1kYicsICdxdWVyeS1hc3NldC1tZXRhJywgYXNzZXRJbmZvLnV1aWQpO1xuICAgICAgICBpZiAoIW1ldGEgfHwgIW1ldGEudXNlckRhdGEpIHJldHVybiBmYWxzZTtcbiAgICAgICAgXG4gICAgICAgIGNvbnN0IHVzZXJEYXRhID0gbWV0YS51c2VyRGF0YTtcbiAgICAgICAgbGV0IGhhbmRsZWQgPSBmYWxzZTtcblxuICAgICAgICBpZiAoVGV4dHVyZVV0aWxzLmFwcGx5UHJvcGVydGllcyh1c2VyRGF0YSwgcGF0aCwgdmFsdWUpKSB7XG4gICAgICAgICAgICBoYW5kbGVkID0gdHJ1ZTtcbiAgICAgICAgfVxuICAgICAgICBcbiAgICAgICAgaWYgKCFoYW5kbGVkKSB7XG4gICAgICAgICAgICBpZiAocGF0aC5pbmNsdWRlcygnLicpKSB7XG4gICAgICAgICAgICAgICAgY29uc3QgcGFydHMgPSBwYXRoLnNwbGl0KCcuJyk7XG4gICAgICAgICAgICAgICAgbGV0IGN1cnJlbnQgPSB1c2VyRGF0YTtcbiAgICAgICAgICAgICAgICBmb3IgKGxldCBpID0gMDsgaSA8IHBhcnRzLmxlbmd0aCAtIDE7IGkrKykge1xuICAgICAgICAgICAgICAgICAgICBpZiAoIWN1cnJlbnRbcGFydHNbaV1dKSByZXR1cm4gZmFsc2U7XG4gICAgICAgICAgICAgICAgICAgIGN1cnJlbnQgPSBjdXJyZW50W3BhcnRzW2ldXTtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgaWYgKGN1cnJlbnQpIHtcbiAgICAgICAgICAgICAgICAgICAgY3VycmVudFtwYXJ0c1twYXJ0cy5sZW5ndGggLSAxXV0gPSB2YWx1ZTtcbiAgICAgICAgICAgICAgICAgICAgaGFuZGxlZCA9IHRydWU7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgICAgICB1c2VyRGF0YVtwYXRoXSA9IHZhbHVlO1xuICAgICAgICAgICAgICAgIGhhbmRsZWQgPSB0cnVlO1xuICAgICAgICAgICAgfVxuICAgICAgICB9XG4gICAgICAgIFxuICAgICAgICBpZiAoaGFuZGxlZCkge1xuICAgICAgICAgICAgYXdhaXQgRWRpdG9yLk1lc3NhZ2UucmVxdWVzdCgnYXNzZXQtZGInLCAnc2F2ZS1hc3NldC1tZXRhJywgYXNzZXRJbmZvLnV1aWQsIEpTT04uc3RyaW5naWZ5KG1ldGEpKTtcbiAgICAgICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBmYWxzZTtcbiAgICB9XG5cbiAgICBhc3luYyBnZXRQcm9wZXJ0aWVzKGFzc2V0SW5mbzogSUFzc2V0SW5mbyk6IFByb21pc2U8eyBba2V5OiBzdHJpbmddOiBJUHJvcGVydHlWYWx1ZVR5cGUgfT4ge1xuICAgICAgICBjb25zdCBtZXRhID0gYXdhaXQgRWRpdG9yLk1lc3NhZ2UucmVxdWVzdCgnYXNzZXQtZGInLCAncXVlcnktYXNzZXQtbWV0YScsIGFzc2V0SW5mby51dWlkKTtcbiAgICAgICAgY29uc3QgdXNlckRhdGEgPSBtZXRhPy51c2VyRGF0YTtcblxuICAgICAgICBpZiAoIXVzZXJEYXRhKSB7XG4gICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFVzZXJEYXRhIG5vdCBmb3VuZCBmb3IgYXNzZXQgJHthc3NldEluZm8udXVpZH1gKTtcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiB0aGlzLnBhcnNlVXNlckRhdGEodXNlckRhdGEpO1xuICAgIH1cblxuICAgIHB1YmxpYyBwYXJzZVVzZXJEYXRhKHVzZXJEYXRhOiB7IFtpbmRleDogc3RyaW5nXTogYW55OyB9KTogeyBba2V5OiBzdHJpbmddOiBJUHJvcGVydHkgfSB7XG4gICAgICAgIGNvbnN0IHByb3BlcnR5Q29udGFpbmVyOiB7IFtrZXk6IHN0cmluZ106IElQcm9wZXJ0eSB9ID0ge307XG5cbiAgICAgICAgcHJvcGVydHlDb250YWluZXIuYW5pc290cm9weSA9IHtcbiAgICAgICAgICAgIHZhbHVlOiB1c2VyRGF0YS5hbmlzb3Ryb3B5LFxuICAgICAgICAgICAgdHlwZTogJ051bWJlcicsXG4gICAgICAgICAgICBkaXNwbGF5TmFtZTogJ0FuaXNvdHJvcHknXG4gICAgICAgIH07XG4gICAgICAgIHByb3BlcnR5Q29udGFpbmVyLmZhY2VTaXplID0ge1xuICAgICAgICAgICAgdmFsdWU6IHVzZXJEYXRhLmZhY2VTaXplLFxuICAgICAgICAgICAgdHlwZTogJ051bWJlcicsXG4gICAgICAgICAgICBkaXNwbGF5TmFtZTogJ0ZhY2UgU2l6ZSdcbiAgICAgICAgfTtcblxuICAgICAgICAvLyBUZXh0dXJlIFV0aWxzIChGaWx0ZXIvV3JhcClcbiAgICAgICAgVGV4dHVyZVV0aWxzLmluamVjdFRleHR1cmVQcm9wZXJ0aWVzKHVzZXJEYXRhLCBwcm9wZXJ0eUNvbnRhaW5lcik7XG5cbiAgICAgICAgcHJvcGVydHlDb250YWluZXIuZ2VuZXJhdGVNaXBtYXBzID0ge1xuICAgICAgICAgICAgdmFsdWU6IHVzZXJEYXRhLm1pcGZpbHRlciAhPT0gJ25vbmUnLFxuICAgICAgICAgICAgdHlwZTogJ0Jvb2xlYW4nLFxuICAgICAgICAgICAgZGlzcGxheU5hbWU6ICdHZW5lcmF0ZSBNaXBtYXBzJ1xuICAgICAgICB9O1xuXG4gICAgICAgIHByb3BlcnR5Q29udGFpbmVyLm1pcEJha2VNb2RlID0ge1xuICAgICAgICAgICAgdmFsdWU6IHVzZXJEYXRhLm1pcEJha2VNb2RlLFxuICAgICAgICAgICAgdHlwZTogJ0Jvb2xlYW4nLFxuICAgICAgICAgICAgZGlzcGxheU5hbWU6ICdNaXAgQmFrZSBNb2RlJ1xuICAgICAgICB9O1xuXG4gICAgICAgIHJldHVybiBwcm9wZXJ0eUNvbnRhaW5lcjtcbiAgICB9XG59XG4iXX0= \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/fbx-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/fbx-importer.js new file mode 100644 index 0000000..cd3e24e --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/fbx-importer.js @@ -0,0 +1,41 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FbxImporter = void 0; +const model_base_importer_1 = require("./model-base-importer"); +class FbxImporter extends model_base_importer_1.ModelBaseImporter { + constructor() { + super(...arguments); + this.name = 'fbx'; + } + addSpecificUserData(userData, container) { + const fbx = userData.fbx || {}; + container.animationBakeRate = { + value: fbx.animationBakeRate, + type: 'Enum', + enumList: [ + { name: 'Auto', value: 0 }, + { name: 'BakeRate24', value: 24 }, + { name: 'BakeRate25', value: 25 }, + { name: 'BakeRate30', value: 30 }, + { name: 'BakeRate60', value: 60 } + ], + tooltip: 'Specify the animation bake sample rate in frames per second (fps).' + }; + container.preferLocalTimeSpan = { + value: !!fbx.preferLocalTimeSpan, + type: 'Boolean', + tooltip: 'When exporting FBX animations, whether prefer to use the time range recorded in FBX file.
If one is not preferred, or one is invalid for use, the time range is robustly calculated.
Some FBX generators may not export this information.' + }; + container.smartMaterialEnabled = { + value: !!fbx.smartMaterialEnabled, + type: 'Boolean', + tooltip: 'Convert DCC materials to engine builtin materials which match the internal lighting model.' + }; + container.legacyFbxImporter = { + value: !!userData.legacyFbxImporter, + type: 'Boolean', + }; + } +} +exports.FbxImporter = FbxImporter; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/gltf-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/gltf-importer.js new file mode 100644 index 0000000..132b808 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/gltf-importer.js @@ -0,0 +1,15 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GltfImporter = void 0; +const model_base_importer_1 = require("./model-base-importer"); +class GltfImporter extends model_base_importer_1.ModelBaseImporter { + constructor() { + super(...arguments); + this.name = 'gltf'; + } + addSpecificUserData(userData, container) { + // GLTF specific properties if any + } +} +exports.GltfImporter = GltfImporter; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2x0Zi1pbXBvcnRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NvdXJjZS91dGNwL3V0aWxzL2Fzc2V0LWltcG9ydGVycy9nbHRmLWltcG9ydGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLCtEQUEwRDtBQUcxRCxNQUFhLFlBQWEsU0FBUSx1Q0FBaUI7SUFBbkQ7O1FBQ0ksU0FBSSxHQUFHLE1BQU0sQ0FBQztJQUtsQixDQUFDO0lBSGEsbUJBQW1CLENBQUMsUUFBYSxFQUFFLFNBQXVDO1FBQ2hGLGtDQUFrQztJQUN0QyxDQUFDO0NBQ0o7QUFORCxvQ0FNQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vZGVsQmFzZUltcG9ydGVyIH0gZnJvbSAnLi9tb2RlbC1iYXNlLWltcG9ydGVyJztcbmltcG9ydCB7IElQcm9wZXJ0eSB9IGZyb20gJ0Bjb2Nvcy9jcmVhdG9yLXR5cGVzL2VkaXRvci9wYWNrYWdlcy9zY2VuZS9AdHlwZXMvcHVibGljJztcblxuZXhwb3J0IGNsYXNzIEdsdGZJbXBvcnRlciBleHRlbmRzIE1vZGVsQmFzZUltcG9ydGVyIHtcbiAgICBuYW1lID0gJ2dsdGYnO1xuXG4gICAgcHJvdGVjdGVkIGFkZFNwZWNpZmljVXNlckRhdGEodXNlckRhdGE6IGFueSwgY29udGFpbmVyOiB7IFtrZXk6IHN0cmluZ106IElQcm9wZXJ0eSB9KTogdm9pZCB7XG4gICAgICAgIC8vIEdMVEYgc3BlY2lmaWMgcHJvcGVydGllcyBpZiBhbnlcbiAgICB9XG59XG4iXX0= \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/image-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/image-importer.js new file mode 100644 index 0000000..ed05e84 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/image-importer.js @@ -0,0 +1,158 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ImageImporter = void 0; +const base_importer_1 = require("./base-importer"); +const texture_importer_1 = require("./texture-importer"); +const sprite_frame_importer_1 = require("./sprite-frame-importer"); +const erp_texture_cube_importer_1 = require("./erp-texture-cube-importer"); +const texture_utils_1 = require("../texture-utils"); +class ImageImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'image'; + this.textureImporter = new texture_importer_1.TextureImporter(); + this.spriteFrameImporter = new sprite_frame_importer_1.SpriteFrameImporter(); + this.erpTextureCubeImporter = new erp_texture_cube_importer_1.ErpTextureCubeImporter(); + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta) + return false; + const userData = meta.userData; + let handled = false; + // Top level properties + if (['type', 'flipVertical', 'fixAlphaTransparencyArtifacts', 'flipGreenChannel', 'isRGBE'].includes(path)) { + userData[path] = value; + handled = true; + } + // Sub-asset delegation + else if (path.startsWith('texture.') || path.startsWith('spriteFrame.')) { + const [prefix, ...rest] = path.split('.'); + const subPath = rest.join('.'); + let targetImporter = ''; + switch (prefix) { + case 'texture': + targetImporter = 'texture'; + break; + case 'spriteFrame': + targetImporter = 'sprite-frame'; + break; + case 'textureCube': + targetImporter = 'erp-texture-cube'; + break; + } + if (targetImporter && meta.subMetas) { + const subMetaKey = Object.keys(meta.subMetas).find(key => meta.subMetas[key].importer === targetImporter); + if (subMetaKey) { + const subUserData = meta.subMetas[subMetaKey].userData; + let syntheticHandled = false; + if (targetImporter === 'texture') { + syntheticHandled = texture_utils_1.TextureUtils.applyProperties(subUserData, subPath, value); + } + if (!syntheticHandled) { + if (subPath.includes('.')) { + // deep set + const parts = subPath.split('.'); + let current = subUserData; + for (let i = 0; i < parts.length - 1; i++) { + current = current[parts[i]]; + } + if (current) + current[parts[parts.length - 1]] = value; + } + else { + subUserData[subPath] = value; + } + } + handled = true; + } + } + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + async getProperties(assetInfo) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta) { + throw new Error('Asset meta not found'); + } + return await this.inspectImageAsset(meta); + } + async inspectImageAsset(meta) { + var _a, _b, _c; + const propertyContainer = {}; + // Type + propertyContainer['type'] = { + type: 'Enum', + value: meta.userData.type || 'texture', + enumList: [ + { name: 'raw', value: 'raw' }, + { name: 'texture', value: 'texture' }, + { name: 'normal-map', value: 'normal map' }, + { name: 'sprite-frame', value: 'sprite-frame' }, + { name: 'texture-cube', value: 'texture cube' } + ], + displayName: 'Type', + visible: true + }; + // Flip Vertical + propertyContainer['flipVertical'] = { + type: 'Boolean', + value: !!meta.userData.flipVertical, + displayName: 'Flip Vertical', + visible: true + }; + // Fix Alpha Transparency Artifacts + propertyContainer['fixAlphaTransparencyArtifacts'] = { + type: 'Boolean', + value: !!meta.userData.fixAlphaTransparencyArtifacts, + displayName: 'Fix Alpha Transparency Artifacts', + visible: meta.userData.type !== 'normal map' + }; + // Flip Green Channel + propertyContainer['flipGreenChannel'] = { + type: 'Boolean', + value: !!meta.userData.flipGreenChannel, + displayName: 'Flip Green Channel', + visible: true + }; + // Is RGBE + propertyContainer['isRGBE'] = { + type: 'Boolean', + value: !!meta.userData.isRGBE, + displayName: 'Is RGBE', + visible: meta.userData.type === 'texture cube' + }; + // Sub-assets inspection + const subMetas = meta.subMetas || {}; + // Determine which importers to use based on type + const type = meta.userData.type || 'texture'; + if (type === 'texture' || type === 'normal map' || type === 'sprite-frame') { + propertyContainer['texture'] = { + value: this.textureImporter.parseUserData(((_a = Object.values(subMetas).find(sm => sm.importer === 'texture')) === null || _a === void 0 ? void 0 : _a.userData) || {}), + type: 'cc.Object', + displayName: 'Texture Properties' + }; + if (type === 'sprite-frame') { + propertyContainer['spriteFrame'] = { + value: this.spriteFrameImporter.parseUserData(((_b = Object.values(subMetas).find(sm => sm.importer === 'sprite-frame')) === null || _b === void 0 ? void 0 : _b.userData) || {}), + type: 'cc.Object', + displayName: 'Sprite Frame Properties' + }; + } + } + else if (type === 'texture cube') { + propertyContainer['textureCube'] = { + value: this.erpTextureCubeImporter.parseUserData(((_c = Object.values(subMetas).find(sm => sm.importer === 'erp-texture-cube')) === null || _c === void 0 ? void 0 : _c.userData) || {}), + type: 'cc.Object', + displayName: 'Texture Cube Properties' + }; + } + return propertyContainer; + } +} +exports.ImageImporter = ImageImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/image-importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAssetImporter } from './base-importer';\nimport { TextureImporter } from './texture-importer';\nimport { SpriteFrameImporter } from './sprite-frame-importer';\nimport { ErpTextureCubeImporter } from './erp-texture-cube-importer';\nimport { IAssetInfo, IAssetMeta } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\nimport { TextureUtils } from '../texture-utils';\n\nexport class ImageImporter extends BaseAssetImporter {\n    name = 'image';\n\n    private textureImporter = new TextureImporter();\n    private spriteFrameImporter = new SpriteFrameImporter();\n    private erpTextureCubeImporter = new ErpTextureCubeImporter();\n\n    async setProperty(assetInfo: IAssetInfo, path: string, value: any): Promise<boolean> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        if (!meta) return false;\n\n        const userData = meta.userData;\n        let handled = false;\n\n        // Top level properties\n        if (['type', 'flipVertical', 'fixAlphaTransparencyArtifacts', 'flipGreenChannel', 'isRGBE'].includes(path)) {\n            userData[path] = value;\n            handled = true;\n        } \n        // Sub-asset delegation\n        else if (path.startsWith('texture.') || path.startsWith('spriteFrame.')) {\n            const [prefix, ...rest] = path.split('.');\n            const subPath = rest.join('.');\n            let targetImporter = '';\n            \n            switch (prefix) {\n                case 'texture':\n                    targetImporter = 'texture';\n                    break;\n                case 'spriteFrame':\n                    targetImporter = 'sprite-frame';\n                    break;\n                case 'textureCube':\n                    targetImporter = 'erp-texture-cube';\n                    break;\n            }\n\n            if (targetImporter && meta.subMetas) {\n                const subMetaKey = Object.keys(meta.subMetas).find(key => meta.subMetas[key].importer === targetImporter);\n                if (subMetaKey) {\n                    const subUserData = meta.subMetas[subMetaKey].userData;\n                    \n                    let syntheticHandled = false;\n                    if (targetImporter === 'texture') {\n                        syntheticHandled = TextureUtils.applyProperties(subUserData, subPath, value);\n                    }\n\n                    if (!syntheticHandled) {\n                        if (subPath.includes('.')) {\n                            // deep set\n                            const parts = subPath.split('.');\n                            let current = subUserData;\n                            for (let i = 0; i < parts.length - 1; i++) {\n                                current = current[parts[i]];\n                            }\n                            if (current) current[parts[parts.length - 1]] = value;\n                        } else {\n                            subUserData[subPath] = value;\n                        }\n                    }\n                    handled = true;\n                }\n            }\n        }\n\n        if (handled) {\n            await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta));\n            return true;\n        }\n\n        return false;\n    }\n\n    async getProperties(assetInfo: IAssetInfo): Promise<{ [key: string]: IPropertyValueType }> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        \n        if (!meta) {\n            throw new Error('Asset meta not found');\n        }\n\n        return await this.inspectImageAsset(meta);\n    }\n\n    private async inspectImageAsset(meta: IAssetMeta): Promise<{ [key: string]: IProperty }> {\n        const propertyContainer: { [key: string]: IProperty } = {};\n\n        // Type\n        propertyContainer['type'] = {\n            type: 'Enum',\n            value: meta.userData.type || 'texture',\n            enumList: [\n                { name: 'raw', value: 'raw' },\n                { name: 'texture', value: 'texture' },\n                { name: 'normal-map', value: 'normal map' },\n                { name: 'sprite-frame', value: 'sprite-frame' },\n                { name: 'texture-cube', value: 'texture cube' }\n            ],\n            displayName: 'Type',\n            visible: true\n        };\n\n        // Flip Vertical\n        propertyContainer['flipVertical'] = {\n            type: 'Boolean',\n            value: !!meta.userData.flipVertical,\n            displayName: 'Flip Vertical',\n            visible: true\n        };\n\n        // Fix Alpha Transparency Artifacts\n        propertyContainer['fixAlphaTransparencyArtifacts'] = {\n            type: 'Boolean',\n            value: !!meta.userData.fixAlphaTransparencyArtifacts,\n            displayName: 'Fix Alpha Transparency Artifacts',\n            visible: meta.userData.type !== 'normal map'\n        };\n\n        // Flip Green Channel\n        propertyContainer['flipGreenChannel'] = {\n            type: 'Boolean',\n            value: !!meta.userData.flipGreenChannel,\n            displayName: 'Flip Green Channel',\n            visible: true\n        };\n\n        // Is RGBE\n        propertyContainer['isRGBE'] = {\n            type: 'Boolean',\n            value: !!meta.userData.isRGBE,\n            displayName: 'Is RGBE',\n            visible: meta.userData.type === 'texture cube'\n        };\n\n        // Sub-assets inspection\n        const subMetas = meta.subMetas || {};\n        \n        // Determine which importers to use based on type\n        const type = meta.userData.type || 'texture';\n        \n        if (type === 'texture' || type === 'normal map' || type === 'sprite-frame') {\n            propertyContainer['texture'] = {\n                value: this.textureImporter.parseUserData(Object.values(subMetas).find(sm => sm.importer === 'texture')?.userData || {}),\n                type: 'cc.Object',\n                displayName: 'Texture Properties'\n            };\n\n            if (type === 'sprite-frame') {\n                propertyContainer['spriteFrame'] = {\n                    value: this.spriteFrameImporter.parseUserData(Object.values(subMetas).find(sm => sm.importer === 'sprite-frame')?.userData || {}),\n                    type: 'cc.Object',\n                    displayName: 'Sprite Frame Properties'\n                };\n            }\n        } else if (type === 'texture cube') {\n            propertyContainer['textureCube'] = {\n                value: this.erpTextureCubeImporter.parseUserData(Object.values(subMetas).find(sm => sm.importer === 'erp-texture-cube')?.userData || {}),\n                type: 'cc.Object',\n                displayName: 'Texture Cube Properties'\n            };\n        }\n\n        return propertyContainer;\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/importer-manager.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/importer-manager.js new file mode 100644 index 0000000..eccd6a5 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/importer-manager.js @@ -0,0 +1,25 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ImporterManager = void 0; +class ImporterManager { + static getInstance() { + if (!this._instance) { + this._instance = new ImporterManager(); + } + return this._instance; + } + constructor() { + this._importers = new Map(); + } + registerImporter(importer) { + this._importers.set(importer.name, importer); + } + getImporter(name) { + return this._importers.get(name); + } + hasImporter(name) { + return this._importers.has(name); + } +} +exports.ImporterManager = ImporterManager; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1wb3J0ZXItbWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NvdXJjZS91dGNwL3V0aWxzL2Fzc2V0LWltcG9ydGVycy9pbXBvcnRlci1tYW5hZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLE1BQWEsZUFBZTtJQUlqQixNQUFNLENBQUMsV0FBVztRQUNyQixJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2xCLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxlQUFlLEVBQUUsQ0FBQztRQUMzQyxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQzFCLENBQUM7SUFFRDtRQVRRLGVBQVUsR0FBZ0MsSUFBSSxHQUFHLEVBQUUsQ0FBQztJQVNyQyxDQUFDO0lBRWpCLGdCQUFnQixDQUFDLFFBQXdCO1FBQzVDLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDakQsQ0FBQztJQUVNLFdBQVcsQ0FBQyxJQUFZO1FBQzNCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVNLFdBQVcsQ0FBQyxJQUFZO1FBQzNCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDckMsQ0FBQztDQUNKO0FBeEJELDBDQXdCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElBc3NldEltcG9ydGVyIH0gZnJvbSAnLi9iYXNlLWltcG9ydGVyJztcblxuZXhwb3J0IGNsYXNzIEltcG9ydGVyTWFuYWdlciB7XG4gICAgcHJpdmF0ZSBzdGF0aWMgX2luc3RhbmNlOiBJbXBvcnRlck1hbmFnZXI7XG4gICAgcHJpdmF0ZSBfaW1wb3J0ZXJzOiBNYXA8c3RyaW5nLCBJQXNzZXRJbXBvcnRlcj4gPSBuZXcgTWFwKCk7XG5cbiAgICBwdWJsaWMgc3RhdGljIGdldEluc3RhbmNlKCk6IEltcG9ydGVyTWFuYWdlciB7XG4gICAgICAgIGlmICghdGhpcy5faW5zdGFuY2UpIHtcbiAgICAgICAgICAgIHRoaXMuX2luc3RhbmNlID0gbmV3IEltcG9ydGVyTWFuYWdlcigpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiB0aGlzLl9pbnN0YW5jZTtcbiAgICB9XG5cbiAgICBwcml2YXRlIGNvbnN0cnVjdG9yKCkge31cblxuICAgIHB1YmxpYyByZWdpc3RlckltcG9ydGVyKGltcG9ydGVyOiBJQXNzZXRJbXBvcnRlcikge1xuICAgICAgICB0aGlzLl9pbXBvcnRlcnMuc2V0KGltcG9ydGVyLm5hbWUsIGltcG9ydGVyKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgZ2V0SW1wb3J0ZXIobmFtZTogc3RyaW5nKTogSUFzc2V0SW1wb3J0ZXIgfCB1bmRlZmluZWQge1xuICAgICAgICByZXR1cm4gdGhpcy5faW1wb3J0ZXJzLmdldChuYW1lKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgaGFzSW1wb3J0ZXIobmFtZTogc3RyaW5nKTogYm9vbGVhbiB7XG4gICAgICAgIHJldHVybiB0aGlzLl9pbXBvcnRlcnMuaGFzKG5hbWUpO1xuICAgIH1cbn1cbiJdfQ== \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/index.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/index.js new file mode 100644 index 0000000..9bce30f --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/index.js @@ -0,0 +1,75 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.registerAllImporters = registerAllImporters; +const importer_manager_1 = require("./importer-manager"); +const material_importer_1 = require("./material-importer"); +const texture_importer_1 = require("./texture-importer"); +const script_importer_1 = require("./script-importer"); +const physics_material_importer_1 = require("./physics-material-importer"); +const fbx_importer_1 = require("./fbx-importer"); +const gltf_importer_1 = require("./gltf-importer"); +const directory_importer_1 = require("./directory-importer"); +const auto_atlas_importer_1 = require("./auto-atlas-importer"); +const prefab_importer_1 = require("./prefab-importer"); +const image_importer_1 = require("./image-importer"); +const sprite_frame_importer_1 = require("./sprite-frame-importer"); +const texture_cube_importer_1 = require("./texture-cube-importer"); +const erp_texture_cube_importer_1 = require("./erp-texture-cube-importer"); +const render_texture_importer_1 = require("./render-texture-importer"); +const project_settings_importer_1 = require("./project-settings-importer"); +__exportStar(require("./base-importer"), exports); +__exportStar(require("./importer-manager"), exports); +__exportStar(require("./material-importer"), exports); +__exportStar(require("./texture-importer"), exports); +__exportStar(require("./script-importer"), exports); +__exportStar(require("./physics-material-importer"), exports); +__exportStar(require("./fbx-importer"), exports); +__exportStar(require("./gltf-importer"), exports); +__exportStar(require("./directory-importer"), exports); +__exportStar(require("./auto-atlas-importer"), exports); +__exportStar(require("./prefab-importer"), exports); +__exportStar(require("./image-importer"), exports); +__exportStar(require("./sprite-frame-importer"), exports); +__exportStar(require("./texture-cube-importer"), exports); +__exportStar(require("./erp-texture-cube-importer"), exports); +__exportStar(require("./render-texture-importer"), exports); +__exportStar(require("./project-settings-importer"), exports); +function registerAllImporters() { + const manager = importer_manager_1.ImporterManager.getInstance(); + // Project Settings + manager.registerImporter(new project_settings_importer_1.ProjectSettingsImporter()); + // Material + manager.registerImporter(new material_importer_1.MaterialImporter()); + // Scripts + manager.registerImporter(new script_importer_1.ScriptImporter()); // typescript + // Prefab + manager.registerImporter(new prefab_importer_1.PrefabImporter()); + // Textures & Images + manager.registerImporter(new image_importer_1.ImageImporter()); + manager.registerImporter(new texture_importer_1.TextureImporter()); + manager.registerImporter(new sprite_frame_importer_1.SpriteFrameImporter()); + manager.registerImporter(new texture_cube_importer_1.TextureCubeImporter()); + manager.registerImporter(new erp_texture_cube_importer_1.ErpTextureCubeImporter()); + manager.registerImporter(new render_texture_importer_1.RenderTextureImporter()); + // Other + manager.registerImporter(new physics_material_importer_1.PhysicsMaterialImporter()); + manager.registerImporter(new fbx_importer_1.FbxImporter()); + manager.registerImporter(new gltf_importer_1.GltfImporter()); + manager.registerImporter(new directory_importer_1.DirectoryImporter()); + manager.registerImporter(new auto_atlas_importer_1.AutoAtlasImporter()); +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/material-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/material-importer.js new file mode 100644 index 0000000..6cb3894 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/material-importer.js @@ -0,0 +1,322 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.MaterialImporter = void 0; +const base_importer_1 = require("./base-importer"); +class MaterialImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'material'; + } + async getProperties(assetInfo) { + var _a; + const materialDump = await Editor.Message.request('scene', 'query-material', assetInfo.uuid); + if (!materialDump) { + throw new Error('Material dump not found'); + } + const propertyContainer = {}; + // Get Effect Info + const collator = new Intl.Collator(undefined, { numeric: true }); + const effects = Object.values(await Editor.Message.request('scene', 'query-all-effects')) + .filter((effect) => !effect.hideInEditor) + .sort((a, b) => collator.compare(a.name, b.name)); + let effectName = (_a = materialDump.effect) !== null && _a !== void 0 ? _a : 'builtin-standard'; + propertyContainer['effect'] = { + value: effectName, + type: 'Enum', + userData: { enumName: 'MaterialEffectAssetName' }, + enumList: effects.map((effect) => ({ name: effect.name.replace('../', ''), value: effect.name })), + visible: true, + readonly: false + }; + if (materialDump.data) { + const techniqueOptions = materialDump.data.map((t, i) => ({ name: t.name || i.toString(), value: i })); + propertyContainer['technique'] = { + value: materialDump.technique, + type: 'Enum', + enumList: techniqueOptions, + visible: true, + readonly: false + }; + const currentTechniqueIndex = materialDump.technique || 0; + const currentTechnique = materialDump.data[currentTechniqueIndex]; + if (currentTechnique && currentTechnique.passes) { + const passes = []; + function checkDefineVisibility(defines, defineMap) { + for (const def of defines) { + if (def.startsWith('!')) { + if (defineMap[def.substring(1)]) { + return false; + } + } + else { + if (!defineMap[def]) { + return false; + } + } + } + return true; + } + currentTechnique.passes.forEach((pass, passIndex) => { + const passProps = {}; + // Create a map of defines for quick lookup + const defineMap = {}; + if (pass.defines) { + // Prepare define map + pass.defines.forEach((def) => { + defineMap[def.name] = def.value; + }); + // Process defines + pass.defines.forEach((def) => { + // Transform define type based on logic + let type = def.type; + let enumList = def.enumList; + switch (def.type) { + case 'Number': + type = 'Enum'; + enumList = []; + if (def.range && def.range.length >= 2) { + for (let i = def.range[0]; i <= def.range[1]; i++) { + enumList.push({ name: `Variant${i}`, value: i }); + } + } + break; + case 'String': + type = 'Enum'; + enumList = []; + if (def.options) { + enumList = def.options.map((str) => ({ name: str, value: str })); + } + break; + case 'Enum': + break; + default: + type = 'Boolean'; + break; + } + const defProp = { + type: type, + extends: [], + value: def.value, + tooltip: def.tooltip, + enumList: enumList, + visible: checkDefineVisibility(def.defines || [], defineMap) + }; + passProps[def.name] = defProp; + }); + } + // Process properties + if (pass.props) { + pass.props.forEach((prop) => { + // Inject extends: ['cc.ValueType'] for known value types to prevent custom class generation + let extendsData = prop.extends || []; + if (['Vec2', 'Vec3', 'Vec4', 'Color', 'Rect', 'Size', 'Quat', 'Mat3', 'Mat4'].includes(prop.type)) { + if (!extendsData.includes('cc.ValueType')) { + extendsData = [...extendsData, 'cc.ValueType']; + } + } + const valProp = Object.assign(Object.assign({}, prop), { displayName: prop.displayName || prop.name, visible: checkDefineVisibility(prop.defines || [], defineMap), extends: extendsData }); + passProps[prop.name] = valProp; + }); + } + const passHasProps = Object.keys(passProps).length > 0; + passProps['phase'] = { + extends: [], + type: 'String', + value: pass.phase || '', + visible: true, + readonly: true + }; + passes.push({ + extends: ['cc.MaterialPass'], + value: passProps, + type: `cc.MaterialPass${passHasProps ? passIndex : ''}` + }); + }); + const passesProp = { + value: passes, + type: 'cc.MaterialPasses', + visible: true + }; + propertyContainer['passes'] = passesProp; + } + } + return propertyContainer; + } + async setProperty(assetInfo, path, value) { + // 1. Get the current material dump + const materialDump = await Editor.Message.request('scene', 'query-material', assetInfo.uuid); + if (!materialDump) { + return false; + } + let handled = false; + // 2. Handle simple root properties + if (path === 'effectAsset' || path === 'effect') { + const effects = await Editor.Message.request('scene', 'query-all-effects'); + if (value && value.name) { + value = value.name; + } + if (typeof value === 'object' && 'uuid' in value) { + value = value.uuid; + } + if (effects[value]) { + value = effects[value].name; + handled = true; + } + else { + const effect = effects.find((eff) => eff.name === value); + if (effect) { + value = effect.name; + handled = true; + } + else { + // Effect not found + throw new Error(`Effect '${value}' not found`); + } + } + } + else if (path === 'technique') { + materialDump.technique = value; + handled = true; + } + else { + // 3. Handle data/props traversal + const techniqueIndex = materialDump.technique || 0; + const technique = materialDump.data[techniqueIndex]; + if (technique && technique.passes) { + const parts = path.split('.'); + let targetPassIndices = []; + let propPathParts = []; + // Check for explicit pass path "passes.0.propName..." + if (parts[0] === 'passes' && !isNaN(parseInt(parts[1]))) { + targetPassIndices = [parseInt(parts[1])]; + propPathParts = parts.slice(2); + } + else { + // Implicit: Search all passes in current technique + targetPassIndices = technique.passes.map((_, i) => i); + propPathParts = parts; + } + if (propPathParts.length > 0) { + const propName = propPathParts[0]; + const subProps = propPathParts.slice(1); + const setDeepProperty = (target, pathParts, val) => { + let current = target; + // Navigate to the parent of the target property + for (let i = 0; i < pathParts.length - 1; i++) { + const key = pathParts[i]; + // 1. Try to access key directly + if (current[key] !== undefined) { + current = current[key]; + continue; + } + // 2. Try to drill into .value (if current is a wrapper) + if (current.value && typeof current.value === 'object' && current.value[key] !== undefined) { + current = current.value[key]; + continue; + } + // 3. Special case for arrays where we might be accessing by index but current is a wrapper + if (current.value && Array.isArray(current.value) && current.value[key] !== undefined) { + current = current.value[key]; + continue; + } + // Path not found + return false; + } + const lastKey = pathParts[pathParts.length - 1]; + // Helper to set on the final object + const setOnObject = (obj) => { + if (obj[lastKey] === undefined) + return false; + const targetProp = obj[lastKey]; + // Check if the target is a Property Wrapper (Object with .value) + // We avoid Arrays or nulls + if (targetProp && typeof targetProp === 'object' && !Array.isArray(targetProp) && 'value' in targetProp) { + targetProp.value = val; + } + else { + // It's a raw value (primitive or struct without wrapper) + obj[lastKey] = val; + } + return true; + }; + // 1. Try direct set + if (setOnObject(current)) + return true; + // 2. Try set on .value (if wrapper) + if (current.value && typeof current.value === 'object') { + if (setOnObject(current.value)) + return true; + } + return false; + }; + targetPassIndices.forEach(passIndex => { + const pass = technique.passes[passIndex]; + if (!pass) + return; + // 1. Search in props (Array) + if (pass.props) { + const prop = pass.props.find((p) => p.name === propName); + if (prop) { + if (subProps.length === 0) { + if (typeof value === 'string' && prop.type && + (prop.type.toLowerCase().includes('texture') || prop.type.toLowerCase().includes('sampler'))) { + prop.value = { uuid: value }; + } + else { + prop.value = value; + } + handled = true; + } + else { + // Validate if prop.value is object for deep set + if (prop.value && typeof prop.value === 'object') { + if (setDeepProperty(prop, subProps, value)) { + handled = true; + } + } + } + } + } + // 2. Search in defines (Array) + if (pass.defines) { + const define = pass.defines.find((d) => d.name === propName); + if (define) { + if (subProps.length === 0) { + define.value = value; + handled = true; + } + } + } + // 3. Search in states (Object) + if (pass.states && pass.states.value) { + // Check direct state property (e.g., "priority", "primitive") + if (pass.states.value[propName]) { + const stateProp = pass.states.value[propName]; + if (subProps.length === 0) { + stateProp.value = value; + handled = true; + } + else { + if (stateProp.value && typeof stateProp.value === 'object') { + if (setDeepProperty(stateProp, subProps, value)) { + handled = true; + } + } + } + } + } + }); + } + } + } + // 4. Apply changes + if (handled) { + await Editor.Message.request('scene', 'apply-material', assetInfo.uuid, materialDump); + Editor.Message.broadcast('material-inspector:change-dump'); + return true; + } + return false; + } +} +exports.MaterialImporter = MaterialImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/material-importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAssetImporter } from './base-importer';\nimport { IAssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\n\nexport class MaterialImporter extends BaseAssetImporter {\n    name = 'material';\n\n    async getProperties(assetInfo: any): Promise<{ [key: string]: IPropertyValueType }> {\n        const materialDump = await Editor.Message.request('scene', 'query-material', assetInfo.uuid);\n        \n        if (!materialDump) {\n            throw new Error('Material dump not found');\n        }\n\n        const propertyContainer: { [key: string]: IProperty } = {};\n\n        // Get Effect Info\n        const collator = new Intl.Collator(undefined, { numeric: true });\n        const effects = Object.values(await Editor.Message.request('scene', 'query-all-effects'))\n            .filter((effect) => !(effect as any).hideInEditor)\n            .sort((a, b) => collator.compare((a as any).name, (b as any).name));\n\n        let effectName = materialDump.effect ?? 'builtin-standard';\n\n        propertyContainer['effect'] = {\n            value: effectName,\n            type: 'Enum',\n            userData: { enumName: 'MaterialEffectAssetName' },\n            enumList: effects.map((effect: any) => ({ name: effect.name.replace('../', ''), value: effect.name })),\n            visible: true,\n            readonly: false\n        };\n\n        if (materialDump.data) {\n            const techniqueOptions = materialDump.data.map((t: any, i: number) => ({ name: t.name || i.toString(), value: i }));\n            \n            propertyContainer['technique'] = {\n                value: materialDump.technique,\n                type: 'Enum',\n                enumList: techniqueOptions,\n                visible: true,\n                readonly: false\n            };\n            \n            const currentTechniqueIndex = materialDump.technique || 0;\n            const currentTechnique = materialDump.data[currentTechniqueIndex];\n            \n            if (currentTechnique && currentTechnique.passes) {\n                const passes: any[] = [];\n\n                function checkDefineVisibility(defines: any[], defineMap: { [key: string]: any }): boolean {\n                    for (const def of defines) {\n                        if (def.startsWith('!')) {\n                            if (defineMap[def.substring(1)]) {\n                                return false;\n                            }\n                        } else {\n                            if (!defineMap[def]) {\n                                return false;\n                            }\n                        }\n                    }\n                    return true;\n                }\n\n                currentTechnique.passes.forEach((pass: any, passIndex: number) => {\n                    const passProps: { [key:string]: any } = {};\n                    \n                    // Create a map of defines for quick lookup\n                    const defineMap: { [key: string]: any } = {};\n                    \n                    if (pass.defines) {\n                        // Prepare define map\n                        pass.defines.forEach((def: any) => {\n                            defineMap[def.name] = def.value;\n                        });\n                        \n                        // Process defines\n                        pass.defines.forEach((def: any) => {\n                            // Transform define type based on logic\n                            let type = def.type;\n                            let enumList = def.enumList;\n\n                            switch (def.type) {\n                                case 'Number':\n                                    type = 'Enum';\n                                    enumList = [];\n                                    if (def.range && def.range.length >= 2) {\n                                        for (let i = def.range[0]; i <= def.range[1]; i++) {\n                                            enumList.push({ name: `Variant${i}`, value: i });\n                                        }\n                                    }\n                                    break;\n                                case 'String':\n                                    type = 'Enum';\n                                    enumList = [];\n                                    if (def.options) {\n                                        enumList = def.options.map((str: string) => ({ name: str, value: str }));\n                                    }\n                                    break;\n                                case 'Enum':\n                                    break;\n                                default:\n                                    type = 'Boolean';\n                                    break;\n                            }\n\n                            const defProp = {\n                                type: type,\n                                extends: [],\n                                value: def.value,\n                                tooltip: def.tooltip,\n                                enumList: enumList,\n                                visible: checkDefineVisibility(def.defines || [], defineMap)\n                            };\n                            passProps[def.name] = defProp;\n                        });\n                    }\n\n                    // Process properties\n                    if (pass.props) {\n                        pass.props.forEach((prop: any) => {\n                            // Inject extends: ['cc.ValueType'] for known value types to prevent custom class generation\n                            let extendsData = prop.extends || [];\n                            if (['Vec2', 'Vec3', 'Vec4', 'Color', 'Rect', 'Size', 'Quat', 'Mat3', 'Mat4'].includes(prop.type)) {\n                                if (!extendsData.includes('cc.ValueType')) {\n                                    extendsData = [...extendsData, 'cc.ValueType'];\n                                }\n                            }\n\n                            const valProp = {\n                                ...prop,\n                                displayName: prop.displayName || prop.name,\n                                visible: checkDefineVisibility(prop.defines || [], defineMap),\n                                extends: extendsData\n                            };\n                            passProps[prop.name] = valProp;\n                        });\n                    }\n\n                    const passHasProps = Object.keys(passProps).length > 0;\n\n                    passProps['phase'] = {\n                        extends: [],\n                        type: 'String',\n                        value: pass.phase || '',\n                        visible: true,\n                        readonly: true\n                    };\n\n                    passes.push({\n                        extends: ['cc.MaterialPass'],\n                        value: passProps,\n                        type: `cc.MaterialPass${passHasProps ? passIndex : ''}`\n                    });\n                });\n                \n                const passesProp: any = {\n                    value: passes,\n                    type: 'cc.MaterialPasses',\n                    visible: true\n                };\n                propertyContainer['passes'] = passesProp;\n            }\n        }\n\n        return propertyContainer;\n    }\n\n    async setProperty(assetInfo: IAssetInfo, path: string, value: any): Promise<boolean> {\n        // 1. Get the current material dump\n        const materialDump = await Editor.Message.request('scene', 'query-material', assetInfo.uuid);\n        if (!materialDump) {\n            return false;\n        }\n\n        let handled = false;\n\n        // 2. Handle simple root properties\n        if (path === 'effectAsset' || path === 'effect') {\n            const effects = await Editor.Message.request('scene', 'query-all-effects');\n            if (value && value.name) {\n                value = value.name;\n            }\n            if (typeof value === 'object' && 'uuid' in value) {\n                value = value.uuid;\n            }\n            if (effects[value]) {\n                value = effects[value].name;\n                handled = true;\n            } else {\n                const effect = effects.find((eff: any) => eff.name === value);\n                if (effect) {\n                    value = effect.name;\n                    handled = true;\n                } else {\n                    // Effect not found\n                    throw new Error(`Effect '${value}' not found`);\n                }\n            }\n        } else if (path === 'technique') {\n            materialDump.technique = value;\n            handled = true;\n        } else {\n            // 3. Handle data/props traversal\n            const techniqueIndex = materialDump.technique || 0;\n            const technique = materialDump.data[techniqueIndex];\n            \n            if (technique && technique.passes) {\n                const parts = path.split('.');\n                let targetPassIndices: number[] = [];\n                let propPathParts: string[] = [];\n\n                // Check for explicit pass path \"passes.0.propName...\"\n                if (parts[0] === 'passes' && !isNaN(parseInt(parts[1]))) {\n                    targetPassIndices = [parseInt(parts[1])];\n                    propPathParts = parts.slice(2);\n                } else {\n                    // Implicit: Search all passes in current technique\n                    targetPassIndices = technique.passes.map((_: any, i: number) => i);\n                    propPathParts = parts;\n                }\n\n                if (propPathParts.length > 0) {\n                    const propName = propPathParts[0];\n                    const subProps = propPathParts.slice(1);\n\n                    const setDeepProperty = (target: any, pathParts: string[], val: any): boolean => {\n                        let current = target;\n                        \n                        // Navigate to the parent of the target property\n                        for (let i = 0; i < pathParts.length - 1; i++) {\n                            const key = pathParts[i];\n                            \n                            // 1. Try to access key directly\n                            if (current[key] !== undefined) {\n                                current = current[key];\n                                continue;\n                            }\n                            \n                            // 2. Try to drill into .value (if current is a wrapper)\n                            if (current.value && typeof current.value === 'object' && current.value[key] !== undefined) {\n                                current = current.value[key];\n                                continue;\n                            }\n\n                            // 3. Special case for arrays where we might be accessing by index but current is a wrapper\n                            if (current.value && Array.isArray(current.value) && current.value[key] !== undefined) {\n                                current = current.value[key];\n                                continue;\n                            }\n\n                            // Path not found\n                            return false;\n                        }\n                        \n                        const lastKey = pathParts[pathParts.length - 1];\n                        \n                        // Helper to set on the final object\n                        const setOnObject = (obj: any): boolean => {\n                             if (obj[lastKey] === undefined) return false;\n\n                             const targetProp = obj[lastKey];\n                             \n                             // Check if the target is a Property Wrapper (Object with .value)\n                             // We avoid Arrays or nulls\n                             if (targetProp && typeof targetProp === 'object' && !Array.isArray(targetProp) && 'value' in targetProp) {\n                                 targetProp.value = val;\n                             } else {\n                                 // It's a raw value (primitive or struct without wrapper)\n                                 obj[lastKey] = val;\n                             }\n                             return true;\n                        };\n\n                        // 1. Try direct set\n                        if (setOnObject(current)) return true;\n\n                        // 2. Try set on .value (if wrapper)\n                        if (current.value && typeof current.value === 'object') {\n                            if (setOnObject(current.value)) return true;\n                        }\n\n                        return false;\n                    };\n\n\n                    targetPassIndices.forEach(passIndex => {\n                        const pass = technique.passes[passIndex];\n                        if (!pass) return;\n\n                        // 1. Search in props (Array)\n                        if (pass.props) {\n                            const prop = pass.props.find((p: any) => p.name === propName);\n                            if (prop) {\n                                if (subProps.length === 0) {\n                                    if (typeof value === 'string' && prop.type && \n                                        (prop.type.toLowerCase().includes('texture') || prop.type.toLowerCase().includes('sampler'))) {\n                                        prop.value = { uuid: value };\n                                    } else {\n                                        prop.value = value;\n                                    }\n                                    handled = true;\n                                } else {\n                                    // Validate if prop.value is object for deep set\n                                    if (prop.value && typeof prop.value === 'object') {\n                                        if (setDeepProperty(prop, subProps, value)) {\n                                            handled = true;\n                                        }\n                                    }\n                                }\n                            }\n                        }\n\n                        // 2. Search in defines (Array)\n                        if (pass.defines) {\n                            const define = pass.defines.find((d: any) => d.name === propName);\n                            if (define) {\n                                if (subProps.length === 0) {\n                                    define.value = value;\n                                    handled = true;\n                                }\n                            }\n                        }\n                        \n                        // 3. Search in states (Object)\n                        if (pass.states && pass.states.value) {\n                             // Check direct state property (e.g., \"priority\", \"primitive\")\n                             if (pass.states.value[propName]) {\n                                 const stateProp = pass.states.value[propName];\n                                 if (subProps.length === 0) {\n                                      stateProp.value = value;\n                                      handled = true;\n                                 } else {\n                                      if (stateProp.value && typeof stateProp.value === 'object') {\n                                          if (setDeepProperty(stateProp, subProps, value)) {\n                                              handled = true;\n                                          }\n                                      }\n                                 }\n                             }\n                        }\n                    });\n                }\n            }\n        }\n\n        // 4. Apply changes\n        if (handled) {\n             await Editor.Message.request('scene', 'apply-material', assetInfo.uuid, materialDump);\n             Editor.Message.broadcast('material-inspector:change-dump');\n             return true;\n        }\n        \n        return false;\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/model-base-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/model-base-importer.js new file mode 100644 index 0000000..45d6bb7 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/model-base-importer.js @@ -0,0 +1,204 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ModelBaseImporter = void 0; +const base_importer_1 = require("./base-importer"); +class ModelBaseImporter extends base_importer_1.BaseAssetImporter { + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta || !meta.userData) { + return false; + } + const userData = meta.userData; + let handled = false; + // Support for nested paths (e.g. meshOptimize.enable) + if (path.includes('.')) { + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + // If the path segment doesn't exist, we might need to create it if it's a known object + // But for now, assume structure exists or fail + if (!current[parts[i]]) { + // Try to be smart? No, just fail for now. + return false; + } + current = current[parts[i]]; + } + if (current) { + current[parts[parts.length - 1]] = value; + handled = true; + } + } + else { + userData[path] = value; + handled = true; + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + async getProperties(assetInfo) { + const assetMeta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!assetMeta) { + throw new Error(`Asset meta not found for ${assetInfo.uuid}`); + } + const userData = assetMeta.userData; + if (!userData) { + throw new Error(`UserData not found for asset ${assetInfo.uuid}`); + } + const properties = this.parseUserData(userData); + console.log('ModelBaseImporter properties:', properties); + this.addSpecificUserData(userData, properties); + console.log('ModelBaseImporter properties after specific:', properties); + return properties; + } + parseUserData(userData) { + const propertyContainer = {}; + // Common Normals/Tangents settings + const normalOptions = [ + { name: 'Optional', value: 0 }, + { name: 'Exclude', value: 1 }, + { name: 'Require', value: 2 }, + { name: 'Recalculate', value: 3 } + ]; + propertyContainer.normals = { + value: userData.normals, + userData: { enumName: 'cc.ModelDataIncludeMode' }, + type: 'Enum', + enumList: normalOptions + }; + propertyContainer.tangents = { + value: userData.tangents, + userData: { enumName: 'cc.ModelDataIncludeMode' }, + type: 'Enum', + enumList: normalOptions + }; + propertyContainer.morphNormals = { + value: userData.morphNormals, + userData: { enumName: 'cc.ModelDataIncludeMode' }, + type: 'Enum', + enumList: normalOptions, + tooltip: 'Required if you need to use normal map on morph targets' + }; + // Booleans + propertyContainer.skipValidation = { value: !!userData.skipValidation, type: 'Boolean', displayName: 'Skip Validation' }; + propertyContainer.disableMeshSplit = { value: !!userData.disableMeshSplit, type: 'Boolean', displayName: 'Disable Mesh Split' }; + propertyContainer.allowMeshDataAccess = { value: !!userData.allowMeshDataAccess, type: 'Boolean', displayName: 'Allow Data Access' }; + propertyContainer.addVertexColor = { value: !!userData.addVertexColor, type: 'Boolean', displayName: 'Add Vertex Color' }; + propertyContainer.promoteSingleRootNode = { value: !!userData.promoteSingleRootNode, type: 'Boolean', displayName: 'Promote Single Root Node' }; + // Optimization Sections as Objects + propertyContainer.meshOptimize = this.createMeshOptimizeObject(userData.meshOptimize); + propertyContainer.meshSimplify = this.createMeshSimplifyObject(userData.meshSimplify); + propertyContainer.meshCluster = this.createMeshClusterObject(userData.meshCluster); + propertyContainer.meshCompress = this.createMeshCompressObject(userData.meshCompress); + propertyContainer.lods = this.createLODsObject(userData.lods); + return propertyContainer; + } + createMeshOptimizeObject(data) { + const props = {}; + if (!data) { + data = { + enable: false, + vertexCache: false, + vertexFetch: false, + overdraw: false + }; + } + props.enable = { value: !!data.enable, type: 'Boolean', tooltip: 'It is recommended to enable these options for models with high vertex count.' }; + props.vertexCache = { value: !!data.vertexCache, type: 'Boolean' }; + props.vertexFetch = { value: !!data.vertexFetch, type: 'Boolean' }; + props.overdraw = { value: !!data.overdraw, type: 'Boolean' }; + return { + value: props, + type: 'cc.MeshOptimizeOptions', + displayName: 'Mesh Optimize' + }; + } + createMeshSimplifyObject(data) { + const props = {}; + if (!data) { + data = { + enable: false, + targetRatio: 1, + autoErrorRate: false, + errorRate: 1, + lockBoundary: false + }; + } + props.enable = { value: !!data.enable, type: 'Boolean' }; + props.targetRatio = { value: data.targetRatio, type: 'Float', min: 0, max: 1, step: 0.01, tooltip: 'The target ratio of the simplified mesh data. It is recommended to set this value to 0.5.' }; + props.autoErrorRate = { value: !!data.autoErrorRate, type: 'Boolean' }; + props.errorRate = { value: data.errorRate, type: 'Float', min: 0, max: 1, step: 0.01, tooltip: 'The max error rate of the simplified mesh data. This value also alters the result size. It is recommended to tune until you get a good result.', visible: !data.autoErrorRate }; + props.lockBoundary = { value: !!data.lockBoundary, type: 'Boolean' }; + return { + value: props, + type: 'cc.MeshSimplifyOptions', + displayName: 'Mesh Simplify' + }; + } + createMeshClusterObject(data) { + const props = {}; + if (!data) { + data = { + enable: false, + generateBounding: false + }; + } + props.enable = { value: !!data.enable, type: 'Boolean' }; + props.generateBounding = { value: !!data.generateBounding, type: 'Boolean', tooltip: 'Whether to generate bounding sphere and normal cone for the clustered mesh data.' }; + return { + value: props, + type: 'cc.MeshClusterOptions', + displayName: 'Mesh Cluster' + }; + } + createMeshCompressObject(data) { + const props = {}; + if (!data) { + data = { + enable: false, + encode: false, + compress: false, + quantize: false + }; + } + props.enable = { value: !!data.enable, type: 'Boolean' }; + props.encode = { value: !!data.encode, type: 'Boolean' }; + props.compress = { value: !!data.compress, type: 'Boolean' }; + props.quantize = { value: !!data.quantize, type: 'Boolean' }; + return { + value: props, + type: 'cc.MeshCompressOptions', + displayName: 'Mesh Compress' + }; + } + createLODsObject(data) { + const props = {}; + if (!data) { + data = { + enable: false, + options: [] + }; + } + props.enable = { value: !!data.enable, type: 'Boolean', displayName: 'Enable' }; + if (data.options && Array.isArray(data.options)) { + data.options.forEach((opt, index) => { + const lodProps = {}; + lodProps.screenRatio = { value: opt.screenRatio, type: 'Number', displayName: 'Screen Ratio' }; + lodProps.faceCount = { value: opt.faceCount, type: 'Number', displayName: 'Face Count', readonly: true }; + props[`lod${index}`] = { + value: lodProps, + type: 'cc.LodOptions', + }; + }); + } + return { + value: props, + type: 'cc.LodGroups', + displayName: 'LODs' + }; + } +} +exports.ModelBaseImporter = ModelBaseImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-base-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/model-base-importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAssetImporter } from './base-importer';\nimport { IAssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\n\nexport abstract class ModelBaseImporter extends BaseAssetImporter {\n    \n    async setProperty(assetInfo: IAssetInfo, path: string, value: any): Promise<boolean> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        if (!meta || !meta.userData) {\n            return false;\n        }\n        \n        const userData = meta.userData;\n        let handled = false;\n\n        // Support for nested paths (e.g. meshOptimize.enable)\n        if (path.includes('.')) {\n            const parts = path.split('.');\n            let current = userData;\n            for (let i = 0; i < parts.length - 1; i++) {\n                // If the path segment doesn't exist, we might need to create it if it's a known object\n                // But for now, assume structure exists or fail\n                if (!current[parts[i]]) {\n                    // Try to be smart? No, just fail for now.\n                    return false;\n                }\n                current = current[parts[i]];\n            }\n            if (current) {\n                current[parts[parts.length - 1]] = value;\n                handled = true;\n            }\n        } else {\n             userData[path] = value;\n             handled = true;\n        }\n\n        if (handled) {\n            await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta));\n            return true;\n        }\n        return false;\n    }\n\n    async getProperties(assetInfo: IAssetInfo): Promise<{ [key: string]: IPropertyValueType }> {\n        const assetMeta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        \n        if (!assetMeta) {\n            throw new Error(`Asset meta not found for ${assetInfo.uuid}`);\n        }\n\n        const userData = assetMeta.userData;\n        if (!userData) {\n            throw new Error(`UserData not found for asset ${assetInfo.uuid}`);\n        }\n\n        const properties = this.parseUserData(userData);\n        console.log('ModelBaseImporter properties:', properties);\n        this.addSpecificUserData(userData, properties);\n        console.log('ModelBaseImporter properties after specific:', properties);\n        return properties;\n    }\n\n    protected abstract addSpecificUserData(userData: any, container: { [key: string]: IProperty }): void;\n\n    protected parseUserData(userData: any): { [key: string]: IProperty } {\n        const propertyContainer: { [key: string]: IProperty } = {};\n\n        // Common Normals/Tangents settings\n        const normalOptions = [\n            { name: 'Optional', value: 0 },\n            { name: 'Exclude', value: 1 },\n            { name: 'Require', value: 2 },\n            { name: 'Recalculate', value: 3 }\n        ];\n\n        propertyContainer.normals = {\n            value: userData.normals,\n            userData: { enumName: 'cc.ModelDataIncludeMode' },\n            type: 'Enum',\n            enumList: normalOptions\n        };\n        propertyContainer.tangents = {\n            value: userData.tangents,\n            userData: { enumName: 'cc.ModelDataIncludeMode' },\n            type: 'Enum',\n            enumList: normalOptions\n        };\n        propertyContainer.morphNormals = {\n            value: userData.morphNormals,\n            userData: { enumName: 'cc.ModelDataIncludeMode' },\n            type: 'Enum',\n            enumList: normalOptions,\n            tooltip: 'Required if you need to use normal map on morph targets'\n        };\n\n        // Booleans\n        propertyContainer.skipValidation = { value: !!userData.skipValidation, type: 'Boolean', displayName: 'Skip Validation' };\n        propertyContainer.disableMeshSplit = { value: !!userData.disableMeshSplit, type: 'Boolean', displayName: 'Disable Mesh Split' };\n        propertyContainer.allowMeshDataAccess = { value: !!userData.allowMeshDataAccess, type: 'Boolean', displayName: 'Allow Data Access' };\n        propertyContainer.addVertexColor = { value: !!userData.addVertexColor, type: 'Boolean', displayName: 'Add Vertex Color' };\n        propertyContainer.promoteSingleRootNode = { value: !!userData.promoteSingleRootNode, type: 'Boolean', displayName: 'Promote Single Root Node' };\n\n        // Optimization Sections as Objects\n        propertyContainer.meshOptimize = this.createMeshOptimizeObject(userData.meshOptimize);\n        propertyContainer.meshSimplify = this.createMeshSimplifyObject(userData.meshSimplify);\n        propertyContainer.meshCluster = this.createMeshClusterObject(userData.meshCluster);\n        propertyContainer.meshCompress = this.createMeshCompressObject(userData.meshCompress);\n        propertyContainer.lods = this.createLODsObject(userData.lods);\n\n        return propertyContainer;\n    }\n\n    private createMeshOptimizeObject(data: any): IProperty {\n        const props: { [key: string]: IProperty } = {};\n        if (!data) {\n            data = {\n                enable: false,\n                vertexCache: false,\n                vertexFetch: false,\n                overdraw: false\n            };\n        }\n        \n        props.enable = { value: !!data.enable, type: 'Boolean', tooltip: 'It is recommended to enable these options for models with high vertex count.'};\n        props.vertexCache = { value: !!data.vertexCache, type: 'Boolean' };\n        props.vertexFetch = { value: !!data.vertexFetch, type: 'Boolean'};\n        props.overdraw = { value: !!data.overdraw, type: 'Boolean'};\n\n        return {\n            value: props,\n            type: 'cc.MeshOptimizeOptions',\n            displayName: 'Mesh Optimize'\n        };\n    }\n\n    private createMeshSimplifyObject(data: any): IProperty {\n        const props: { [key: string]: IProperty } = {};\n        if (!data) {\n            data = {\n                enable: false,\n                targetRatio: 1,\n                autoErrorRate: false,\n                errorRate: 1,\n                lockBoundary: false\n            };\n        }\n        \n        props.enable = { value: !!data.enable, type: 'Boolean' };\n        props.targetRatio = { value: data.targetRatio, type: 'Float', min: 0, max: 1, step: 0.01, tooltip: 'The target ratio of the simplified mesh data. It is recommended to set this value to 0.5.' };\n        props.autoErrorRate = { value: !!data.autoErrorRate, type: 'Boolean' };\n        props.errorRate = { value: data.errorRate, type: 'Float', min: 0, max: 1, step: 0.01, tooltip: 'The max error rate of the simplified mesh data. This value also alters the result size. It is recommended to tune until you get a good result.', visible: !data.autoErrorRate };\n        props.lockBoundary = { value: !!data.lockBoundary, type: 'Boolean' };\n\n        return {\n            value: props,\n            type: 'cc.MeshSimplifyOptions',\n            displayName: 'Mesh Simplify'\n        };\n    }\n\n    private createMeshClusterObject(data: any): IProperty {\n        const props: { [key: string]: IProperty } = {};\n        if (!data) {\n            data = {\n                enable: false,\n                generateBounding: false\n            };\n        }\n        \n        props.enable = { value: !!data.enable, type: 'Boolean' };\n        props.generateBounding = { value: !!data.generateBounding, type: 'Boolean', tooltip: 'Whether to generate bounding sphere and normal cone for the clustered mesh data.' };\n\n        return {\n            value: props,\n            type: 'cc.MeshClusterOptions',\n            displayName: 'Mesh Cluster'\n        };\n    }\n\n    private createMeshCompressObject(data: any): IProperty {\n        const props: { [key: string]: IProperty } = {};\n        if (!data) {\n            data = {\n                enable: false,\n                encode: false,\n                compress: false,\n                quantize: false\n            };\n        }\n        \n        props.enable = { value: !!data.enable, type: 'Boolean' };\n        props.encode = { value: !!data.encode, type: 'Boolean' };\n        props.compress = { value: !!data.compress, type: 'Boolean' };\n        props.quantize = { value: !!data.quantize, type: 'Boolean' };\n\n        return {\n            value: props,\n            type: 'cc.MeshCompressOptions',\n            displayName: 'Mesh Compress'\n        };\n    }\n\n    private createLODsObject(data: any): IProperty {\n        const props: { [key: string]: IProperty } = {};\n        if (!data) {\n            data = {\n                enable: false,\n                options: []\n            };\n        }\n        \n        props.enable = { value: !!data.enable, type: 'Boolean', displayName: 'Enable' };\n        \n        if (data.options && Array.isArray(data.options)) {\n            data.options.forEach((opt: any, index: number) => {\n                const lodProps: { [key: string]: IProperty } = {};\n                lodProps.screenRatio = { value: opt.screenRatio, type: 'Number', displayName: 'Screen Ratio' };\n                lodProps.faceCount = { value: opt.faceCount, type: 'Number', displayName: 'Face Count', readonly: true };\n                \n                props[`lod${index}`] = {\n                    value: lodProps,\n                    type: 'cc.LodOptions',\n                };\n            });\n        }\n\n        return {\n            value: props,\n            type: 'cc.LodGroups',\n            displayName: 'LODs'\n        };\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/physics-material-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/physics-material-importer.js new file mode 100644 index 0000000..0a2b8f1 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/physics-material-importer.js @@ -0,0 +1,55 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PhysicsMaterialImporter = void 0; +const base_importer_1 = require("./base-importer"); +class PhysicsMaterialImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'physics-material'; + } + async getProperties(assetInfo) { + const materialMeta = await Editor.Message.request('scene', 'query-physics-material', assetInfo.uuid); + if (!materialMeta) { + throw new Error(`Physics material meta not found for ${assetInfo.uuid}`); + } + return materialMeta; + } + async setProperty(assetInfo, path, value) { + let materialMeta = await Editor.Message.request('scene', 'query-physics-material', assetInfo.uuid); + if (!materialMeta) { + return false; + } + // Apply change + if (path.includes('.')) { + const parts = path.split('.'); + let current = materialMeta; + for (let i = 0; i < parts.length - 1; i++) { + current = current[parts[i]]; + if (current === undefined) + current = current[parts[i]].value; + if (current === undefined) + return false; + } + const lastCurrent = current[parts[parts.length - 1]]; + if (typeof lastCurrent === 'object' && 'value' in lastCurrent) { + current[parts[parts.length - 1]].value = value; + } + else { + current[parts[parts.length - 1]] = value; + } + } + else { + if (typeof materialMeta[path] === 'object' && 'value' in materialMeta[path]) { + materialMeta[path].value = value; + } + else { + materialMeta[path] = value; + } + } + materialMeta = await Editor.Message.request('scene', 'change-physics-material', materialMeta); + await Editor.Message.request('scene', 'apply-physics-material', assetInfo.uuid, materialMeta); + return true; + } +} +exports.PhysicsMaterialImporter = PhysicsMaterialImporter; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/prefab-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/prefab-importer.js new file mode 100644 index 0000000..d61d953 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/prefab-importer.js @@ -0,0 +1,66 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PrefabImporter = void 0; +const base_importer_1 = require("./base-importer"); +class PrefabImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'prefab'; + } + async getProperties(assetInfo) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + const userData = meta === null || meta === void 0 ? void 0 : meta.userData; + if (!userData) { + throw new Error(`UserData not found for asset ${assetInfo.uuid}`); + } + return this.parseUserData(userData); + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta || !meta.userData) + return false; + const userData = meta.userData; + let handled = false; + // Prefab currently mostly exposes 'persistent' in metadata + if (path === 'persistent') { + userData.persistent = value; + handled = true; + } + else { + // Generic fallback + if (path.includes('.')) { + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + if (!current[parts[i]]) + return false; + current = current[parts[i]]; + } + if (current) { + current[parts[parts.length - 1]] = value; + handled = true; + } + } + else { + userData[path] = value; + handled = true; + } + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + parseUserData(userData) { + return { + persistent: { + value: !!userData.persistent, + type: 'Boolean', + displayName: 'Persistent' + } + }; + } +} +exports.PrefabImporter = PrefabImporter; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/project-settings-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/project-settings-importer.js new file mode 100644 index 0000000..041cd86 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/project-settings-importer.js @@ -0,0 +1,364 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ProjectSettingsImporter = void 0; +class ProjectSettingsImporter { + get name() { + return 'project-settings'; + } + get className() { + return 'ProjectSettings'; + } + async getProperties(assetInfo) { + try { + // Get actual config + const projectConfig = await Editor.Message.request('project', 'query-config', 'project') || {}; + // Build manual properties + return this.buildProperties(projectConfig); + } + catch (e) { + console.warn('[ProjectSettingsImporter] Failed to query project settings:', e); + return {}; + } + } + async setProperty(assetInfo, path, value) { + try { + // Handle Custom Layers + if (path.startsWith('customLayers')) { + return this.setLayerProperty(path, value); + } + // Handle Sorting Layers + if (path.startsWith('sortingLayers')) { + return this.setSortingLayerProperty(path, value); + } + // Handle Physics Collision Groups + if (path.startsWith('physics.collisionGroups')) { + return this.setCollisionGroupProperty(path, value); + } + // Handle General Settings + if (path.startsWith('general')) { + return this.setGeneralProperty(path, value); + } + // Handle Default Material (Reference Unwrap) + if (path === 'physics.defaultMaterial' && value && typeof value === 'object' && value.uuid) { + value = value.uuid; + } + // Handle Collision Matrix (Object vs Array) + // If path is physics.collisionMatrix.5, it maps to physics.collisionMatrix["5"] which is fine. + await Editor.Message.request('project', 'set-config', 'project', path, value); + return true; + } + catch (e) { + console.warn('[ProjectSettingsImporter] Failed to set project settings:', e); + return false; + } + } + async setGeneralProperty(path, value) { + const config = await Editor.Message.request('project', 'query-config', 'project'); + const general = config.general || {}; + const parts = path.split('.'); + const key = parts[1]; + if (key === 'designResolution') { + // sub-properties: general.designResolution.width + if (parts.length === 3) { + const subKey = parts[2]; + general.designResolution[subKey] = value; + } + else { + // general.designResolution (Replace size values) + if (value && typeof value === 'object') { + if ('width' in value) + general.designResolution.width = value.width; + if ('height' in value) + general.designResolution.height = value.height; + } + } + } + else if (key === 'fitWidth' || key === 'fitHeight') { + general.designResolution[key] = value; + } + else { + general[key] = value; + } + await Editor.Message.request('project', 'set-config', 'project', 'general', general); + return true; + } + async setCollisionGroupProperty(path, value) { + // path: physics.collisionGroups.0.name or physics.collisionGroups.0 + const parts = path.split('.'); + const indexStr = parts[2]; + if (!indexStr) + return false; + const index = parseInt(indexStr); + if (isNaN(index)) + return false; + const config = await Editor.Message.request('project', 'query-config', 'project'); + const physics = config.physics || {}; + const groups = physics.collisionGroups || []; + let newName = ""; + if (typeof value === 'string') + newName = value; + else if (typeof value === 'object' && value.name) + newName = value.name; + // Note: 'index' variable here refers to the ARRAY INDEX in the configuration list, + // NOT the collision group index (1 << groupIndex). + if (index < groups.length) { + // Modification + if (newName) + groups[index].name = newName; + } + else if (index === groups.length) { + // Creation: Find first available group index (0..31) + const usedIndices = new Set(groups.map((g) => g.index)); + // Usually 0 is Default. + if (!usedIndices.has(0)) + usedIndices.add(0); // Treat 0 as used usually + let nextGroupIndex = 1; + while (usedIndices.has(nextGroupIndex)) { + nextGroupIndex++; + } + if (nextGroupIndex > 31) { + console.warn('Max collision groups reached (32).'); + return false; + } + groups.push({ + index: nextGroupIndex, + name: newName || `Group ${nextGroupIndex}` + }); + } + else { + return false; + } + physics.collisionGroups = groups; + await Editor.Message.request('project', 'set-config', 'project', 'physics', physics); + return true; + } + async setSortingLayerProperty(path, value) { + // path: sortingLayers.0 or sortingLayers.0.name + const parts = path.split('.'); + const indexStr = parts[1]; + if (!indexStr) + return false; + const index = parseInt(indexStr); + if (isNaN(index)) + return false; + const config = await Editor.Message.request('project', 'query-config', 'project'); + const sortingInfo = config['sorting-layer'] || { layers: [], increaseId: 0 }; + const layers = sortingInfo.layers || []; + // Determine what we are setting + let patchData = {}; + if (parts.length === 2) { + if (typeof value === 'string') + patchData = { name: value }; + else + patchData = value; + } + else if (parts.length === 3) { + const field = parts[2]; + patchData[field] = value; + } + else { + return false; + } + if (index < layers.length) { + // Modification + layers[index] = Object.assign(Object.assign({}, layers[index]), patchData); + } + else if (index === layers.length) { + // Creation + const newId = (sortingInfo.increaseId || 0) + 1; + sortingInfo.increaseId = newId; + let newValue = patchData.value; + if (newValue === undefined) { + const maxVal = layers.reduce((max, l) => (l.value !== undefined && l.value > max) ? l.value : max, -1); + newValue = maxVal + 1; + } + const newLayer = { + id: newId, + name: patchData.name || `Layer ${newId}`, + value: newValue + }; + layers.push(newLayer); + } + else { + return false; + } + sortingInfo.layers = layers; + // Update the full sorting-layer object to ensure increaseId and set-config sync + await Editor.Message.request('project', 'set-config', 'project', 'sorting-layer', sortingInfo); + return true; + } + async setLayerProperty(path, value) { + // parsing path: customLayers.0.name or customLayers.0 + const parts = path.split('.'); + const indexStr = parts[1]; + if (!indexStr) + return false; + const index = parseInt(indexStr); + if (isNaN(index)) + return false; + let newName = ""; + if (typeof value === 'string') + newName = value; + else if (typeof value === 'object' && value.name) + newName = value.name; + await Editor.Message.request('project', 'set-config', 'project', `layer.${index}`, { name: newName, value: 1 << (index + 1) }); + return true; + } + buildProperties(data) { + const result = {}; + result['sortingLayers'] = { + value: data && data['sorting-layer'] && data['sorting-layer'].layers ? this.buildSortingLayerProperties(data['sorting-layer'].layers) : [], + extends: [], + type: 'SortingLayerItem', + isArray: true, + tooltip: 'Sorting layers for sprites' + }; + result['customLayers'] = { + value: data && data.layer ? this.buildLayerProperties(data.layer) : [], + extends: [], + type: 'LayerItem', + isArray: true, + tooltip: 'User defined rendering layers' + }; + result['physics'] = { + value: data && data.physics ? this.buildPhysicsProperties(data.physics) : {}, + type: 'PhysicsSettings' + }; + result['general'] = { + value: data && data.general ? this.buildGeneralProperties(data.general) : {}, + type: 'GeneralSettings' + }; + return result; + } + buildGeneralProperties(general) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k; + const result = {}; + result['designResolution'] = { + value: { width: (_b = (_a = general.designResolution) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 1280, height: (_d = (_c = general.designResolution) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 720 }, + type: 'cc.Size', + extends: ['cc.ValueType'] + }; + result['fitWidth'] = { value: (_f = (_e = general.designResolution) === null || _e === void 0 ? void 0 : _e.fitWidth) !== null && _f !== void 0 ? _f : false, type: 'Boolean' }; + result['fitHeight'] = { value: (_h = (_g = general.designResolution) === null || _g === void 0 ? void 0 : _g.fitHeight) !== null && _h !== void 0 ? _h : false, type: 'Boolean' }; + result['downloadMaxConcurrency'] = { value: (_j = general.downloadMaxConcurrency) !== null && _j !== void 0 ? _j : 15, type: 'Integer', min: 1 }; + result['highQuality'] = { value: (_k = general.highQuality) !== null && _k !== void 0 ? _k : false, type: 'Boolean' }; + return result; + } + buildPhysicsProperties(physics) { + const result = {}; + // Simple props + const props = [ + { key: 'allowSleep', type: 'Boolean' }, + { key: 'autoSimulation', type: 'Boolean' }, + { key: 'sleepThreshold', type: 'Float' }, + { key: 'fixedTimeStep', type: 'Float', options: { min: 0 } }, + { key: 'maxSubSteps', type: 'Integer', options: { min: 1 } }, + ]; + for (const p of props) { + if (p.key in physics) { + result[p.key] = Object.assign({ value: physics[p.key], type: p.type }, p.options); + } + } + if (physics.gravity) { + result['gravity'] = { value: physics.gravity, type: 'cc.Vec3', extends: ['cc.ValueType'] }; + } + result['defaultMaterial'] = { + value: physics.defaultMaterial ? { uuid: physics.defaultMaterial } : null, + type: 'cc.PhysicsMaterial', + extends: ['cc.Object'] + }; + // Collision Groups + const groups = physics.collisionGroups || []; + result['collisionGroups'] = { + value: groups.map((g) => ({ + value: { + index: { value: g.index, type: 'Integer', readonly: true }, + name: { value: g.name, type: 'String' } + }, + type: 'CollisionGroupItem' + })), + type: 'CollisionGroupItem', + isArray: true, + elementTypeData: { + type: 'CollisionGroupItem', + value: { + index: { value: 0, type: 'Integer', readonly: true }, + name: { value: '', type: 'String' } + } + } + }; + // Collision Matrix + const bitmaskList = []; + // Default group 0 + const defaultGroup = groups.find((g) => g.index === 0); + bitmaskList.push({ name: defaultGroup ? defaultGroup.name : 'DEFAULT', value: 1 << 0 }); + for (const g of groups) { + if (g.index !== 0) { + bitmaskList.push({ name: g.name, value: 1 << g.index }); + } + } + const matrixObj = physics.collisionMatrix || {}; + const matrixArr = []; + // Calculate max index to display + const indices = [0, ...groups.map((g) => g.index), ...Object.keys(matrixObj).map(k => parseInt(k))]; + const maxIndex = Math.max(...indices); + for (let i = 0; i <= maxIndex; i++) { + matrixArr.push({ + value: matrixObj[i] || 0, + type: 'BitMask', + bitmaskList: bitmaskList + }); + } + result['collisionMatrix'] = { + value: matrixArr, + type: 'BitMask', + isArray: true, + elementTypeData: { + type: 'BitMask', + value: 0, + bitmaskList: bitmaskList + } + }; + return result; + } + buildSortingLayerProperties(layers) { + return layers.map(layer => ({ + extends: [], + value: { + id: { + value: layer.id, + type: 'Integer', + readonly: true + }, + name: { + value: layer.name, + type: 'String' + }, + value: { + value: layer.value, + type: 'Integer' + } + }, + type: 'SortingLayerItem' + })); + } + buildLayerProperties(layers) { + return layers.map(layer => ({ + extends: [], + value: { + name: { + value: layer.name, + type: 'String' + }, + value: { + value: layer.value, + type: 'Integer', + readonly: true + } + }, + type: 'LayerItem' + })); + } +} +exports.ProjectSettingsImporter = ProjectSettingsImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-settings-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/project-settings-importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { IAssetImporter } from './base-importer';\nimport { AssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\n\ndeclare const Editor: any;\n\nexport class ProjectSettingsImporter implements IAssetImporter {\n    get name(): string {\n        return 'project-settings';\n    }\n\n    get className(): string {\n        return 'ProjectSettings';\n    }\n\n    async getProperties(assetInfo: AssetInfo): Promise<{ [key: string]: IPropertyValueType }> {\n        try {\n            // Get actual config\n            const projectConfig = await Editor.Message.request('project', 'query-config', 'project') || {};\n            \n            // Build manual properties\n            return this.buildProperties(projectConfig);\n        } catch (e) {\n            console.warn('[ProjectSettingsImporter] Failed to query project settings:', e);\n            return {};\n        }\n    }\n\n    async setProperty(assetInfo: AssetInfo, path: string, value: any): Promise<boolean> {\n        try {\n            // Handle Custom Layers\n            if (path.startsWith('customLayers')) {\n                return this.setLayerProperty(path, value);\n            }\n\n            // Handle Sorting Layers\n            if (path.startsWith('sortingLayers')) {\n                return this.setSortingLayerProperty(path, value);\n            }\n\n            // Handle Physics Collision Groups\n            if (path.startsWith('physics.collisionGroups')) {\n                return this.setCollisionGroupProperty(path, value);\n            }\n\n            // Handle General Settings\n            if (path.startsWith('general')) {\n                return this.setGeneralProperty(path, value);\n            }\n\n            // Handle Default Material (Reference Unwrap)\n            if (path === 'physics.defaultMaterial' && value && typeof value === 'object' && value.uuid) {\n                value = value.uuid;\n            }\n\n            // Handle Collision Matrix (Object vs Array)\n            // If path is physics.collisionMatrix.5, it maps to physics.collisionMatrix[\"5\"] which is fine.\n\n            await Editor.Message.request('project', 'set-config', 'project', path, value);\n            return true;\n        } catch (e) {\n            console.warn('[ProjectSettingsImporter] Failed to set project settings:', e);\n            return false;\n        }\n    }\n\n\n    private async setGeneralProperty(path: string, value: any): Promise<boolean> {\n        const config = await Editor.Message.request('project', 'query-config', 'project');\n        const general = config.general || {};\n        \n        const parts = path.split('.');\n        const key = parts[1];\n        \n        if (key === 'designResolution') {\n             // sub-properties: general.designResolution.width\n             if (parts.length === 3) {\n                 const subKey = parts[2];\n                 general.designResolution[subKey] = value;\n             } else {\n                 // general.designResolution (Replace size values)\n                 if (value && typeof value === 'object') {\n                     if ('width' in value) general.designResolution.width = value.width;\n                     if ('height' in value) general.designResolution.height = value.height;\n                 }\n             }\n        } else if (key === 'fitWidth' || key === 'fitHeight') {\n             general.designResolution[key] = value;\n        } else {\n             general[key] = value;\n        }\n        \n        await Editor.Message.request('project', 'set-config', 'project', 'general', general);\n        return true;\n    }\n\n    private async setCollisionGroupProperty(path: string, value: any): Promise<boolean> {\n        // path: physics.collisionGroups.0.name or physics.collisionGroups.0\n        const parts = path.split('.');\n        const indexStr = parts[2];\n        if (!indexStr) return false;\n        const index = parseInt(indexStr);\n        if (isNaN(index)) return false;\n\n        const config = await Editor.Message.request('project', 'query-config', 'project');\n        const physics = config.physics || {};\n        const groups = physics.collisionGroups || [];\n\n        let newName = \"\";\n        if (typeof value === 'string') newName = value;\n        else if (typeof value === 'object' && value.name) newName = value.name;\n\n        // Note: 'index' variable here refers to the ARRAY INDEX in the configuration list,\n        // NOT the collision group index (1 << groupIndex).\n        \n        if (index < groups.length) {\n             // Modification\n             if (newName) groups[index].name = newName;\n        } else if (index === groups.length) {\n             // Creation: Find first available group index (0..31)\n             const usedIndices = new Set(groups.map((g: any) => g.index));\n             // Usually 0 is Default.\n             if (!usedIndices.has(0)) usedIndices.add(0); // Treat 0 as used usually\n             \n             let nextGroupIndex = 1;\n             while (usedIndices.has(nextGroupIndex)) {\n                 nextGroupIndex++;\n             }\n             \n             if (nextGroupIndex > 31) {\n                 console.warn('Max collision groups reached (32).');\n                 return false;\n             }\n\n             groups.push({\n                 index: nextGroupIndex,\n                 name: newName || `Group ${nextGroupIndex}`\n             });\n        } else {\n            return false;\n        }\n\n        physics.collisionGroups = groups;\n        await Editor.Message.request('project', 'set-config', 'project', 'physics', physics);\n        return true;\n    }\n\n    private async setSortingLayerProperty(path: string, value: any): Promise<boolean> {\n        // path: sortingLayers.0 or sortingLayers.0.name\n        const parts = path.split('.');\n        const indexStr = parts[1];\n        if (!indexStr) return false;\n        const index = parseInt(indexStr);\n        if (isNaN(index)) return false;\n\n        const config = await Editor.Message.request('project', 'query-config', 'project');\n        const sortingInfo = config['sorting-layer'] || { layers: [], increaseId: 0 };\n        const layers = sortingInfo.layers || [];\n\n        // Determine what we are setting\n        let patchData: any = {};\n        if (parts.length === 2) {\n             if (typeof value === 'string') patchData = { name: value };\n             else patchData = value;\n        } else if (parts.length === 3) {\n             const field = parts[2];\n             patchData[field] = value;\n        } else {\n            return false;\n        }\n\n        if (index < layers.length) {\n             // Modification\n             layers[index] = { ...layers[index], ...patchData };\n        } else if (index === layers.length) {\n             // Creation\n             const newId = (sortingInfo.increaseId || 0) + 1;\n             sortingInfo.increaseId = newId;\n             \n             let newValue = patchData.value;\n             if (newValue === undefined) {\n                 const maxVal = layers.reduce((max: number, l: any) => (l.value !== undefined && l.value > max) ? l.value : max, -1);\n                 newValue = maxVal + 1;\n             }\n             \n             const newLayer = {\n                 id: newId,\n                 name: patchData.name || `Layer ${newId}`,\n                 value: newValue\n             };\n             layers.push(newLayer);\n        } else {\n            return false;\n        }\n        \n        sortingInfo.layers = layers;\n        // Update the full sorting-layer object to ensure increaseId and set-config sync\n        await Editor.Message.request('project', 'set-config', 'project', 'sorting-layer', sortingInfo);\n        return true;\n    }\n\n    private async setLayerProperty(path: string, value: any): Promise<boolean> {\n        // parsing path: customLayers.0.name or customLayers.0\n        const parts = path.split('.');\n        const indexStr = parts[1];\n        if (!indexStr) return false;\n        const index = parseInt(indexStr);\n        if (isNaN(index)) return false;\n        \n        let newName = \"\";\n        if (typeof value === 'string') newName = value;\n        else if (typeof value === 'object' && value.name) newName = value.name;\n\n        await Editor.Message.request('project', 'set-config', 'project', `layer.${index}`, { name: newName, value: 1 << (index + 1) });\n        return true;\n    }\n\n    private buildProperties(data: any): { [key: string]: IPropertyValueType } {\n        const result: { [key: string]: IPropertyValueType } = {};\n\n        result['sortingLayers'] = {\n            value: data && data['sorting-layer'] && data['sorting-layer'].layers ? this.buildSortingLayerProperties(data['sorting-layer'].layers) : [],\n            extends: [],\n            type: 'SortingLayerItem',\n            isArray: true,\n            tooltip: 'Sorting layers for sprites'\n        };\n\n        result['customLayers'] = {\n            value: data && data.layer ? this.buildLayerProperties(data.layer) : [],\n            extends: [],\n            type: 'LayerItem',\n            isArray: true,\n            tooltip: 'User defined rendering layers'\n        };\n\n        result['physics'] = {\n            value: data && data.physics ? this.buildPhysicsProperties(data.physics) : {},\n            type: 'PhysicsSettings'\n        };\n\n        result['general'] = {\n            value: data && data.general ? this.buildGeneralProperties(data.general) : {},\n            type: 'GeneralSettings'\n        };\n        \n        return result;\n    }\n\n    private buildGeneralProperties(general: any): { [key: string]: IPropertyValueType } {\n        const result: { [key: string]: IPropertyValueType } = {};\n        \n        result['designResolution'] = {\n            value: { width: general.designResolution?.width ?? 1280, height: general.designResolution?.height ?? 720 },\n            type: 'cc.Size',\n            extends: ['cc.ValueType']\n        };\n        result['fitWidth'] = { value: general.designResolution?.fitWidth ?? false, type: 'Boolean' };\n        result['fitHeight'] = { value: general.designResolution?.fitHeight ?? false, type: 'Boolean' };\n\n        result['downloadMaxConcurrency'] = { value: general.downloadMaxConcurrency ?? 15, type: 'Integer', min: 1 };\n        result['highQuality'] = { value: general.highQuality ?? false, type: 'Boolean' };\n\n        return result;\n    }\n\n    private buildPhysicsProperties(physics: any): { [key: string]: IPropertyValueType } {\n        const result: { [key: string]: IPropertyValueType } = {};\n        \n        // Simple props\n        const props = [\n            { key: 'allowSleep', type: 'Boolean' },\n            { key: 'autoSimulation', type: 'Boolean' },\n            { key: 'sleepThreshold', type: 'Float' },\n            { key: 'fixedTimeStep', type: 'Float', options: { min: 0 } },\n            { key: 'maxSubSteps', type: 'Integer', options: { min: 1 } },\n        ];\n\n        for (const p of props) {\n            if (p.key in physics) {\n                 result[p.key] = { value: physics[p.key], type: p.type, ...p.options };\n            }\n        }\n        \n        if (physics.gravity) {\n            result['gravity'] = { value: physics.gravity, type: 'cc.Vec3', extends: ['cc.ValueType' ] };\n        }\n\n        result['defaultMaterial'] = { \n            value: physics.defaultMaterial ? { uuid: physics.defaultMaterial } : null,\n            type: 'cc.PhysicsMaterial', \n            extends: ['cc.Object'] \n        };\n\n        // Collision Groups\n        const groups = physics.collisionGroups || [];\n        result['collisionGroups'] = {\n             value: groups.map((g: any) => ({\n                 value: {\n                     index: { value: g.index, type: 'Integer', readonly: true },\n                     name: { value: g.name, type: 'String' }\n                 },\n                 type: 'CollisionGroupItem'\n             })),\n             type: 'CollisionGroupItem',\n             isArray: true,\n             elementTypeData: {\n                type: 'CollisionGroupItem',\n                value: {\n                    index: { value: 0, type: 'Integer', readonly: true },\n                    name: { value: '', type: 'String' }\n                }\n             }\n        };\n\n        // Collision Matrix\n        const bitmaskList: { name: string, value: number }[] = [];\n        // Default group 0\n        const defaultGroup = groups.find((g: any) => g.index === 0);\n        bitmaskList.push({ name: defaultGroup ? defaultGroup.name : 'DEFAULT', value: 1 << 0 });\n        \n        for (const g of groups) {\n            if (g.index !== 0) {\n                 bitmaskList.push({ name: g.name, value: 1 << g.index });\n            }\n        }\n\n        const matrixObj = physics.collisionMatrix || {};\n        const matrixArr = [];\n        // Calculate max index to display\n        const indices = [0, ...groups.map((g: any) => g.index), ...Object.keys(matrixObj).map(k => parseInt(k))];\n        const maxIndex = Math.max(...indices);\n        \n        for (let i = 0; i <= maxIndex; i++) {\n            matrixArr.push({\n                value: matrixObj[i] || 0,\n                type: 'BitMask',\n                bitmaskList: bitmaskList\n            });\n        }\n\n        result['collisionMatrix'] = {\n            value: matrixArr,\n            type: 'BitMask',\n            isArray: true,\n            elementTypeData: {\n                type: 'BitMask',\n                value: 0,\n                bitmaskList: bitmaskList\n            }\n        };\n\n        return result;\n    }\n\n    private buildSortingLayerProperties(layers: Array<{ id: number, name: string, value: number }>): Array<IPropertyValueType> {\n        return layers.map(layer => ({\n            extends: [],\n            value: {\n                id: {\n                    value: layer.id,\n                    type: 'Integer',\n                    readonly: true\n                },\n                name: {\n                    value: layer.name,\n                    type: 'String'\n                },\n                value: {\n                    value: layer.value,\n                    type: 'Integer'\n                }\n            },\n            type: 'SortingLayerItem'\n        }));\n    }\n\n    private buildLayerProperties(layers: Array<{ name: string, value: number }>): Array<IPropertyValueType> {\n         return layers.map(layer => ({\n            extends: [],\n            value: {\n                name: {\n                    value: layer.name,\n                    type: 'String'\n                },\n                value: {\n                    value: layer.value,\n                    type: 'Integer',\n                    readonly: true\n                }\n            },\n            type: 'LayerItem'\n        }));\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/render-texture-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/render-texture-importer.js new file mode 100644 index 0000000..d7053ed --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/render-texture-importer.js @@ -0,0 +1,87 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.RenderTextureImporter = void 0; +const base_importer_1 = require("./base-importer"); +const texture_importer_1 = require("./texture-importer"); +const texture_utils_1 = require("../texture-utils"); +class RenderTextureImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'render-texture'; + this.textureImporter = new texture_importer_1.TextureImporter(); + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta || !meta.userData) + return false; + const userData = meta.userData; + let handled = texture_utils_1.TextureUtils.applyProperties(userData, path, value); + if (!handled) { + if (path.includes('.')) { + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + if (!current[parts[i]]) + return false; + current = current[parts[i]]; + } + if (current) { + current[parts[parts.length - 1]] = value; + handled = true; + } + } + else { + userData[path] = value; + handled = true; + } + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + async getProperties(assetInfo) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta) { + throw new Error(`Asset meta not found for ${assetInfo.uuid}`); + } + const userData = meta.userData; + if (!userData) { + throw new Error(`UserData not found for asset ${assetInfo.uuid}`); + } + return this.parseUserData(userData, meta.subMetas); + } + parseUserData(userData, subMetas) { + const propertyContainer = {}; + // Width & Height + propertyContainer.width = { + value: userData.width, + type: 'Integer', + displayName: 'Width' + }; + propertyContainer.height = { + value: userData.height, + type: 'Integer', + displayName: 'Height' + }; + // Texture properties + const textureProps = this.textureImporter.parseUserData(userData); + Object.assign(propertyContainer, textureProps); + // SpriteFrame UUID from subMetas + if (subMetas) { + const spriteFrameSubMeta = Object.values(subMetas).find((sm) => sm.importer === 'sprite-frame'); + if (spriteFrameSubMeta) { + propertyContainer.spriteFrame = { + value: { uuid: spriteFrameSubMeta.uuid }, + type: 'cc.SpriteFrame', + displayName: 'Sprite Frame', + readonly: true + }; + } + } + return propertyContainer; + } +} +exports.RenderTextureImporter = RenderTextureImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-texture-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/render-texture-importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAssetImporter } from './base-importer';\nimport { IAssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { TextureImporter } from './texture-importer';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\nimport { TextureUtils } from '../texture-utils';\n\nexport class RenderTextureImporter extends BaseAssetImporter {\n    name = 'render-texture';\n    private textureImporter = new TextureImporter();\n\n    async setProperty(assetInfo: IAssetInfo, path: string, value: any): Promise<boolean> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        if (!meta || !meta.userData) return false;\n        \n        const userData = meta.userData;\n        let handled = TextureUtils.applyProperties(userData, path, value);\n\n        if (!handled) {\n            if (path.includes('.')) {\n                const parts = path.split('.');\n                let current = userData;\n                for (let i = 0; i < parts.length - 1; i++) {\n                    if (!current[parts[i]]) return false;\n                    current = current[parts[i]];\n                }\n                if (current) {\n                    current[parts[parts.length - 1]] = value;\n                    handled = true;\n                }\n            } else {\n                userData[path] = value;\n                handled = true;\n            }\n        }\n        \n        if (handled) {\n            await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta));\n            return true;\n        }\n        return false;\n    }\n\n    async getProperties(assetInfo: IAssetInfo): Promise<{ [key: string]: IPropertyValueType }> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        \n        if (!meta) {\n            throw new Error(`Asset meta not found for ${assetInfo.uuid}`);\n        }\n\n        const userData = meta.userData;\n        if (!userData) {\n            throw new Error(`UserData not found for asset ${assetInfo.uuid}`);\n        }\n\n        return this.parseUserData(userData, meta.subMetas);\n    }\n\n    private parseUserData(userData: any, subMetas: any): { [key: string]: IProperty } {\n        const propertyContainer: { [key: string]: IProperty } = {};\n\n        // Width & Height\n        propertyContainer.width = {\n            value: userData.width,\n            type: 'Integer',\n            displayName: 'Width'\n        };\n        propertyContainer.height = {\n            value: userData.height,\n            type: 'Integer',\n            displayName: 'Height'\n        };\n\n        // Texture properties\n        const textureProps = this.textureImporter.parseUserData(userData);\n        Object.assign(propertyContainer, textureProps);\n\n        // SpriteFrame UUID from subMetas\n        if (subMetas) {\n            const spriteFrameSubMeta = Object.values(subMetas).find((sm: any) => sm.importer === 'sprite-frame');\n            if (spriteFrameSubMeta) {\n                 propertyContainer.spriteFrame = {\n                    value: { uuid: (spriteFrameSubMeta as any).uuid },\n                    type: 'cc.SpriteFrame',\n                    displayName: 'Sprite Frame',\n                    readonly: true\n                };\n            }\n        }\n\n        return propertyContainer;\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/script-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/script-importer.js new file mode 100644 index 0000000..44f7eab --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/script-importer.js @@ -0,0 +1,99 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ScriptImporter = void 0; +const base_importer_1 = require("./base-importer"); +const fs = __importStar(require("fs")); +class ScriptImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'typescript'; + } + async getProperties(assetInfo) { + const filePath = assetInfo.file; + if (!filePath || !fs.existsSync(filePath)) { + throw new Error(`File not found for asset ${assetInfo.uuid}`); + } + try { + // Limit to 400 lines or 20000 chars, similar to engine inspector + const content = fs.readFileSync(filePath, 'utf-8'); + const MAX_CHARS = 20000; + const MAX_LINES = 400; + let truncated = false; + let finalContent = content; + if (finalContent.length > MAX_CHARS) { + finalContent = finalContent.substring(0, MAX_CHARS); + truncated = true; + } + const lines = finalContent.split('\n'); + if (lines.length > MAX_LINES) { + finalContent = lines.slice(0, MAX_LINES).join('\n'); + truncated = true; + } + if (truncated) { + finalContent += '\n... (truncated)'; + } + return this.parseUserData(finalContent, this.name); + } + catch (e) { + return { + error: { + type: 'String', + value: 'Failed to read script file: ' + e, + displayName: 'Error', + readonly: true + } + }; + } + } + parseUserData(content, language) { + return { + content: { + value: content, + type: 'String', + displayName: 'Content', + readonly: true + }, + language: { + value: language, + type: 'String', + displayName: 'Language', + readonly: true + } + }; + } +} +exports.ScriptImporter = ScriptImporter; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/sprite-frame-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/sprite-frame-importer.js new file mode 100644 index 0000000..205baa7 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/sprite-frame-importer.js @@ -0,0 +1,145 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SpriteFrameImporter = void 0; +const base_importer_1 = require("./base-importer"); +class SpriteFrameImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'sprite-frame'; + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta || !meta.userData) + return false; + const userData = meta.userData; + let handled = false; + if (path.includes('.')) { + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + if (!current[parts[i]]) + return false; + current = current[parts[i]]; + } + if (current) { + current[parts[parts.length - 1]] = value; + handled = true; + } + } + else { + userData[path] = value; + handled = true; + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + async getProperties(assetInfo) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + const userData = meta === null || meta === void 0 ? void 0 : meta.userData; + if (!userData) { + throw new Error(`UserData not found for asset ${assetInfo.uuid}`); + } + return this.parseUserData(userData); + } + parseUserData(userData) { + const propertyContainer = {}; + // Basic properties + propertyContainer.packable = { + value: userData.packable, + type: 'Boolean', + displayName: 'Packable', + }; + propertyContainer.rotated = { + value: userData.rotated, + type: 'Boolean', + displayName: 'Rotated', + readonly: true + }; + propertyContainer.offsetX = { + value: userData.offsetX, + type: 'Number', + displayName: 'Offset X', + readonly: true + }; + propertyContainer.offsetY = { + value: userData.offsetY, + type: 'Number', + displayName: 'Offset Y', + readonly: true + }; + // Trim + propertyContainer.trimType = { + value: userData.trimType, + type: 'Enum', + enumList: ['auto', 'custom', 'none'].map(k => ({ name: k, value: k })), + displayName: 'Trim Type' + }; + propertyContainer.trimThreshold = { + value: userData.trimThreshold, + type: 'Number', + displayName: 'Trim Threshold' + }; + propertyContainer.trimX = { + value: userData.trimX, + type: 'Number', + displayName: 'Trim X' + }; + propertyContainer.trimY = { + value: userData.trimY, + type: 'Number', + displayName: 'Trim Y' + }; + propertyContainer.width = { + value: userData.width, + type: 'Number', + displayName: 'Width' + }; + propertyContainer.height = { + value: userData.height, + type: 'Number', + displayName: 'Height' + }; + // Borders + propertyContainer.borderTop = { + value: userData.borderTop, + type: 'Number', + displayName: 'Border Top' + }; + propertyContainer.borderBottom = { + value: userData.borderBottom, + type: 'Number', + displayName: 'Border Bottom' + }; + propertyContainer.borderLeft = { + value: userData.borderLeft, + type: 'Number', + displayName: 'Border Left' + }; + propertyContainer.borderRight = { + value: userData.borderRight, + type: 'Number', + displayName: 'Border Right' + }; + propertyContainer.pixelsToUnit = { + value: userData.pixelsToUnit, + type: 'Number', + displayName: 'Pixels To Unit' + }; + propertyContainer.pivotX = { + value: userData.pivotX, + type: 'Number', + displayName: 'Pivot X' + }; + propertyContainer.pivotY = { + value: userData.pivotY, + type: 'Number', + displayName: 'Pivot Y' + }; + return propertyContainer; + } +} +exports.SpriteFrameImporter = SpriteFrameImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sprite-frame-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/sprite-frame-importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAssetImporter } from './base-importer';\nimport { IAssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\n\nexport class SpriteFrameImporter extends BaseAssetImporter {\n    name = 'sprite-frame';\n\n    async setProperty(assetInfo: IAssetInfo, path: string, value: any): Promise<boolean> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        if (!meta || !meta.userData) return false;\n        \n        const userData = meta.userData;\n        let handled = false;\n        \n        if (path.includes('.')) {\n            const parts = path.split('.');\n            let current = userData;\n            for (let i = 0; i < parts.length - 1; i++) {\n                if (!current[parts[i]]) return false;\n                current = current[parts[i]];\n            }\n            if (current) {\n                current[parts[parts.length - 1]] = value;\n                handled = true;\n            }\n        } else {\n            userData[path] = value;\n            handled = true;\n        }\n        \n        if (handled) {\n            await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta));\n            return true;\n        }\n        return false;\n    }\n\n    async getProperties(assetInfo: IAssetInfo): Promise<{ [key: string]: IPropertyValueType }> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        const userData = meta?.userData;\n\n        if (!userData) {\n            throw new Error(`UserData not found for asset ${assetInfo.uuid}`);\n        }\n        \n        return this.parseUserData(userData);\n    }\n\n    public parseUserData(userData: { [index: string]: any; }): { [key: string]: IProperty } {\n        const propertyContainer: { [key: string]: IProperty } = {};\n\n        // Basic properties\n        propertyContainer.packable = {\n            value: userData.packable,\n            type: 'Boolean',\n            displayName: 'Packable',\n        };\n        propertyContainer.rotated = {\n            value: userData.rotated,\n            type: 'Boolean',\n            displayName: 'Rotated',\n            readonly: true\n        };\n        propertyContainer.offsetX = {\n            value: userData.offsetX,\n            type: 'Number',\n            displayName: 'Offset X',\n            readonly: true\n        };\n        propertyContainer.offsetY = {\n            value: userData.offsetY,\n            type: 'Number',\n            displayName: 'Offset Y',\n            readonly: true\n        };\n\n        // Trim\n        propertyContainer.trimType = {\n            value: userData.trimType,\n            type: 'Enum',\n            enumList: ['auto', 'custom', 'none'].map(k => ({ name: k, value: k })),\n            displayName: 'Trim Type'\n        };\n        propertyContainer.trimThreshold = {\n            value: userData.trimThreshold,\n            type: 'Number',\n            displayName: 'Trim Threshold'\n        };\n        propertyContainer.trimX = {\n            value: userData.trimX,\n            type: 'Number',\n            displayName: 'Trim X'\n        };\n        propertyContainer.trimY = {\n            value: userData.trimY,\n            type: 'Number',\n            displayName: 'Trim Y'\n        };\n        propertyContainer.width = {\n            value: userData.width,\n            type: 'Number',\n            displayName: 'Width'\n        };\n        propertyContainer.height = {\n            value: userData.height,\n            type: 'Number',\n            displayName: 'Height'\n        };\n\n        // Borders\n        propertyContainer.borderTop = {\n            value: userData.borderTop,\n            type: 'Number',\n            displayName: 'Border Top'\n        };\n        propertyContainer.borderBottom = {\n            value: userData.borderBottom,\n            type: 'Number',\n            displayName: 'Border Bottom'\n        };\n        propertyContainer.borderLeft = {\n            value: userData.borderLeft,\n            type: 'Number',\n            displayName: 'Border Left'\n        };\n        propertyContainer.borderRight = {\n            value: userData.borderRight,\n            type: 'Number',\n            displayName: 'Border Right'\n        };\n\n        propertyContainer.pixelsToUnit = {\n            value: userData.pixelsToUnit,\n            type: 'Number',\n            displayName: 'Pixels To Unit'\n        };\n        propertyContainer.pivotX = {\n            value: userData.pivotX,\n            type: 'Number',\n            displayName: 'Pivot X'\n        };\n        propertyContainer.pivotY = {\n            value: userData.pivotY,\n            type: 'Number',\n            displayName: 'Pivot Y'\n        };\n\n        return propertyContainer;\n    }\n\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/texture-cube-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/texture-cube-importer.js new file mode 100644 index 0000000..9d40a8a --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/texture-cube-importer.js @@ -0,0 +1,85 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TextureCubeImporter = void 0; +const base_importer_1 = require("./base-importer"); +const texture_utils_1 = require("../texture-utils"); +class TextureCubeImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'texture-cube'; + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta || !meta.userData) + return false; + const userData = meta.userData; + let handled = false; + if (texture_utils_1.TextureUtils.applyProperties(userData, path, value)) { + handled = true; + } + if (!handled) { + if (path.includes('.')) { + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + if (!current[parts[i]]) + return false; + current = current[parts[i]]; + } + if (current) { + current[parts[parts.length - 1]] = value; + handled = true; + } + } + else { + userData[path] = value; + handled = true; + } + } + if (handled) { + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + return false; + } + async getProperties(assetInfo) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + if (!meta) { + return {}; + } + const userData = meta.userData || {}; + return this.parseUserData(userData); + } + parseUserData(userData) { + const propertyContainer = {}; + // Faces + ['front', 'back', 'left', 'right', 'top', 'bottom'].forEach(face => { + propertyContainer[face] = { + value: userData[face] ? { uuid: userData[face] } : null, + type: 'cc.ImageAsset', + displayName: face.charAt(0).toUpperCase() + face.slice(1) + }; + }); + // Texture Settings + propertyContainer.anisotropy = { + value: userData.anisotropy, + type: 'Number', + displayName: 'Anisotropy' + }; + propertyContainer.faceSize = { + value: userData.faceSize, + type: 'Number', + displayName: 'Face Size' + }; + // Texture Utils (Filter/Wrap) + texture_utils_1.TextureUtils.injectTextureProperties(userData, propertyContainer); + propertyContainer.generateMipmaps = { + value: userData.mipfilter !== 'none', + type: 'Boolean', + displayName: 'Generate Mipmaps' + }; + return propertyContainer; + } +} +exports.TextureCubeImporter = TextureCubeImporter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"texture-cube-importer.js","sourceRoot":"","sources":["../../../../source/utcp/utils/asset-importers/texture-cube-importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAssetImporter } from './base-importer';\nimport { TextureUtils } from '../texture-utils';\nimport { IAssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\nimport { IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\n\nexport class TextureCubeImporter extends BaseAssetImporter {\n    name = 'texture-cube';\n\n    async setProperty(assetInfo: IAssetInfo, path: string, value: any): Promise<boolean> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        if (!meta || !meta.userData) return false;\n        \n        const userData = meta.userData;\n        let handled = false;\n\n        if (TextureUtils.applyProperties(userData, path, value)) {\n            handled = true;\n        }\n        \n        if (!handled) {\n            if (path.includes('.')) {\n                const parts = path.split('.');\n                let current = userData;\n                for (let i = 0; i < parts.length - 1; i++) {\n                    if (!current[parts[i]]) return false;\n                    current = current[parts[i]];\n                }\n                if (current) {\n                    current[parts[parts.length - 1]] = value;\n                    handled = true;\n                }\n            } else {\n                userData[path] = value;\n                handled = true;\n            }\n        }\n        \n        if (handled) {\n            await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta));\n            return true;\n        }\n        return false;\n    }\n\n    async getProperties(assetInfo: IAssetInfo): Promise<{ [key: string]: IPropertyValueType }> {\n        const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n        if (!meta) {\n            return {};\n        }\n        const userData = meta.userData || {};\n        return this.parseUserData(userData);\n    }\n\n    public parseUserData(userData: { [index: string]: any; }): { [key: string]: IProperty } {\n        const propertyContainer: { [key: string]: IProperty } = {};\n\n        // Faces\n        ['front', 'back', 'left', 'right', 'top', 'bottom'].forEach(face => {\n            propertyContainer[face] = {\n                value: userData[face] ? { uuid: userData[face] } : null,\n                type: 'cc.ImageAsset',\n                displayName: face.charAt(0).toUpperCase() + face.slice(1)\n            };\n        });\n\n        // Texture Settings\n        propertyContainer.anisotropy = {\n            value: userData.anisotropy,\n            type: 'Number',\n            displayName: 'Anisotropy'\n        };\n        propertyContainer.faceSize = {\n            value: userData.faceSize,\n            type: 'Number',\n            displayName: 'Face Size'\n        };\n\n        // Texture Utils (Filter/Wrap)\n        TextureUtils.injectTextureProperties(userData, propertyContainer);\n\n        propertyContainer.generateMipmaps = {\n            value: userData.mipfilter !== 'none',\n            type: 'Boolean',\n            displayName: 'Generate Mipmaps'\n        };\n\n        return propertyContainer;\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/texture-importer.js b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/texture-importer.js new file mode 100644 index 0000000..9cf828f --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/asset-importers/texture-importer.js @@ -0,0 +1,60 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TextureImporter = void 0; +const base_importer_1 = require("./base-importer"); +const texture_utils_1 = require("../texture-utils"); +class TextureImporter extends base_importer_1.BaseAssetImporter { + constructor() { + super(...arguments); + this.name = 'texture'; + } + async getProperties(assetInfo) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + const userData = meta === null || meta === void 0 ? void 0 : meta.userData; + if (!userData) { + throw new Error(`UserData not found for asset ${assetInfo.uuid}`); + } + return this.parseUserData(userData); + } + async setProperty(assetInfo, path, value) { + const meta = await Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + const userData = meta === null || meta === void 0 ? void 0 : meta.userData; + if (!userData) { + return false; + } + let handled = texture_utils_1.TextureUtils.applyProperties(userData, path, value); + if (!handled) { + // Default: direct assignment to userData + // TODO: Support nested paths if needed (e.g. 'some.deep.prop') + if (path.includes('.')) { + // Simple dot notation support + const parts = path.split('.'); + let current = userData; + for (let i = 0; i < parts.length - 1; i++) { + current = current[parts[i]]; + if (!current) + return false; // Path doesn't exist + } + current[parts[parts.length - 1]] = value; + } + else { + userData[path] = value; + } + } + await Editor.Message.request('asset-db', 'save-asset-meta', assetInfo.uuid, JSON.stringify(meta)); + return true; + } + parseUserData(userData) { + const propertyContainer = {}; + texture_utils_1.TextureUtils.injectTextureProperties(userData, propertyContainer); + // Generate Mipmaps + propertyContainer.generateMipmaps = { + value: userData.mipfilter !== 'none', + type: 'Boolean', + displayName: 'Generate Mipmaps' + }; + return propertyContainer; + } +} +exports.TextureImporter = TextureImporter; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/inspector-utils.js b/extensions/cocos-code-mode/dist/utcp/utils/inspector-utils.js new file mode 100644 index 0000000..9a896e2 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/inspector-utils.js @@ -0,0 +1,57 @@ +"use strict"; +// Removed IInspectorProperty-related transformation methods. +/* +export class InspectorUtils { + + static localize(text: string | undefined): string | undefined { + if (!text) return text; + if (text.length === 0) return undefined; + if (text.startsWith('i18n:')) { + // @ts-ignore + return Editor.I18n.t(text.replace('i18n:', '')); + } + return text; + } + + static isPrimitiveType(type: string | undefined): boolean { + if (!type) return false; + return ['Number', 'Integer', 'String', 'Boolean', 'Enum', 'BitMask', 'Float', + 'cc.Vec2', 'cc.Vec3', 'cc.Vec4', 'cc.Color', 'cc.Size', 'cc.Rect', 'cc.Quat'].includes(type); + } + + static cleanResult(obj: any): any { + if (Array.isArray(obj)) { + return obj.map(v => this.cleanResult(v)); + } else if (obj !== null && typeof obj === 'object') { + const newObj: any = {}; + for (const key in obj) { + const val = this.cleanResult(obj[key]); + if (val !== undefined) { + newObj[key] = val; + } + } + return newObj; + } + return obj; + } + + static parsePropertySet(container: any, excludeKeys: string[] = [], simple: boolean = false, depth: number = 0): any { + if (!container) return {}; + const props: any = {}; + for (const key in container) { + if (excludeKeys.includes(key)) continue; + + const prop = container[key]; + if ('visible' in prop && !prop.visible) continue; + if (prop && typeof prop === 'object' && 'value' in prop) { + props[key] = prop.value; + } else { + props[key] = prop; + } + } + return props; + } +} + +*/ +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/texture-utils.js b/extensions/cocos-code-mode/dist/utcp/utils/texture-utils.js new file mode 100644 index 0000000..8003604 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/texture-utils.js @@ -0,0 +1,113 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TextureUtils = void 0; +class TextureUtils { + /** + * Applies synthetic texture properties (filterMode, wrapMode) to the user data. + * Returns true if the property was handled. + */ + static applyProperties(userData, path, value) { + if (path === 'filterMode') { + if (this.FilterModeMap[value]) { + Object.assign(userData, this.FilterModeMap[value]); + return true; + } + } + else if (path === 'wrapMode') { + if (this.WrapModeMap[value]) { + Object.assign(userData, this.WrapModeMap[value]); + return true; + } + } + return false; + } + /** + * Injects synthetic texture properties (filterMode, wrapMode) into the property container. + */ + static injectTextureProperties(userData, propertyContainer) { + // Filter Mode Logic + let filterMode = 'Advanced'; + for (const [mode, settings] of Object.entries(this.FilterModeMap)) { + if (userData.minfilter === settings.minfilter && + userData.magfilter === settings.magfilter && + userData.mipfilter === settings.mipfilter) { + filterMode = mode; + break; + } + } + propertyContainer.filterMode = { + value: filterMode, + type: 'Enum', + enumList: [...Object.keys(this.FilterModeMap), 'Advanced'].map(k => ({ name: k, value: k })), + displayName: 'Filter Mode', + }; + if (filterMode === 'Advanced') { + propertyContainer.minfilter = { + value: userData.minfilter, + type: 'Enum', + enumList: ['nearest', 'linear'].map(k => ({ name: k, value: k })), + displayName: 'Min Filter', + }; + propertyContainer.magfilter = { + value: userData.magfilter, + type: 'Enum', + enumList: ['nearest', 'linear'].map(k => ({ name: k, value: k })), + displayName: 'Mag Filter', + }; + propertyContainer.mipfilter = { + value: userData.mipfilter, + type: 'Enum', + enumList: ['none', 'nearest', 'linear'].map(k => ({ name: k, value: k })), + displayName: 'Mip Filter', + }; + } + // Wrap Mode Logic + let wrapMode = 'Advanced'; + for (const [mode, settings] of Object.entries(this.WrapModeMap)) { + if (userData.wrapModeS === settings.wrapModeS && + userData.wrapModeT === settings.wrapModeT) { + wrapMode = mode; + break; + } + } + propertyContainer.wrapMode = { + value: wrapMode, + type: 'Enum', + enumList: [...Object.keys(this.WrapModeMap), 'Advanced'].map(k => ({ name: k, value: k })), + displayName: 'Wrap Mode', + }; + if (wrapMode === 'Advanced') { + const wrapModes = ['repeat', 'clamp-to-edge', 'mirrored-repeat'].map(k => ({ name: k, value: k })); + propertyContainer.wrapModeS = { + value: userData.wrapModeS, + type: 'Enum', + enumList: wrapModes, + displayName: 'Wrap Mode S', + }; + propertyContainer.wrapModeT = { + value: userData.wrapModeT, + type: 'Enum', + enumList: wrapModes, + displayName: 'Wrap Mode T', + }; + } + propertyContainer.anisotropy = { + value: userData.anisotropy, + type: 'Number', + displayName: 'Anisotropy', + }; + } +} +exports.TextureUtils = TextureUtils; +TextureUtils.FilterModeMap = { + 'Nearest (None)': { minfilter: 'nearest', magfilter: 'nearest', mipfilter: 'none' }, + 'Bilinear': { minfilter: 'linear', magfilter: 'linear', mipfilter: 'none' }, + 'Bilinear with Mipmaps': { minfilter: 'linear', magfilter: 'linear', mipfilter: 'nearest' }, + 'Trilinear with Mipmaps': { minfilter: 'linear', magfilter: 'linear', mipfilter: 'linear' }, +}; +TextureUtils.WrapModeMap = { + 'Repeat': { wrapModeS: 'repeat', wrapModeT: 'repeat' }, + 'Clamp': { wrapModeS: 'clamp-to-edge', wrapModeT: 'clamp-to-edge' }, + 'Mirror': { wrapModeS: 'mirrored-repeat', wrapModeT: 'mirrored-repeat' }, +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"texture-utils.js","sourceRoot":"","sources":["../../../source/utcp/utils/texture-utils.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { IProperty } from '@cocos/creator-types/editor/packages/scene/@types/public';\n\nexport class TextureUtils {\n    static readonly FilterModeMap: Record<string, { minfilter: string; magfilter: string; mipfilter: string }> = {\n        'Nearest (None)': { minfilter: 'nearest', magfilter: 'nearest', mipfilter: 'none' },\n        'Bilinear': { minfilter: 'linear', magfilter: 'linear', mipfilter: 'none' },\n        'Bilinear with Mipmaps': { minfilter: 'linear', magfilter: 'linear', mipfilter: 'nearest' },\n        'Trilinear with Mipmaps': { minfilter: 'linear', magfilter: 'linear', mipfilter: 'linear' },\n    };\n\n    static readonly WrapModeMap: Record<string, { wrapModeS: string; wrapModeT: string }> = {\n        'Repeat': { wrapModeS: 'repeat', wrapModeT: 'repeat' },\n        'Clamp': { wrapModeS: 'clamp-to-edge', wrapModeT: 'clamp-to-edge' },\n        'Mirror': { wrapModeS: 'mirrored-repeat', wrapModeT: 'mirrored-repeat' },\n    };\n\n    /**\n     * Applies synthetic texture properties (filterMode, wrapMode) to the user data.\n     * Returns true if the property was handled.\n     */\n    static applyProperties(userData: any, path: string, value: any): boolean {\n        if (path === 'filterMode') {\n            if (this.FilterModeMap[value]) {\n                Object.assign(userData, this.FilterModeMap[value]);\n                return true;\n            }\n        } else if (path === 'wrapMode') {\n            if (this.WrapModeMap[value]) {\n                Object.assign(userData, this.WrapModeMap[value]);\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Injects synthetic texture properties (filterMode, wrapMode) into the property container.\n     */\n    static injectTextureProperties(userData: any, propertyContainer: { [key: string]: IProperty }): void {\n        // Filter Mode Logic\n        let filterMode = 'Advanced';\n        for (const [mode, settings] of Object.entries(this.FilterModeMap)) {\n            if (userData.minfilter === settings.minfilter &&\n                userData.magfilter === settings.magfilter &&\n                userData.mipfilter === settings.mipfilter) {\n                filterMode = mode;\n                break;\n            }\n        }\n\n        propertyContainer.filterMode = {\n            value: filterMode,\n            type: 'Enum',\n            enumList: [...Object.keys(this.FilterModeMap), 'Advanced'].map(k => ({ name: k, value: k })),\n            displayName: 'Filter Mode',\n        };\n\n        if (filterMode === 'Advanced') {\n            propertyContainer.minfilter = { \n                value: userData.minfilter, \n                type: 'Enum',\n                enumList: ['nearest', 'linear'].map(k => ({ name: k, value: k })),\n                displayName: 'Min Filter',\n            };\n            propertyContainer.magfilter = { \n                value: userData.magfilter, \n                type: 'Enum',\n                enumList: ['nearest', 'linear'].map(k => ({ name: k, value: k })),\n                displayName: 'Mag Filter',\n            };\n            propertyContainer.mipfilter = { \n                value: userData.mipfilter, \n                type: 'Enum',\n                enumList: ['none', 'nearest', 'linear'].map(k => ({ name: k, value: k })),\n                displayName: 'Mip Filter',\n            };\n        }\n\n        // Wrap Mode Logic\n        let wrapMode = 'Advanced';\n        for (const [mode, settings] of Object.entries(this.WrapModeMap)) {\n            if (userData.wrapModeS === settings.wrapModeS &&\n                userData.wrapModeT === settings.wrapModeT) {\n                wrapMode = mode;\n                break;\n            }\n        }\n\n        propertyContainer.wrapMode = {\n            value: wrapMode,\n            type: 'Enum',\n            enumList: [...Object.keys(this.WrapModeMap), 'Advanced'].map(k => ({ name: k, value: k })),\n            displayName: 'Wrap Mode',\n        };\n\n         if (wrapMode === 'Advanced') {\n            const wrapModes = ['repeat', 'clamp-to-edge', 'mirrored-repeat'].map(k => ({ name: k, value: k }));\n            propertyContainer.wrapModeS = { \n                value: userData.wrapModeS, \n                type: 'Enum',\n                enumList: wrapModes,\n                displayName: 'Wrap Mode S',\n            };\n            propertyContainer.wrapModeT = { \n                value: userData.wrapModeT, \n                type: 'Enum',\n                enumList: wrapModes,\n                displayName: 'Wrap Mode T',\n            };\n        }\n\n        propertyContainer.anisotropy = {\n            value: userData.anisotropy,\n            type: 'Number',\n            displayName: 'Anisotropy',\n        };\n    }\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/dist/utcp/utils/tools-utils.js b/extensions/cocos-code-mode/dist/utcp/utils/tools-utils.js new file mode 100644 index 0000000..5a20d17 --- /dev/null +++ b/extensions/cocos-code-mode/dist/utcp/utils/tools-utils.js @@ -0,0 +1,220 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ToolsUtils = void 0; +const asset_importers_1 = require("./asset-importers"); +class ToolsUtils { + static async inspectInstance(targetId, adaptNode = true) { + var _a, _b; + if (targetId === 'CurrentSceneGlobals') { + return this.inspectCurrentSceneSettings(); + } + if (targetId === 'ProjectSettings') { + return { + uuid: 'ProjectSettings', + type: 'ProjectSettings', + props: await ((_a = asset_importers_1.ImporterManager.getInstance().getImporter('project-settings')) === null || _a === void 0 ? void 0 : _a.getProperties({})) || null, + assetInfo: { uuid: 'ProjectSettings', type: 'ProjectSettings', importer: 'project-settings' } + }; + } + // Try Node + try { + const nodeDump = await Editor.Message.request('scene', 'query-node', targetId); + const props = this.convertDumpToProperties('node', nodeDump, adaptNode); + if (nodeDump) { + return { + uuid: targetId, + type: nodeDump.__type__ || 'cc.Node', + props: props, + assetInfo: null + }; + } + } + catch (e) { } + // Try Component + try { + const compDump = await Editor.Message.request('scene', 'query-component', targetId); + if (compDump) { + const props = this.convertDumpToProperties('component', compDump.value || compDump); + return { + uuid: targetId, + type: compDump.type || 'cc.Component', + props: props, + assetInfo: null + }; + } + } + catch (e) { } + // Try Asset + try { + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', targetId); + const props = assetInfo ? await ((_b = asset_importers_1.ImporterManager.getInstance().getImporter(assetInfo.importer)) === null || _b === void 0 ? void 0 : _b.getProperties(assetInfo)) : null; + if (assetInfo) { + return { + uuid: targetId, + type: assetInfo.type, + props: props || null, + assetInfo: assetInfo + }; + } + } + catch (e) { + console.warn('Failed to inspect asset:', e); + } + return null; + } + static async inspectCurrentSceneSettings() { + try { + const tree = await Editor.Message.request('scene', 'query-node-tree'); + if (!tree || !tree.uuid) { + return null; + } + const sceneDump = await Editor.Message.request('scene', 'query-node', tree.uuid); + if (sceneDump && sceneDump._globals) { + const props = this.convertDumpToProperties('component', sceneDump._globals); + return { + uuid: tree.uuid, + type: 'cc.SceneGlobals', + props: props, + assetInfo: null + }; + } + } + catch (e) { + console.warn('Failed to inspect CurrentSceneGlobals:', e); + } + return null; + } + static convertDumpToProperties(dumpType, dump, adaptNode = true) { + if (!dump) + return {}; + const result = {}; + if (typeof dump === 'object' && dump !== null) { + // Safe iteration for object + for (const key of Object.keys(dump)) { + const val = dump[key]; + if (val) { + result[key] = val; + } + } + } + switch (dumpType) { + // Specific adjustments for Node + case 'node': + if (!adaptNode) { + break; + } + // Adapt __comps__ to show component UUIDs only + if (!('__comps__' in result)) { + throw new Error(`Missing __comps__ property for Node class.`); + } + const compsMap = result.__comps__.map(comp => { return { value: { id: comp.value.uuid.value } }; }); + result['__comps__'] = { value: compsMap, extends: ['cc.Object'], type: 'cc.Component', isArray: true, tooltip: 'cc.Component is a basic type for component. Inspect specific component instance for it\'s definition. You can change actual instances properties via __comps__.i prefix of node' }; + if (!('children' in result)) { + throw new Error(`Missing children property for Node class.`); + } + result['children'] = { value: [], type: 'cc.Node', isArray: true, readonly: true }; + if (!('__type__' in result)) { + throw new Error(`Missing __type__ property for Node class.`); + } + result['__type__'] = { value: 'cc.Node', visible: false }; + break; + case 'component': + // Inspector hides 'enabled' property for Components, but we need it + if ('enabled' in result && result.enabled && + typeof result.enabled === 'object' && 'visible' in result.enabled) { + result.enabled.visible = true; + } + break; + } + return result; + } + static unwrapProperties(properties) { + const result = {}; + for (const [key, prop] of Object.entries(properties)) { + // Check if prop is null/undefined + if (prop === undefined || prop === null) { + result[key] = prop; + continue; + } + // Check if prop is IProperty (has value, type, default, etc) + if (typeof prop !== 'object') { + result[key] = prop; + continue; + } + // It is an object. Check if it looks like IProperty. + const p = prop; + let value = p.value; + // Skip invisible properties + if (p.visible === false) { + continue; + } + // If value is undefined, try default + if (value === undefined) { + value = p.default; + } + const isLikelyIProperty = 'type' in p || 'value' in p || 'default' in p || 'visible' in p; + if (!isLikelyIProperty) { + // It might be a nested object that is NOT wrapped (though rare in dump root) + if (Array.isArray(prop)) { + // Array of values? + result[key] = prop; + } + else { + // Nested object + result[key] = this.unwrapProperties(prop); + } + continue; + } + // Now 'value' holds the unwrapped value (or it's undefined/null). + // Recursive unpack if value is an object (nested IProperties) + if (value && typeof value === 'object') { + if (Array.isArray(value)) { + // Check if it's an array of IProperties + if (value.length > 0 && typeof value[0] === 'object' && value[0] && + ('type' in value[0] || 'value' in value[0] || 'default' in value[0])) { + // Recursively unwrap each element in the array + value = value.map((item) => { + // This item is efficiently an IProperty (or mostly likely). + let val = item.value; + if (val === undefined) + val = item.default; + // If it doesn't have value/default but is object, might be raw object? + if (val === undefined && !('type' in item)) + val = item; + // Verify deeply nested + if (val && typeof val === 'object' && !Array.isArray(val)) { + // We need to verify if 'val' keys point to IProperties. + const keys = Object.keys(val); + if (keys.length > 0) { + // Check first key + const firstChild = val[keys[0]]; + if (firstChild && typeof firstChild === 'object' && + ('type' in firstChild || 'value' in firstChild || 'default' in firstChild)) { + return this.unwrapProperties(val); + } + } + } + return val; + }); + } + } + else { + // Nested object (Struct). Check if it contains IProperties. + const keys = Object.keys(value); + if (keys.length > 0) { + const firstVal = value[keys[0]]; + if (firstVal && typeof firstVal === 'object' && + ('type' in firstVal || 'value' in firstVal || 'default' in firstVal)) { + // It is a struct where values are IProperties + value = this.unwrapProperties(value); + } + } + } + } + result[key] = value; + } + return result; + } +} +exports.ToolsUtils = ToolsUtils; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tools-utils.js","sourceRoot":"","sources":["../../../source/utcp/utils/tools-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { ImporterManager } from './asset-importers';\nimport { INode, IProperty, IPropertyValueType } from '@cocos/creator-types/editor/packages/scene/@types/public';\nimport { AssetInfo } from '@cocos/creator-types/editor/packages/asset-db/@types/public';\n\nexport class ToolsUtils {\n\n    static async inspectInstance(targetId: string, adaptNode: boolean = true): Promise<{ uuid: string, type: string, props: { [key: string]: IPropertyValueType } | null, assetInfo: AssetInfo | null } | null> {\n        if (targetId === 'CurrentSceneGlobals') {\n            return this.inspectCurrentSceneSettings();\n        }\n\n        if (targetId === 'ProjectSettings') {\n            return {\n                uuid: 'ProjectSettings',\n                type: 'ProjectSettings',\n                props: await ImporterManager.getInstance().getImporter('project-settings')?.getProperties({} as any) || null,\n                assetInfo: { uuid: 'ProjectSettings', type: 'ProjectSettings', importer: 'project-settings' } as any\n            };\n        }\n\n        // Try Node\n        try {\n            const nodeDump = await Editor.Message.request('scene', 'query-node', targetId);\n            const props = this.convertDumpToProperties('node', nodeDump, adaptNode);\n\n            if (nodeDump) {\n                return {\n                    uuid: targetId,\n                    type: nodeDump.__type__ || 'cc.Node',\n                    props: props,\n                    assetInfo: null\n                };\n            }\n        } catch (e) {}\n\n        // Try Component\n        try {\n            const compDump = await Editor.Message.request('scene', 'query-component', targetId);\n            if (compDump) {\n                const props = this.convertDumpToProperties('component', compDump.value || compDump);\n\n                return {\n                    uuid: targetId,\n                    type: compDump.type || 'cc.Component',\n                    props: props,\n                    assetInfo: null\n                };\n            }\n        } catch (e) {}\n        \n        // Try Asset\n        try {\n             const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', targetId);\n             const props = assetInfo ? await ImporterManager.getInstance().getImporter(assetInfo.importer)?.getProperties(assetInfo) : null;\n             if (assetInfo) {\n                 return {\n                     uuid: targetId,\n                     type: assetInfo.type, \n                     props: props || null,\n                     assetInfo: assetInfo\n                 };\n             }\n        } catch (e) { console.warn('Failed to inspect asset:', e); }\n\n        return null; \n    }\n\n    private static async inspectCurrentSceneSettings(): Promise<{ uuid: string, type: string, props: { [key: string]: IPropertyValueType } | null, assetInfo: AssetInfo | null } | null> {\n        try {\n            const tree = await Editor.Message.request('scene', 'query-node-tree') as any;\n            if (!tree || !tree.uuid) {\n                 return null;\n            }\n\n            const sceneDump = await Editor.Message.request('scene', 'query-node', tree.uuid) as any;\n            \n            if (sceneDump && sceneDump._globals) {\n                 const props = this.convertDumpToProperties('component', sceneDump._globals);\n                 return {\n                     uuid: tree.uuid,\n                     type: 'cc.SceneGlobals',\n                     props: props,\n                     assetInfo: null\n                 };\n            }\n        } catch (e) {\n            console.warn('Failed to inspect CurrentSceneGlobals:', e);\n        }\n        return null;\n    }\n\n    private static convertDumpToProperties(dumpType: \"node\" | \"component\", dump: INode | IPropertyValueType | { [key: string]: IPropertyValueType; } | null, adaptNode: boolean = true): { [key: string]: IPropertyValueType } {\n        if (!dump) return {};\n        \n        const result: { [key: string]: IPropertyValueType } = {};\n        if (typeof dump === 'object' && dump !== null) {\n             // Safe iteration for object\n             for (const key of Object.keys(dump)) {\n                 const val = (dump as any)[key];\n                 if (val) {\n                     result[key] = val;\n                 }\n             }\n        }\n\n        switch (dumpType) {\n            // Specific adjustments for Node\n            case 'node':\n                if (!adaptNode) {\n                    break;\n                }\n                \n                // Adapt __comps__ to show component UUIDs only\n                if (!('__comps__' in result)) {\n                    throw new Error(`Missing __comps__ property for Node class.`);\n                }\n                const compsMap = (result.__comps__ as IProperty[]).map(comp => { return { value: { id: (comp.value as any).uuid.value } }});\n                result['__comps__'] = { value: compsMap, extends: ['cc.Object'], type: 'cc.Component', isArray: true, tooltip: 'cc.Component is a basic type for component. Inspect specific component instance for it\\'s definition. You can change actual instances properties via __comps__.i prefix of node' };\n\n                if (!('children' in result)) {\n                    throw new Error(`Missing children property for Node class.`);\n                }\n                result['children'] = { value: [], type: 'cc.Node', isArray: true, readonly: true };\n                \n                if (!('__type__' in result)) {\n                    throw new Error(`Missing __type__ property for Node class.`);\n                }\n                result['__type__'] = { value: 'cc.Node', visible: false };\n                break;\n                \n            case 'component':\n                // Inspector hides 'enabled' property for Components, but we need it\n                if ('enabled' in result && result.enabled &&\n                    typeof result.enabled === 'object' && 'visible' in result.enabled) {\n                    result.enabled.visible = true;\n                }\n            break;\n        }\n\n        return result;\n    }\n\n    public static unwrapProperties(properties: { [key: string]: IPropertyValueType }): any {\n        const result: any = {};\n        \n        for (const [key, prop] of Object.entries(properties)) {\n            // Check if prop is null/undefined\n            if (prop === undefined || prop === null) {\n                result[key] = prop;\n                continue;\n            }\n\n            // Check if prop is IProperty (has value, type, default, etc)\n            if (typeof prop !== 'object') {\n                 result[key] = prop;\n                 continue;\n            }\n\n            // It is an object. Check if it looks like IProperty.\n            const p = prop as IProperty;\n            let value = p.value;\n\n            // Skip invisible properties\n            if (p.visible === false) {\n                continue;\n            }\n            \n            // If value is undefined, try default\n            if (value === undefined) {\n                value = p.default;\n            }\n\n            const isLikelyIProperty = 'type' in p || 'value' in p || 'default' in p || 'visible' in p;\n            \n            if (!isLikelyIProperty) {\n                 // It might be a nested object that is NOT wrapped (though rare in dump root)\n                 if (Array.isArray(prop)) {\n                     // Array of values?\n                     result[key] = prop; \n                 } else {\n                     // Nested object\n                     result[key] = this.unwrapProperties(prop as any);\n                 }\n                 continue;\n            }\n\n            // Now 'value' holds the unwrapped value (or it's undefined/null).\n            \n            // Recursive unpack if value is an object (nested IProperties)\n            if (value && typeof value === 'object') {\n                if (Array.isArray(value)) {\n                     // Check if it's an array of IProperties\n                     if (value.length > 0 && typeof value[0] === 'object' && value[0] &&\n                         ('type' in value[0] || 'value' in value[0] || 'default' in value[0])) {\n                         \n                         // Recursively unwrap each element in the array\n                         value = value.map((item: any) => {\n                             // This item is efficiently an IProperty (or mostly likely).\n                             let val = item.value;\n                             if (val === undefined) val = item.default;\n                             \n                             // If it doesn't have value/default but is object, might be raw object? \n                             if (val === undefined && !('type' in item)) val = item;\n\n                             // Verify deeply nested\n                             if (val && typeof val === 'object' && !Array.isArray(val)) {\n                                  // We need to verify if 'val' keys point to IProperties.\n                                  const keys = Object.keys(val);\n                                  if (keys.length > 0) {\n                                      // Check first key\n                                      const firstChild = val[keys[0]];\n                                      if (firstChild && typeof firstChild === 'object' && \n                                         ('type' in firstChild || 'value' in firstChild || 'default' in firstChild)) {\n                                          return this.unwrapProperties(val);\n                                      }\n                                  }\n                             }\n                             return val;\n                         });\n                     }\n                } else {\n                     // Nested object (Struct). Check if it contains IProperties.\n                     const keys = Object.keys(value);\n                     if (keys.length > 0) {\n                         const firstVal = (value as any)[keys[0]];\n                         if (firstVal && typeof firstVal === 'object' && \n                            ('type' in firstVal || 'value' in firstVal || 'default' in firstVal)) {\n                             // It is a struct where values are IProperties\n                             value = this.unwrapProperties(value as any);\n                         }\n                     }\n                }\n            }\n\n            result[key] = value;\n        }\n        return result;\n    }\n/*\n    static resolvePropertyPath(data: any, path: string): any {\n        if (!path || !data) return data;\n        \n        let current = data;\n        \n        const parts = path.split('.');\n        \n        for (const part of parts) {\n            if (current === null || current === undefined) return undefined;\n\n            if (typeof current === 'object' && current !== null) {\n                 if (Array.isArray(current)) {\n                     const idx = parseInt(part);\n                     if (!isNaN(idx) && current[idx] !== undefined) {\n                         current = current[idx];\n                         continue;\n                     }\n                 }\n                 if (part in current) {\n                     current = current[part];\n                     continue;\n                 }\n            }\n            \n            return undefined;\n        }\n\n        return current;\n    }\n        */\n}\n"]} \ No newline at end of file diff --git a/extensions/cocos-code-mode/i18n/en.js b/extensions/cocos-code-mode/i18n/en.js new file mode 100644 index 0000000..5419b48 --- /dev/null +++ b/extensions/cocos-code-mode/i18n/en.js @@ -0,0 +1 @@ +"use strict"; module.exports = { open_panel: "Configuration", description: "Cocos Creator MCP Integration for AI Code Mode" }; \ No newline at end of file diff --git a/extensions/cocos-code-mode/i18n/zh.js b/extensions/cocos-code-mode/i18n/zh.js new file mode 100644 index 0000000..f6aaa91 --- /dev/null +++ b/extensions/cocos-code-mode/i18n/zh.js @@ -0,0 +1 @@ +"use strict"; module.exports = { open_panel: "配置", description: "Cocos Creator MCP Integration for AI Code Mode" }; \ No newline at end of file diff --git a/extensions/cocos-code-mode/package-lock.json b/extensions/cocos-code-mode/package-lock.json new file mode 100644 index 0000000..7cd0714 --- /dev/null +++ b/extensions/cocos-code-mode/package-lock.json @@ -0,0 +1,1374 @@ +{ + "name": "cocos-code-mode", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "cocos-code-mode", + "version": "1.0.0", + "hasInstallScript": true, + "dependencies": { + "@types/sharp": "^0.31.1", + "@utcp/http": "^1.1.0", + "@utcp/sdk": "^1.1.0", + "cors": "^2.8.6", + "express": "^5.2.1", + "fs-extra": "^10.0.0", + "sharp": "^0.34.5", + "zod": "^4.2.1" + }, + "devDependencies": { + "@cocos/creator-types": "^3.8.7", + "@types/cors": "^2.8.19", + "@types/express": "^5.0.6", + "@types/fs-extra": "^9.0.5", + "@types/node": "^18.17.1", + "typescript": "^5.8.2" + } + }, + "node_modules/@cocos/creator-types": { + "version": "3.8.7", + "resolved": "https://registry.npmjs.org/@cocos/creator-types/-/creator-types-3.8.7.tgz", + "integrity": "sha512-QTtuC+w1s1yQ8DPlgFSiIGS+Pko6v2QdrrQRN8/SttEBo53JjyXEWHXpRkg1lGiHq0u/aadm0cN/Y4jtEmis/w==", + "dev": true, + "license": "ISC" + }, + "node_modules/@img/colour": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.0.0.tgz", + "integrity": "sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw==", + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/@img/sharp-darwin-arm64": { + "version": "0.34.5", + "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.34.5.tgz", + "integrity": "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==", + "cpu": [ + "arm64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-darwin-arm64": "1.2.4" + } + }, + "node_modules/@img/sharp-libvips-darwin-arm64": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.2.4.tgz", + "integrity": "sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==", + "cpu": [ + "arm64" + ], + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "darwin" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@types/body-parser": { + "version": "1.19.6", + "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz", + "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/connect": "*", + "@types/node": "*" + } + }, + "node_modules/@types/connect": { + "version": "3.4.38", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz", + "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/cors": { + "version": "2.8.19", + "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz", + "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/express": { + "version": "5.0.6", + "resolved": "https://registry.npmjs.org/@types/express/-/express-5.0.6.tgz", + "integrity": "sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/body-parser": "*", + "@types/express-serve-static-core": "^5.0.0", + "@types/serve-static": "^2" + } + }, + "node_modules/@types/express-serve-static-core": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.1.1.tgz", + "integrity": "sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*", + "@types/qs": "*", + "@types/range-parser": "*", + "@types/send": "*" + } + }, + "node_modules/@types/fs-extra": { + "version": "9.0.13", + "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz", + "integrity": "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/http-errors": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz", + "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "18.19.130", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz", + "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==", + "license": "MIT", + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/@types/qs": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.14.0.tgz", + "integrity": "sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/range-parser": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz", + "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/send": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@types/send/-/send-1.2.1.tgz", + "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/serve-static": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-2.2.0.tgz", + "integrity": "sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/http-errors": "*", + "@types/node": "*" + } + }, + "node_modules/@types/sharp": { + "version": "0.31.1", + "resolved": "https://registry.npmjs.org/@types/sharp/-/sharp-0.31.1.tgz", + "integrity": "sha512-5nWwamN9ZFHXaYEincMSuza8nNfOof8nmO+mcI+Agx1uMUk4/pQnNIcix+9rLPXzKrm1pS34+6WRDbDV0Jn7ag==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@utcp/http": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@utcp/http/-/http-1.1.0.tgz", + "integrity": "sha512-+B1OOxstnC39e3nx8jgaFGoO1KZIwFLjYPfKz1t+OX/tfpE01tsLoErZ5yI3dc4JHdTV3AwK+LTmFnFpspFZBA==", + "license": "MPL-2.0", + "dependencies": { + "@utcp/sdk": "^1.1.0", + "axios": "^1.11.0", + "js-yaml": "^4.1.0" + } + }, + "node_modules/@utcp/sdk": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@utcp/sdk/-/sdk-1.1.0.tgz", + "integrity": "sha512-JyNG+TdtoaZ19K2v+FSmRzi3YR3Ri0XVI7ntiz8pKDA9ZbNqa5+op2EAmmGIHD9sp0IyTI7pMHeUR+mYqd97PA==", + "license": "MPL-2.0", + "dependencies": { + "dotenv": "^17.2.1", + "zod": "^3.23.8" + } + }, + "node_modules/@utcp/sdk/node_modules/zod": { + "version": "3.25.76", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz", + "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/accepts": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", + "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==", + "license": "MIT", + "dependencies": { + "mime-types": "^3.0.0", + "negotiator": "^1.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "license": "Python-2.0" + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "license": "MIT" + }, + "node_modules/axios": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.4.tgz", + "integrity": "sha512-1wVkUaAO6WyaYtCkcYCOx12ZgpGf9Zif+qXa4n+oYzK558YryKqiL6UWwd5DqiH3VRW0GYhTZQ/vlgJrCoNQlg==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.15.6", + "form-data": "^4.0.4", + "proxy-from-env": "^1.1.0" + } + }, + "node_modules/body-parser": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.2.tgz", + "integrity": "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==", + "license": "MIT", + "dependencies": { + "bytes": "^3.1.2", + "content-type": "^1.0.5", + "debug": "^4.4.3", + "http-errors": "^2.0.0", + "iconv-lite": "^0.7.0", + "on-finished": "^2.4.1", + "qs": "^6.14.1", + "raw-body": "^3.0.1", + "type-is": "^2.0.1" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/content-disposition": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.1.tgz", + "integrity": "sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", + "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", + "license": "MIT", + "engines": { + "node": ">=6.6.0" + } + }, + "node_modules/cors": { + "version": "2.8.6", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz", + "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==", + "license": "MIT", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "engines": { + "node": ">= 0.10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/dotenv": { + "version": "17.2.3", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.2.3.tgz", + "integrity": "sha512-JVUnt+DUIzu87TABbhPmNfVdBDt18BLOWjMUFJMSi/Qqg7NTYtabbvSNJGOJ7afbRuv9D/lngizHtP7QyLQ+9w==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://dotenvx.com" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/express": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", + "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", + "license": "MIT", + "dependencies": { + "accepts": "^2.0.0", + "body-parser": "^2.2.1", + "content-disposition": "^1.0.0", + "content-type": "^1.0.5", + "cookie": "^0.7.1", + "cookie-signature": "^1.2.1", + "debug": "^4.4.0", + "depd": "^2.0.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "finalhandler": "^2.1.0", + "fresh": "^2.0.0", + "http-errors": "^2.0.0", + "merge-descriptors": "^2.0.0", + "mime-types": "^3.0.0", + "on-finished": "^2.4.1", + "once": "^1.4.0", + "parseurl": "^1.3.3", + "proxy-addr": "^2.0.7", + "qs": "^6.14.0", + "range-parser": "^1.2.1", + "router": "^2.2.0", + "send": "^1.1.0", + "serve-static": "^2.2.0", + "statuses": "^2.0.1", + "type-is": "^2.0.1", + "vary": "^1.1.2" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/finalhandler": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz", + "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "on-finished": "^2.4.1", + "parseurl": "^1.3.3", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/follow-redirects": { + "version": "1.15.11", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz", + "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/form-data": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz", + "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/form-data/node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/form-data/node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz", + "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "license": "ISC" + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/iconv-lite": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz", + "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-promise": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz", + "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz", + "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/merge-descriptors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz", + "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mime-db": { + "version": "1.54.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", + "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz", + "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==", + "license": "MIT", + "dependencies": { + "mime-db": "^1.54.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", + "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-to-regexp": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.3.0.tgz", + "integrity": "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/proxy-from-env": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", + "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", + "license": "MIT" + }, + "node_modules/qs": { + "version": "6.14.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz", + "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz", + "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.7.0", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/router": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz", + "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "depd": "^2.0.0", + "is-promise": "^4.0.0", + "parseurl": "^1.3.3", + "path-to-regexp": "^8.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/semver": { + "version": "7.7.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", + "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/send": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz", + "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.3", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "fresh": "^2.0.0", + "http-errors": "^2.0.1", + "mime-types": "^3.0.2", + "ms": "^2.1.3", + "on-finished": "^2.4.1", + "range-parser": "^1.2.1", + "statuses": "^2.0.2" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/serve-static": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz", + "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==", + "license": "MIT", + "dependencies": { + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "parseurl": "^1.3.3", + "send": "^1.2.0" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/sharp": { + "version": "0.34.5", + "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.34.5.tgz", + "integrity": "sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@img/colour": "^1.0.0", + "detect-libc": "^2.1.2", + "semver": "^7.7.3" + }, + "engines": { + "node": "^18.17.0 || ^20.3.0 || >=21.0.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-darwin-arm64": "0.34.5", + "@img/sharp-darwin-x64": "0.34.5", + "@img/sharp-libvips-darwin-arm64": "1.2.4", + "@img/sharp-libvips-darwin-x64": "1.2.4", + "@img/sharp-libvips-linux-arm": "1.2.4", + "@img/sharp-libvips-linux-arm64": "1.2.4", + "@img/sharp-libvips-linux-ppc64": "1.2.4", + "@img/sharp-libvips-linux-riscv64": "1.2.4", + "@img/sharp-libvips-linux-s390x": "1.2.4", + "@img/sharp-libvips-linux-x64": "1.2.4", + "@img/sharp-libvips-linuxmusl-arm64": "1.2.4", + "@img/sharp-libvips-linuxmusl-x64": "1.2.4", + "@img/sharp-linux-arm": "0.34.5", + "@img/sharp-linux-arm64": "0.34.5", + "@img/sharp-linux-ppc64": "0.34.5", + "@img/sharp-linux-riscv64": "0.34.5", + "@img/sharp-linux-s390x": "0.34.5", + "@img/sharp-linux-x64": "0.34.5", + "@img/sharp-linuxmusl-arm64": "0.34.5", + "@img/sharp-linuxmusl-x64": "0.34.5", + "@img/sharp-wasm32": "0.34.5", + "@img/sharp-win32-arm64": "0.34.5", + "@img/sharp-win32-ia32": "0.34.5", + "@img/sharp-win32-x64": "0.34.5" + } + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/type-is": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz", + "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==", + "license": "MIT", + "dependencies": { + "content-type": "^1.0.5", + "media-typer": "^1.1.0", + "mime-types": "^3.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "license": "MIT" + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/zod": { + "version": "4.3.6", + "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz", + "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + } + } +} diff --git a/extensions/cocos-code-mode/package.json b/extensions/cocos-code-mode/package.json new file mode 100644 index 0000000..4c5661e --- /dev/null +++ b/extensions/cocos-code-mode/package.json @@ -0,0 +1,100 @@ +{ + "$schema": "./@types/schema/package/index.json", + "package_version": 2, + "name": "cocos-code-mode", + "version": "1.0.0", + "author": "Roman Rogov", + "editor": ">=3.8.7", + "scripts": { + "preinstall": "node ./scripts/preinstall.js", + "build": "npx tsc", + "package": "npm run build && node ./scripts/package.js" + }, + "description": "i18n:cocos-code-mode.description", + "main": "./dist/main.js", + "dependencies": { + "@types/sharp": "^0.31.1", + "@utcp/http": "^1.1.0", + "@utcp/sdk": "^1.1.0", + "cors": "^2.8.6", + "express": "^5.2.1", + "fs-extra": "^10.0.0", + "sharp": "^0.34.5", + "zod": "^4.2.1" + }, + "devDependencies": { + "@cocos/creator-types": "^3.8.7", + "@types/cors": "^2.8.19", + "@types/express": "^5.0.6", + "@types/fs-extra": "^9.0.5", + "@types/node": "^18.17.1", + "typescript": "^5.8.2" + }, + "panels": { + "configuration": { + "title": "Configuration", + "type": "dockable", + "main": "dist/panels/configuration", + "size": { + "min-width": 400, + "min-height": 300, + "width": 1024, + "height": 600 + } + }, + "preview": { + "title": "Asset Preview", + "type": "dockable", + "main": "dist/panels/preview", + "size": { + "min-width": 200, + "min-height": 200, + "width": 400, + "height": 400 + } + } + }, + "contributions": { + "scene": { + "script": "./dist/scene.js" + }, + "menu": [ + { + "path": "Code Mode", + "label": "i18n:cocos-code-mode.open_panel", + "message": "open-panel" + } + ], + "messages": { + "open-panel": { + "methods": [ + "openPanel" + ] + }, + "open-preview-panel": { + "methods": [ + "openPreviewPanel" + ] + }, + "preview-asset": { + "methods": [ + "preview.previewAsset" + ] + }, + "generate-preview": { + "methods": [ + "preview.generatePreview" + ] + }, + "restart-server": { + "methods": [ + "restartServer" + ] + } + } + }, + "creator": { + "version": "3.8.7" + }, + "uuid": "b401b190-c2a1-4149-9250-a0ed22e1968b" +} \ No newline at end of file diff --git a/extensions/cocos-code-mode/static/style/configuration/index.css b/extensions/cocos-code-mode/static/style/configuration/index.css new file mode 100644 index 0000000..23523dc --- /dev/null +++ b/extensions/cocos-code-mode/static/style/configuration/index.css @@ -0,0 +1,104 @@ +.panel { + display: flex; + flex-direction: column; + height: 100%; + padding: 10px; + gap: 10px; + overflow-y: auto; +} + +ui-prop-split { + --ui-prop-margin-left: 24px; + --ui-prop-label-width-min: 60px; + --ui-prop-label-width-max: 289px; + --left-width: 38.2%; +} + +.section { + margin-bottom: 10px; +} + +.desc-container { + padding: 5px 10px; + color: var(--color-text-normal); + opacity: 0.8; + margin-bottom: 5px; +} + +.code-container { + margin-top: 5px; +} + +.list-container { + padding: 0; + max-height: 400px; + overflow-y: auto; + margin-bottom: 15px; +} + +.bridge-item-section { + margin-bottom: 5px; + border: 1px solid var(--color-normal-border-weak); + border-radius: 4px; + overflow: hidden; +} + +.bridge-item-content { + padding: 10px; + background: var(--color-normal-fill-calmer); +} + +.bridge-actions { + display: flex; + justify-content: flex-end; + margin-top: 5px; +} + +.actions.right { + display: flex; + justify-content: flex-end; + margin-top: 5px; +} + +ui-button.blue { + color: white; +} + +ui-button.green { + color: white; +} + +ui-prop { + margin-top: 10px; +} + +.transparent { + background: transparent; + border: none; +} + +.group-header { + font-weight: bold; + color: var(--color-text-normal); + margin-bottom: 5px; + margin-top: 10px; + padding-left: 5px; +} + +.mt-10 { + margin-top: 10px; +} + +.add-template-container { + padding: 0 5px; +} + +ui-prop ui-button { + margin-left: 10px; +} + +#save-utcp-path-btn { + max-width: 24px; + padding: 0 4px; + height: 24px; +} \ No newline at end of file diff --git a/extensions/cocos-code-mode/static/style/preview/index.css b/extensions/cocos-code-mode/static/style/preview/index.css new file mode 100644 index 0000000..05f32f6 --- /dev/null +++ b/extensions/cocos-code-mode/static/style/preview/index.css @@ -0,0 +1,15 @@ +.panel { + display: flex; + flex-direction: column; + height: 100%; + width: 100%; + background-color: #252526; +} + +#preview-container { + flex: 1; + position: relative; + overflow: hidden; + width: 100%; + height: 100%; +} diff --git a/extensions/cocos-code-mode/static/template/configuration/index.html b/extensions/cocos-code-mode/static/template/configuration/index.html new file mode 100644 index 0000000..be588ab --- /dev/null +++ b/extensions/cocos-code-mode/static/template/configuration/index.html @@ -0,0 +1,48 @@ + + + + + + Server Port + + Update + + + + + + + Config Path + + + + +
Bridge Templates
+
+ +
+ +
Add New Template
+
+ +
+ + Add Template + +
+
+ + + + +
+ Configure your AI agent by adding this server to MCP config + config. Config example: +
+
+ +
+ + + \ No newline at end of file diff --git a/extensions/cocos-code-mode/static/template/preview/index.html b/extensions/cocos-code-mode/static/template/preview/index.html new file mode 100644 index 0000000..5d9c71a --- /dev/null +++ b/extensions/cocos-code-mode/static/template/preview/index.html @@ -0,0 +1,3 @@ +
+
+