@lcap/nasl 4.4.0-beta.3 → 4.4.0-beta.30

package/out/natural/exports/transform2BatchActions.js

@@ -0,0 +1,1233 @@
+"use strict";
+/**
+ *
+ * 这个模块的主要功能是将多个代码文件操作（创建、更新、删除）转换为统一的nasl批量操作格式，
+ *
+ * 主要处理流程：
+ * 1. 解析codeAction 的路径，提取命名空间和项目类型信息
+ * 2. 将代码内容包装在适当的命名空间中
+ * 3. 使用 parseNaturalTS 解析 TypeScript 代码为 NASL 对象
+ * 4. 为每种类型（entity、structure、enum、logic、view）提供统一的操作接口
+ * 5. 生成批量操作数组，支持创建、更新和删除操作
+ * 6. 处理操作过程中的错误并提供调试信息
+ *
+ * 目前支持的类型：
+ * - entity: 数据实体
+ * - structure: 数据结构
+ * - enum: 枚举类型
+ * - logic: 业务逻辑
+ * - view: 视图组件
+ * - backendVariables: 后端变量
+ * - frontendVariables: 前端类型变量
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyBatchActions = exports.transform2BatchActions = exports.generateRouterContainerTemplate = void 0;
+const uuid_1 = require("uuid");
+const concepts_1 = require("../../concepts");
+const index_1 = require("../../index");
+const utils_1 = require("../../utils");
+const nasl_file_types_1 = require("../utils/nasl-file-types");
+/**
+ * 检查项目类型是否允许空名称
+ */
+const isNameOptional = (itemType) => {
+    return ['backendVariables', 'frontendVariables', 'theme'].includes(itemType);
+};
+/**
+ * 生成空的路由容器模板
+ * 用于为嵌套视图创建父级容器视图
+ * @param params - 包含视图名称、标题和命名空间的参数
+ * @returns 生成的路由容器模板代码
+ */
+const generateRouterContainerTemplate = (params) => {
+    const { viewName, title, namespace } = params;
+    return `
+namespace ${namespace} {
+      $View({
+        title: "${title}",
+        crumb: '',
+        auth: false,
+        isIndex: true,
+    })
+    export function ${viewName}() {
+        return <ElRouterView />
+    }
+}`;
+};
+exports.generateRouterContainerTemplate = generateRouterContainerTemplate;
+/**
+ * 根据命名空间获取项目类型
+ * @param namespace - 命名空间字符串
+ * @returns 项目类型，如果无法识别则返回 'unknown'
+ */
+const getItemType = (namespace) => {
+    if (namespace.includes('entities'))
+        return 'entity';
+    if (namespace.includes('structures'))
+        return 'structure';
+    if (namespace.includes('enums'))
+        return 'enum';
+    if (namespace.includes('logics'))
+        return 'logic';
+    if (namespace.includes('views'))
+        return 'view';
+    if (namespace.includes('extensions'))
+        return 'extensions';
+    if (namespace.includes('app.backend.variables'))
+        return 'backendVariables';
+    if (namespace.includes('theme.css'))
+        return 'theme';
+    if (/app\.frontendTypes\.[^.]+\.frontends\.[^.]+\.variables/.test(namespace))
+        return 'frontendVariables';
+    return 'unknown';
+};
+/**
+ * 解析视图路径，提取视图名称和命名空间
+ * @param path - 视图路径，例如: 'src/app.frontendTypes.pc.frontends.pc.views.aaa.tsx'
+ * @returns 包含视图名称、命名空间和完整路径的对象
+ */
+const parseViewPath = (path) => {
+    // 移除 src/ 前缀和 .tsx 后缀
+    const cleanPath = path.replace(/^src\//, '').replace(/\.tsx$/, '');
+    // 提取最后一个部分作为视图名称
+    const lastDotIndex = cleanPath.lastIndexOf('.');
+    const viewName = lastDotIndex !== -1 ? cleanPath.substring(lastDotIndex + 1) : cleanPath;
+    const namespace = lastDotIndex !== -1 ? cleanPath.substring(0, lastDotIndex) : '';
+    return {
+        viewName,
+        namespace,
+        fullPath: path,
+    };
+};
+/**
+ * 提取嵌套视图路径的所有父级路径信息
+ * @param path - 视图路径，例如: 'src/app.frontendTypes.pc.frontends.pc.views.aaa.views.bbb.views.ccc.tsx'
+ * @returns 父级路径信息数组，例如: [{ viewName: 'aaa', namespace: '...', fullPath: '...' }, ...]
+ */
+const extractParentViewPaths = (path) => {
+    const parentInfos = [];
+    // 检查是否是嵌套视图路径（至少包含两个 .views.）
+    const viewsMatches = path.match(/\.views\./g);
+    if (!viewsMatches || viewsMatches.length < 2) {
+        return parentInfos;
+    }
+    // 提取 views 部分: src/app.frontendTypes.pc.frontends.pc.views.aaa.views.bbb.views.ccc.tsx
+    // -> aaa.views.bbb.views.ccc
+    const regex = /src\/app\.frontendTypes\.pc\.frontends\.pc\.views\.(.*?)\.tsx$/;
+    const match = path.match(regex);
+    if (!match)
+        return parentInfos;
+    const viewPath = match[1]; // 例如: aaa.views.bbb.views.ccc
+    const parts = viewPath.split('.views.'); // ['aaa', 'bbb', 'ccc']
+    // 构建所有父级路径信息（不包括当前路径本身）
+    for (let i = 0; i < parts.length - 1; i++) {
+        const pathParts = parts.slice(0, i + 1);
+        const parentPath = `src/app.frontendTypes.pc.frontends.pc.views.${pathParts.join('.views.')}.tsx`;
+        parentInfos.push(parseViewPath(parentPath));
+    }
+    return parentInfos;
+};
+/**
+ * 构建嵌套视图的路径
+ * @param parentViewNames - 父级视图名称数组，例如: ['dashboard', 'teamLeader']
+ * @param viewName - 当前视图名称，例如: 'teamLeaveStatistics'
+ * @returns 构建的路径，例如: 'app.frontendTypes[name=pc].frontends[name=pc].views[name=dashboard].children[name=teamLeader].children[name=teamLeaveStatistics]'
+ */
+const buildNestedViewPath = (parentViewNames, viewName) => {
+    // 基础路径常量
+    const basePath = 'app.frontendTypes[name=pc].frontends[name=pc].views';
+    if (!parentViewNames || parentViewNames.length === 0) {
+        // 如果没有父级，返回顶级视图路径
+        return `${basePath}[name=${viewName}]`;
+    }
+    // 使用数组拼接优化字符串构建性能
+    const pathParts = [`${basePath}[name=${parentViewNames[0]}]`];
+    // 添加后续的父级视图（使用 children）
+    for (let i = 1; i < parentViewNames.length; i++) {
+        pathParts.push(`children[name=${parentViewNames[i]}]`);
+    }
+    // 添加当前视图
+    pathParts.push(`children[name=${viewName}]`);
+    return pathParts.join('.');
+};
+/**
+ * 创建视图查找函数
+ * 统一处理顶级视图和嵌套视图的查找逻辑
+ * @param instance - 应用实例（appInstance 或 app）
+ * @param name - 视图名称
+ * @param parentViewNames - 可选的父级视图名称数组
+ * @returns 找到的视图节点或 undefined
+ */
+const createViewFinder = (instance) => (name, parentViewNames = []) => {
+    // if (parentViewNames && parentViewNames.length > 0) {
+    //   // 对于嵌套视图，使用路径查找
+    // }
+    const viewPath = buildNestedViewPath(parentViewNames, name);
+    return instance?.findNodeByPath(viewPath);
+    // 顶级视图使用 findViewByName
+    // return instance?.frontendTypes?.[0]?.frontends?.[0]?.findViewByName(name);
+};
+/**
+ * 类型守卫：判断是否为单节点处理器
+ */
+const isSingleNodeHandler = (handler) => {
+    return ['entity', 'structure', 'enum', 'logic'].includes(handler.type);
+};
+/**
+ * 类型守卫：判断是否为视图处理器
+ */
+const isViewHandler = (handler) => {
+    return handler.type === 'view';
+};
+/**
+ * 类型守卫：判断是否为全局变量处理器
+ */
+const isGlobalVariablesHandler = (handler) => {
+    return ['backendVariables', 'frontendVariables'].includes(handler.type);
+};
+/**
+ * 类型守卫：判断是否为主题处理器
+ */
+const isThemeHandler = (handler) => {
+    return handler.type === 'theme';
+};
+/**
+ * 创建不同类型处理器的工厂函数
+ * 为每种类型（entity、structure、enum、logic、view、backendVariables、frontendVariables）提供统一的操作接口
+ * @param appInstance - 解析后的应用实例，用于查找新创建的对象
+ * @param app - 目前已有的应用实例，用于查找已存在的对象和添加新对象
+ * @returns 包含各种类型处理器的对象
+ */
+const createTypeHandlers = (appInstance, app) => ({
+    entity: {
+        type: 'entity',
+        /** 实体在应用中的路径模板 */
+        path: 'app.dataSources[name=defaultDS].entities[0]',
+        /** 从解析实例中查找实体的方法 */
+        findMethod: (name) => appInstance?.dataSources?.[0]?.findEntityByName(name),
+        /** 从目标应用中查找已存在实体的方法 */
+        findExisting: (name) => app.dataSources?.[0]?.findEntityByName(name),
+    },
+    structure: {
+        type: 'structure',
+        /** 结构体在应用中的路径模板 */
+        path: 'app.structures[0]',
+        /** 从解析实例中查找结构体的方法 */
+        findMethod: (name) => appInstance?.findStructureByName(name),
+        /** 从目标应用中查找已存在结构体的方法 */
+        findExisting: (name) => app.findStructureByName(name),
+    },
+    enum: {
+        type: 'enum',
+        /** 枚举在应用中的路径模板 */
+        path: 'app.enums[0]',
+        /** 从解析实例中查找枚举的方法 */
+        findMethod: (name) => appInstance?.findEnumByName(name),
+        /** 从目标应用中查找已存在枚举的方法 */
+        findExisting: (name) => app.findEnumByName(name),
+    },
+    logic: {
+        type: 'logic',
+        /** 逻辑在应用中的路径模板 */
+        path: 'app.logics[0]',
+        /** 从解析实例中查找逻辑的方法 */
+        findMethod: (name) => appInstance?.findLogicByName(name),
+        /** 从目标应用中查找已存在逻辑的方法 */
+        findExisting: (name) => app.findLogicByName(name),
+    },
+    view: {
+        type: 'view',
+        /** 视图在应用中的路径模板 */
+        path: 'app.frontendTypes[name=pc].frontends[name=pc].views[0]',
+        /** 从解析实例中查找视图的方法 */
+        findMethod: createViewFinder(appInstance),
+        /** 从目标应用中查找已存在视图的方法 */
+        findExisting: createViewFinder(app),
+    },
+    backendVariables: {
+        type: 'backendVariables',
+        /** 后端全局变量在应用中的路径 */
+        path: 'app.backend.variables[0]',
+        /** 从解析实例中查找后端变量 */
+        findMethod: (name) => {
+            if (!name)
+                return appInstance?.backend;
+            const path = `app.backend.variables[name=${name}]`;
+            return appInstance?.findNodeByPath(path);
+        },
+        /** 从目标应用中查找已存在的后端变量 */
+        findExisting: (name) => {
+            if (!name)
+                return app.backend;
+            const path = `app.backend.variables[name=${name}]`;
+            return app.findNodeByPath(path);
+        },
+    },
+    frontendVariables: {
+        type: 'frontendVariables',
+        /** 前端全局变量在应用中的路径 */
+        path: 'app.frontendTypes[name=pc].frontends[name=pc].variables[0]',
+        /** 从解析实例中查找前端变量 */
+        findMethod: (name) => {
+            if (!name)
+                return appInstance?.frontendTypes?.[0]?.frontends?.[0];
+            const path = `app.frontendTypes[name=pc].frontends[name=pc].variables[name=${name}]`;
+            return appInstance?.findNodeByPath(path);
+        },
+        /** 从目标应用中查找已存在的前端变量 */
+        findExisting: (name) => {
+            if (!name)
+                return app.frontendTypes?.[0]?.frontends?.[0];
+            const path = `app.frontendTypes[name=pc].frontends[name=pc].variables[name=${name}]`;
+            return app.findNodeByPath(path);
+        },
+    },
+    theme: {
+        type: 'theme',
+        /** 主题在应用中的路径 */
+        path: 'app.frontendTypes[name=pc].frontends[name=pc].theme',
+        /** 从解析实例中查找主题 */
+        findMethod: () => appInstance?.frontendTypes?.[0]?.frontends?.[0]?.theme,
+        /** 从目标应用中查找已存在的主题 */
+        findExisting: () => app.frontendTypes?.[0]?.frontends?.[0]?.theme,
+    },
+    // 后续需要扩展 extensions 的
+});
+/**
+ * 通用删除操作处理
+ * @param params - 删除操作参数
+ */
+const handleDeleteOperation = (params) => {
+    const { handler, itemName, itemType, batchActions, errors, parentViewNames, errorMessageTemplate = `要删除的对象不存在: ${itemName}`, } = params;
+    // 根据 handler 类型调用不同的 findExisting 方法
+    let existingNode;
+    if (isViewHandler(handler)) {
+        existingNode = handler.findExisting(itemName, parentViewNames);
+    }
+    else if (isSingleNodeHandler(handler)) {
+        existingNode = handler.findExisting(itemName);
+    }
+    else if (isGlobalVariablesHandler(handler)) {
+        existingNode = handler.findExisting(itemName);
+    }
+    if (existingNode) {
+        batchActions.actions.push({
+            action: 'delete',
+            path: existingNode.nodePath,
+            object: null,
+        });
+    }
+    else {
+        errors.push({
+            item: itemName,
+            type: itemType,
+            error: new Error(errorMessageTemplate),
+            level: 1,
+        });
+    }
+};
+/**
+ * 处理变量创建或更新操作
+ */
+const handleVariableCreateOrUpdate = (handler, variable, variableName, batchActions) => {
+    const existingVar = handler.findExisting(variableName);
+    const variableObject = variable.toJSON();
+    if (existingVar) {
+        // 更新操作
+        batchActions.actions.push({
+            action: 'update',
+            path: existingVar.nodePath,
+            object: variableObject,
+        });
+    }
+    else {
+        // 创建操作
+        batchActions.actions.push({
+            action: 'create',
+            path: handler.path,
+            object: variableObject,
+        });
+    }
+};
+/**
+ * 处理全局变量类型（一个文件对应多个节点）
+ */
+const processGlobalVariables = (params) => {
+    const { handler, action, itemType, batchActions, errors } = params;
+    // 系统保留变量，不允许删除、创建或更新
+    const RESERVED_VARIABLES = new Set(['httpRequest', 'httpResponse', 'currentUser']);
+    // 获取容器节点（backend 或 frontend）
+    const container = handler.findMethod();
+    if (!container || !container.variables) {
+        errors.push({
+            item: itemType,
+            type: itemType,
+            error: new Error(`未找到${itemType}容器或variables属性`),
+            level: 2,
+        });
+        return;
+    }
+    // 处理删除操作的特殊情况
+    if (action === 'delete') {
+        for (const variable of container.variables) {
+            const variableName = variable.name;
+            if (!variableName || RESERVED_VARIABLES.has(variableName))
+                continue;
+            try {
+                handleDeleteOperation({
+                    handler,
+                    itemName: variableName,
+                    itemType,
+                    batchActions,
+                    errors,
+                    errorMessageTemplate: `要删除的变量不存在: ${variableName}`,
+                });
+            }
+            catch (error) {
+                errors.push({
+                    item: variableName,
+                    type: itemType,
+                    error: error,
+                    level: 3,
+                });
+            }
+        }
+        return;
+    }
+    // 处理创建和更新操作
+    // 一次性获取现有容器，避免重复调用
+    const existingContainer = handler.findExisting();
+    // 构建新变量名的 Set（只在有现有容器时才需要）
+    const newVariableNames = existingContainer?.variables ? new Set() : null;
+    // 第一遍：处理新变量的创建/更新
+    for (const variable of container.variables) {
+        const variableName = variable.name;
+        if (!variableName || RESERVED_VARIABLES.has(variableName))
+            continue;
+        // 同时收集变量名（避免额外的 map 操作）
+        newVariableNames?.add(variableName);
+        try {
+            handleVariableCreateOrUpdate(handler, variable, variableName, batchActions);
+        }
+        catch (error) {
+            errors.push({
+                item: variableName,
+                type: itemType,
+                error: error,
+                level: 3,
+            });
+        }
+    }
+    // 第二遍：处理需要删除的旧变量（app 中有但 appInstance 中没有的，目前以 spec 生成为准，如果后续不需要，这块可以隐藏）
+    if (existingContainer?.variables && newVariableNames) {
+        for (const existingVariable of existingContainer.variables) {
+            const existingVariableName = existingVariable.name;
+            if (!existingVariableName ||
+                RESERVED_VARIABLES.has(existingVariableName) ||
+                newVariableNames.has(existingVariableName)) {
+                continue;
+            }
+            // 变量在 appInstance 中不存在，按 delete 处理
+            try {
+                handleDeleteOperation({
+                    handler,
+                    itemName: existingVariableName,
+                    itemType,
+                    batchActions,
+                    errors,
+                    errorMessageTemplate: `要删除的变量不存在: ${existingVariableName}`,
+                });
+            }
+            catch (error) {
+                errors.push({
+                    item: existingVariableName,
+                    type: itemType,
+                    error: error,
+                    level: 3,
+                });
+            }
+        }
+    }
+};
+/**
+ * 计算 view 类型的路径
+ */
+const calculateViewPath = (naslObject) => {
+    let type = 'views';
+    if (naslObject.parentNode?.concept === 'View') {
+        type = 'children';
+    }
+    const parentChildren = naslObject.parentNode?.[type] || [];
+    const childIndex = parentChildren.findIndex((child) => child === naslObject);
+    const index = childIndex !== -1 ? childIndex : 0;
+    return `${naslObject.parentNode.nodePath}.${type}[${index}]`;
+};
+/**
+ * 处理 view 类型的 children 属性
+ */
+const handleViewChildren = (object, action) => {
+    if (action === 'create') {
+        // 对于创建操作，需要将 children 数组转换为空数组
+        object.children = [];
+    }
+    else if (action === 'update') {
+        // 对于更新操作，删除 children 属性
+        if (object.children) {
+            delete object.children;
+        }
+    }
+};
+/**
+ * 处理单节点创建或更新操作
+ */
+const handleSingleNodeCreateOrUpdate = (handler, itemName, itemType, parentViewNames, batchActions, errors) => {
+    // 从解析的实例中获取 NASL 对象
+    let naslObject;
+    // 根据 handler 类型调用不同的 findMethod
+    if (isViewHandler(handler)) {
+        naslObject = handler.findMethod(itemName, parentViewNames);
+    }
+    else {
+        naslObject = handler.findMethod(itemName);
+    }
+    if (!naslObject) {
+        errors.push({
+            item: itemName,
+            type: itemType,
+            error: new Error(`未找到对应的 NASL 对象: ${handler.path} - ${itemName}`),
+            level: 2,
+        });
+        return;
+    }
+    let finalAction = 'create';
+    let path = '';
+    let object = naslObject.toJSON();
+    // 特殊处理：对于 view 类型，计算正确的路径
+    if (itemType === 'view' && naslObject.parentNode) {
+        path = calculateViewPath(naslObject);
+    }
+    // 检查目标应用中是否已存在同名对象
+    let existingNode;
+    if (isViewHandler(handler)) {
+        existingNode = handler.findExisting(itemName, parentViewNames);
+    }
+    else {
+        existingNode = handler.findExisting(itemName);
+    }
+    if (existingNode) {
+        // 存在同名对象，标记为更新操作
+        finalAction = 'update';
+        path = existingNode.nodePath;
+    }
+    // 特殊处理 view 类型的 children 属性
+    if (itemType === 'view') {
+        handleViewChildren(object, finalAction);
+    }
+    // 添加创建或更新操作到批量操作列表
+    batchActions.actions.push({
+        action: finalAction,
+        path: path || handler.path,
+        object,
+    });
+};
+/**
+ * 处理单节点类型（一个文件对应一个节点）
+ */
+const processSingleNode = (params) => {
+    const { handler, itemName, itemType, action, parentViewNames, batchActions, errors } = params;
+    if (action === 'delete') {
+        // 删除操作：使用通用删除方法
+        handleDeleteOperation({
+            handler,
+            itemName,
+            itemType,
+            batchActions,
+            errors,
+            parentViewNames,
+            errorMessageTemplate: `要删除的对象不存在: ${handler.path} - ${itemName}`,
+        });
+    }
+    else {
+        // 创建或更新操作
+        handleSingleNodeCreateOrUpdate(handler, itemName, itemType, parentViewNames, batchActions, errors);
+    }
+};
+/**
+ * 检测并生成缺失的父级视图模板
+ * @param path - 当前项的路径
+ * @param codeArray - 代码数组，用于添加生成的模板代码
+ * @param processedPaths - 已处理的路径集合，用于去重
+ * @param errors - 错误收集数组
+ */
+const processParentViews = (path, codeArray, processedPaths, errors) => {
+    // 获取当前项的所有父级路径信息（按层级从浅到深排序）
+    const parentInfos = extractParentViewPaths(path);
+    // 为缺失的父级视图生成模板并添加到 codeArray
+    for (const { viewName, namespace, fullPath } of parentInfos) {
+        if (!processedPaths.has(fullPath)) {
+            try {
+                const template = (0, exports.generateRouterContainerTemplate)({
+                    viewName,
+                    title: viewName,
+                    namespace,
+                });
+                // 直接将模板代码添加到 codeArray
+                codeArray.push(template);
+                // 标记为已处理
+                processedPaths.add(fullPath);
+            }
+            catch (error) {
+                errors.push({
+                    item: fullPath,
+                    type: 'generateParentView',
+                    error: error,
+                });
+            }
+        }
+    }
+};
+/**
+ * 转换单个codeAction
+ * 将codeAction 中的路径和内容转换为可解析的格式
+ * @param path - 文件路径
+ * @param content - 文件内容
+ * @param action - 操作类型
+ * @returns 包含转换后代码、项目类型、项目名称、操作类型和父级视图名称数组的对象
+ */
+const transformCodeAction = ({ path, content, action, }) => {
+    // 移除路径前缀 'src/'，并解析命名空间
+    const namespace = path.replace(/^src\//, '');
+    const namespaceParts = namespace.split('.');
+    // 根据命名空间确定项目类型（需要先确定类型）
+    const itemType = getItemType(namespace);
+    // 提取项目名称和父命名空间，对于变量类型需要特殊处理
+    let itemName;
+    let parentNamespace;
+    if (itemType === 'backendVariables' || itemType === 'frontendVariables') {
+        // 对于变量类型，路径格式为: app.backend.variables.ts 或 app.frontendTypes.pc.frontends.pc.variables.ts
+        // itemName 设为空字符串（因为这是整个 variables 文件）
+        // parentNamespace 为去掉 .ts 的部分，即保留到 variables
+        itemName = '';
+        parentNamespace = namespaceParts.slice(0, -1).join('.');
+    }
+    else if (itemType === 'theme') {
+        // 对于主题类型，路径格式为: app.frontendTypes.pc.frontends.pc.theme.css
+        itemName = '';
+        parentNamespace = namespaceParts.slice(0, -1).join('.');
+    }
+    else if (itemType === 'extensions') {
+        parentNamespace = namespaceParts.slice(0, -1).join('.');
+    }
+    else {
+        // 其他类型使用原有逻辑，即单文件模式(例如一个实体对应一个文件)
+        itemName = namespaceParts.length >= 2 ? namespaceParts[namespaceParts.length - 2] : '';
+        parentNamespace = namespaceParts.slice(0, -2).join('.');
+    }
+    // 生成转换后的代码，为非未知类型添加命名空间包装
+    let transformedCode = content;
+    if (itemType === 'theme') {
+        transformedCode = `namespace ${parentNamespace} {\n  $theme\`${content}\`;\n}\n`;
+    }
+    else if (itemType !== 'unknown' && parentNamespace) {
+        // 对于视图类型，需要额外的缩进
+        const indent = itemType === 'view' ? '    ' : '';
+        transformedCode = `namespace ${parentNamespace} {\n${indent}${content}\n}\n`;
+    }
+    // 如果是 view 类型，提取父级视图名称数组
+    // 优化：只在需要时计算 parentViewNames
+    const parentViewNames = itemType === 'view' ? extractParentViewPaths(path).map((info) => info.viewName) : undefined;
+    return {
+        transformedCode,
+        itemType,
+        itemName,
+        action,
+        ...(parentViewNames && parentViewNames.length > 0 && { parentViewNames }),
+    };
+};
+/**
+ * 将 codeAction 数组转换为批量操作
+ * 这是整个模块的核心函数，负责将多个codeAction 转换成统一的批量操作格式
+ *
+ * 处理流程：
+ * 1. 解析每个 codeAction ，提取类型和名称信息
+ * 2. 将需要解析的代码合并并通过 parseNaturalTS 解析
+ * 3. 为每个操作生成对应的 NASL 对象
+ * 4. 构建批量操作数组，支持创建、更新和删除操作
+ * 5. 处理错误并返回结果
+ *
+ * @param codeActions - codeAction 数组，每个元素包含 path、content、action
+ * @param app - NASL 应用实例，用于操作目标应用
+ * @param sessionId - 会话 ID，用于生成唯一标识
+ * @param type - 操作类型，'normal' 为正常模式，'debug' 为调试模式（会返回更多信息）
+ * @param files - 可选的完整文件列表，包含现有文件和新文件
+ * @returns 包含批量操作和可选调试信息的对象
+ */
+const transform2BatchActions = ({ codeActions, app, sessionId, type = 'normal', }) => {
+    // 开始性能计时
+    const startTime = performance.now();
+    // 存储转换后的代码片段（用于解析）
+    const codeArray = [];
+    // 存储每个项目的类型、名称、操作信息和父级视图名称
+    const itemTypes = [];
+    // 存储处理过程中的错误
+    const errors = [];
+    // 记录已处理的路径，避免重复生成父级视图
+    const processedPaths = new Set();
+    // 第一阶段：转换所有codeAction
+    for (const item of codeActions) {
+        try {
+            // 检查文件后缀，目前只处理 .ts、.tsx 和 .css 文件
+            if (!item.path.endsWith('.ts') &&
+                !item.path.endsWith('.tsx') &&
+                !item.path.endsWith('.css')) {
+                continue;
+            }
+            if (!(0, nasl_file_types_1.isKnownFileType)(item.path)) {
+                continue;
+            }
+            // 检测并生成缺失的父级视图
+            if (item.path?.includes('app.frontendTypes.pc.frontends.')) {
+                processParentViews(item.path, codeArray, processedPaths, errors);
+            }
+            // 处理当前项
+            const { transformedCode, itemType, itemName, action, parentViewNames } = transformCodeAction(item);
+            // 跳过未知类型的 codeAction/暂时禁用 extensions
+            if (itemType === 'unknown' || itemType === 'extensions')
+                continue;
+            // 只有非删除操作才需要累积代码用于解析，因为删除操作不需要解析新的 NASL 对象
+            if (action !== 'delete') {
+                codeArray.push(transformedCode);
+            }
+            if (action !== 'exist') {
+                itemTypes.push({ type: itemType, name: itemName, action, parentViewNames });
+            }
+            processedPaths.add(item.path);
+        }
+        catch (error) {
+            errors.push({
+                item: item.path,
+                type: 'transformCodeAction',
+                error: error,
+                level: 0,
+            });
+        }
+    }
+    // 第二阶段：解析累积的代码
+    // 将所有需要解析的代码合并为一个字符串（性能优化）
+    const accumulatedTsCode = codeArray.join('');
+    // 只有当有需要解析的代码时才调用 parseNaturalTS
+    let appInstance = null;
+    let parseJSON = null;
+    if (accumulatedTsCode) {
+        // 解析 TypeScript 代码为 NASL 对象
+        try {
+            parseJSON = (0, index_1.parseNaturalTS)(accumulatedTsCode, {});
+            if (!parseJSON)
+                return null;
+        }
+        catch (error) {
+            console.error('转换失败:', error);
+            console.error('原始数据:', codeActions);
+            return null;
+        }
+        // 生成 AI 唯一标识并创建应用实例
+        const { node: nodes } = (0, index_1.genAIUID)(parseJSON.toJSON(), sessionId);
+        appInstance = new concepts_1.App(nodes);
+    }
+    // 初始化批量操作对象
+    const batchActions = {
+        uuid: (0, uuid_1.v4)().replace(/-/g, ''), // 生成无连字符的 UUID
+        actions: [],
+        actionMsg: '批量操作数据模型和视图',
+        sourceType: 'spec_driven',
+    };
+    // 第三阶段：生成批量操作
+    // 获取不同类型的处理器
+    const typeHandlers = createTypeHandlers(appInstance, app);
+    // 收集所有要删除的视图名称，用于跳过冗余的子视图删除操作
+    const deletedViewNames = new Set(itemTypes
+        .filter(({ type, action }) => type === 'view' && action === 'delete')
+        .map(({ name }) => name));
+    // 遍历每个项目，生成对应的批量操作
+    for (const { type: itemType, name: itemName, action, parentViewNames } of itemTypes) {
+        // 跳过未知类型，或者非可选名称但无名称的项目
+        if (itemType === 'unknown' || (!isNameOptional(itemType) && !itemName))
+            continue;
+        // 如果父级视图已在删除列表中，子视图无需单独删除（父视图删除时会级联删除子视图）
+        if (itemType === 'view' && action === 'delete' && parentViewNames?.some((p) => deletedViewNames.has(p))) {
+            continue;
+        }
+        try {
+            const handler = typeHandlers[itemType];
+            if (!handler)
+                continue;
+            // 使用类型守卫进行精确的类型判断和处理
+            if (isThemeHandler(handler)) {
+                // 主题类型：无需参数
+                const naslObject = handler.findMethod();
+                if (naslObject) {
+                    const existingNode = handler.findExisting();
+                    batchActions.actions.push({
+                        action: 'update',
+                        path: existingNode?.nodePath || handler.path,
+                        object: {
+                            // 暂时只支持 scopeVariableMap + cssRules
+                            ...existingNode.toJSON(),
+                            scopeVariableMap: naslObject.scopeVariableMap,
+                            cssRules: naslObject.cssRules,
+                        },
+                    });
+                }
+            }
+            else if (isGlobalVariablesHandler(handler)) {
+                // 全局变量类型：一个文件对应多个节点
+                processGlobalVariables({
+                    handler,
+                    action,
+                    itemType,
+                    batchActions,
+                    errors,
+                });
+            }
+            else if (isViewHandler(handler)) {
+                // 视图类型：一个文件对应一个节点，支持嵌套视图
+                processSingleNode({
+                    handler,
+                    itemName,
+                    itemType,
+                    action,
+                    parentViewNames,
+                    batchActions,
+                    errors,
+                });
+            }
+            else if (isSingleNodeHandler(handler)) {
+                // 单节点类型：entity, structure, enum, logic
+                processSingleNode({
+                    handler,
+                    itemName,
+                    itemType,
+                    action,
+                    parentViewNames,
+                    batchActions,
+                    errors,
+                });
+            }
+        }
+        catch (error) {
+            // 记录处理过程中的错误
+            errors.push({
+                item: itemName,
+                type: itemType,
+                error: error,
+                level: 3,
+            });
+        }
+    }
+    // 第五阶段：同步 directories（只处理 appInstance 中已存在的）
+    if (appInstance && app) {
+        handleAppDirectories(appInstance, app, batchActions, errors);
+    }
+    // 第四阶段：错误处理和结果返回
+    // 如果有错误发生，在控制台输出错误信息（但不中断执行）
+    if (errors.length > 0) {
+        console.error('批量处理过程中发现错误:', errors);
+    }
+    // 构建返回结果，基础结果包含批量操作
+    let result = {
+        batchActions,
+        accumulatedTsCode, // 累积的 TypeScript 代码
+    };
+    // 调试模式下返回额外的调试信息
+    if (type === 'debug') {
+        result = {
+            ...result,
+            parseJSON, // 解析后的 JSON 对象
+            errors, // 错误列表
+        };
+    }
+    // 计算并输出执行时间
+    const endTime = performance.now();
+    console.log(`transform2BatchActions 执行时间: ${endTime - startTime}ms`);
+    return result;
+};
+exports.transform2BatchActions = transform2BatchActions;
+/**
+ * 构建全局 definition 索引
+ * 一次性构建，避免重复遍历
+ * @param allDirs - 所有目录数组
+ * @returns 全局索引对象
+ */
+const buildGlobalDefIndex = (allDirs) => {
+    const defMap = new Map();
+    const dirDefMap = new Map();
+    for (const dir of allDirs) {
+        if (!dir?.definitions || !dir.name)
+            continue;
+        const defKeys = new Set();
+        for (const def of dir.definitions) {
+            if (!def)
+                continue;
+            const key = `${def.namespace}:${def.name}`;
+            defMap.set(key, {
+                def,
+                dirName: dir.name,
+                dirPath: dir.nodePath,
+            });
+            defKeys.add(key);
+        }
+        if (defKeys.size > 0) {
+            dirDefMap.set(dir.name, defKeys);
+        }
+    }
+    return { defMap, dirDefMap };
+};
+/**
+ * 深度比较两个 definition 是否需要更新
+ * 只比较关键属性，避免不必要的序列化
+ * @param appDef - app 中的 definition
+ * @param instanceDef - appInstance 中的 definition
+ * @returns 是否需要更新
+ */
+const needsDefinitionUpdate = (appDef, instanceDef) => {
+    // 快速检查：引用相等
+    if (appDef === instanceDef)
+        return false;
+    // 关键属性比较
+    return (appDef.referredConcept !== instanceDef.referredConcept ||
+        appDef.namespace !== instanceDef.namespace ||
+        appDef.name !== instanceDef.name);
+};
+/**
+ * 同步目录的 definitions
+ * 使用 Map 替代数组查找，使用全局索引避免重复遍历
+ * @param instanceDir - appInstance 中的目录
+ * @param appDir - app 中对应的目录
+ * @param globalDefIndex - 全局 definition 索引
+ * @param pendingActions - 待添加的批量操作数组
+ * @param errors - 错误收集数组
+ */
+const syncDirectoryDefinitions = (instanceDir, appDir, globalDefIndex, pendingActions, errors) => {
+    try {
+        // 快速检查
+        if (!instanceDir?.definitions || instanceDir.definitions.length === 0) {
+            return;
+        }
+        // 构建当前目录的 definition Map
+        const appDefMap = new Map((appDir?.definitions || []).map((def) => [`${def.namespace}:${def.name}`, def]));
+        for (const instanceDef of instanceDir.definitions) {
+            if (!instanceDef)
+                continue;
+            const key = `${instanceDef.namespace}:${instanceDef.name}`;
+            const defObject = instanceDef.toJSON();
+            // 第一步：在当前目录查找
+            const appDefInCurrentDir = appDefMap.get(key);
+            if (appDefInCurrentDir) {
+                // 在当前目录找到了，检查是否需要更新
+                if (needsDefinitionUpdate(appDefInCurrentDir, instanceDef)) {
+                    // 内容不同，更新（先删除再创建）
+                    pendingActions.push({
+                        action: 'delete',
+                        path: appDefInCurrentDir.nodePath,
+                        object: null,
+                    }, {
+                        action: 'create',
+                        path: `${appDir.nodePath}.definitions[0]`,
+                        object: defObject,
+                    });
+                }
+                // 内容相同则跳过
+            }
+            else {
+                // 第二步：使用全局索引查找其他目录
+                const defInOtherDir = globalDefIndex.defMap.get(key);
+                if (defInOtherDir && defInOtherDir.dirName !== appDir.name) {
+                    // 在其他文件夹找到了 → 文件移动场景
+                    // 先删除旧位置的引用
+                    pendingActions.push({
+                        action: 'delete',
+                        path: defInOtherDir.def.nodePath,
+                        object: null,
+                    });
+                }
+                // 然后在当前目录创建新引用（无论是移动还是新建）
+                pendingActions.push({
+                    action: 'create',
+                    path: `${appDir.nodePath}.definitions[0]`,
+                    object: defObject,
+                });
+            }
+        }
+    }
+    catch (error) {
+        errors.push({
+            item: instanceDir?.name || 'unknown',
+            type: 'definitionSync',
+            error: error,
+            level: 4,
+        });
+    }
+};
+/**
+ * 删除新目录中的 definitions 在其他目录中的旧引用
+ * 使用全局索引，避免重复构建 Map
+ * @param instanceDir - 新目录
+ * @param globalDefIndex - 全局 definition 索引
+ * @param pendingActions - 待添加的批量操作数组
+ */
+const deleteOldDefinitionReferences = (instanceDir, globalDefIndex, pendingActions) => {
+    if (!instanceDir?.definitions || instanceDir.definitions.length === 0) {
+        return;
+    }
+    // 直接使用全局索引查找
+    for (const instanceDef of instanceDir.definitions) {
+        if (!instanceDef)
+            continue;
+        const key = `${instanceDef.namespace}:${instanceDef.name}`;
+        const oldDef = globalDefIndex.defMap.get(key);
+        if (oldDef) {
+            // 找到了旧引用，删除它
+            pendingActions.push({
+                action: 'delete',
+                path: oldDef.def.nodePath,
+                object: null,
+            });
+        }
+    }
+};
+/**
+ * 同步单个目录
+ * 通用的目录同步逻辑，适用于所有类型的目录
+ * @param instanceDir - appInstance 中的目录
+ * @param appDir - app 中对应的目录（可能不存在）
+ * @param globalDefIndex - 全局 definition 索引
+ * @param parentPath - 父级路径
+ * @param pendingActions - 待添加的批量操作数组
+ * @param errors - 错误收集数组
+ * @param errorType - 错误类型标识
+ */
+const syncSingleDirectory = (instanceDir, appDir, globalDefIndex, parentPath, pendingActions, errors, errorType) => {
+    try {
+        if (!appDir) {
+            // 目录不存在，需要创建
+            // 先删除该目录中 definitions 在其他目录的旧引用
+            deleteOldDefinitionReferences(instanceDir, globalDefIndex, pendingActions);
+            // 然后创建完整的新目录
+            const dirObject = instanceDir.toJSON();
+            pendingActions.push({
+                action: 'create',
+                path: parentPath,
+                object: dirObject,
+            });
+        }
+        else {
+            // 目录存在，同步 definitions
+            syncDirectoryDefinitions(instanceDir, appDir, globalDefIndex, pendingActions, errors);
+        }
+    }
+    catch (error) {
+        errors.push({
+            item: instanceDir?.name || 'unknown',
+            type: errorType,
+            error: error,
+            level: 4,
+        });
+    }
+};
+/**
+ * 处理 app directories 同步
+ * 处理四种 directories: 'LOGICS', 'ENUMS', 'STRUCTURES' 以及 appInstance.dataSources[0] 的 directories
+ * 比对 directories 及引用 definitions，最小粒度是 definition，唯一标识是 namespace+name
+ * 文件夹只做新增更新，definition 如果在同一领域的文件夹下，需要先删除原引用，再创建新引用
+ *
+ * 性能优化:
+ * 1. 全局 definition 索引缓存 - 避免重复构建
+ * 3. 批量操作收集 - 减少数组扩容
+ * 4. 提前验证和快速退出 - 避免无效处理
+ * 5. 优化的 definition 比较 - 只比较关键属性
+ */
+const handleAppDirectories = (appInstance, app, batchActions, errors) => {
+    // 性能计时开始
+    const startTime = performance.now();
+    // 1. 边界检查和快速退出
+    if (!appInstance || !app) {
+        errors.push({
+            item: 'handleAppDirectories',
+            type: 'invalidParams',
+            error: new Error('appInstance 或 app 参数无效'),
+            level: 5,
+        });
+        return;
+    }
+    try {
+        // 2. 快速检查是否有需要处理的目录
+        const hasInstanceDirs = appInstance.directories?.some((dir) => ['LOGICS', 'ENUMS', 'STRUCTURES'].includes(dir?.name) && dir.children?.length > 0);
+        const hasDataSourceDirs = appInstance.dataSources?.[0]?.directories?.length > 0;
+        if (!hasInstanceDirs && !hasDataSourceDirs) {
+            console.log('[handleAppDirectories] 无需处理目录同步');
+            return; // 无需处理
+        }
+        // 3. 批量操作收集器（减少数组扩容）
+        const pendingActions = [];
+        // 4. 处理根目录类型 (LOGICS, ENUMS, STRUCTURES)
+        const rootDirectoryTypes = ['LOGICS', 'ENUMS', 'STRUCTURES'];
+        for (const rootType of rootDirectoryTypes) {
+            try {
+                const instanceRootDir = appInstance.directories?.find((dir) => dir?.name === rootType);
+                if (!instanceRootDir?.children?.length) {
+                    continue;
+                }
+                let appRootDir = app.directories?.find((dir) => dir?.name === rootType);
+                if (!appRootDir) {
+                    // 根目录不存在，直接创建
+                    pendingActions.push({
+                        action: 'create',
+                        path: 'app.directories[0]',
+                        object: instanceRootDir.toJSON(),
+                    });
+                    continue;
+                }
+                // 5. 构建子目录 Map（O(1) 查找，替代数组遍历）
+                const allAppChildDirs = appRootDir.children || [];
+                const appChildDirMap = new Map(allAppChildDirs.filter((dir) => dir?.name).map((dir) => [dir.name, dir]));
+                // 6. 构建全局 definition 索引（一次性构建）
+                const globalDefIndex = buildGlobalDefIndex(allAppChildDirs);
+                // 7. 遍历子目录
+                for (const instanceChildDir of instanceRootDir.children) {
+                    if (!instanceChildDir?.name)
+                        continue;
+                    const appChildDir = appChildDirMap.get(instanceChildDir.name);
+                    syncSingleDirectory(instanceChildDir, appChildDir, globalDefIndex, `${appRootDir.nodePath}.children[0]`, pendingActions, errors, 'directorySync');
+                }
+            }
+            catch (error) {
+                errors.push({
+                    item: rootType,
+                    type: 'rootDirectorySync',
+                    error: error,
+                    level: 4,
+                });
+            }
+        }
+        // 8. 处理数据源 (Entity) directories
+        if (appInstance.dataSources?.[0]?.directories && app.dataSources?.[0]) {
+            try {
+                const instanceDataSource = appInstance.dataSources[0];
+                const appDataSource = app.dataSources[0];
+                const allAppEntityDirs = appDataSource.directories || [];
+                // 构建目录 Map（O(1) 查找）
+                const entityDirMap = new Map(allAppEntityDirs.filter((dir) => dir?.name).map((dir) => [dir.name, dir]));
+                // 构建全局 definition 索引
+                const globalDefIndex = buildGlobalDefIndex(allAppEntityDirs);
+                for (const instanceDir of instanceDataSource.directories) {
+                    if (!instanceDir?.name)
+                        continue;
+                    const appDir = entityDirMap.get(instanceDir.name);
+                    syncSingleDirectory(instanceDir, appDir, globalDefIndex, `${appDataSource.nodePath}.directories[0]`, pendingActions, errors, 'entityDirectorySync');
+                }
+            }
+            catch (error) {
+                errors.push({
+                    item: 'dataSources',
+                    type: 'dataSourceDirectorySync',
+                    error: error,
+                    level: 4,
+                });
+            }
+        }
+        // 9. 批量添加所有操作（一次性 push，减少数组扩容）
+        if (pendingActions.length > 0) {
+            batchActions.actions.push(...pendingActions);
+            console.log(`[handleAppDirectories] 生成 ${pendingActions.length} 个批量操作`);
+        }
+        // 性能计时结束
+        const endTime = performance.now();
+        console.log(`[handleAppDirectories] 执行时间: ${(endTime - startTime).toFixed(2)}ms`);
+    }
+    catch (error) {
+        errors.push({
+            item: 'handleAppDirectories',
+            type: 'directorySync',
+            error: error,
+            level: 4,
+        });
+    }
+};
+/**
+ * 辅助函数：从路径项中提取索引
+ * @param pathItem - 路径项，如 'entities[0]'
+ * @returns 索引数字，如果没有则返回 undefined
+ */
+const extractIndex = (pathItem) => {
+    const match = pathItem.match(/\[(\d+)\]$/);
+    return match ? parseInt(match[1], 10) : undefined;
+};
+/**
+ * 辅助函数：从路径项中提取父级键名
+ * @param pathItem - 路径片段，如 'entities[0]' 或 'dataSources[name=defaultDS]'
+ * @returns 父级键名，如 'entities' 或 'dataSources'
+ */
+const getParentKey = (pathItem) => {
+    return pathItem.replace(/\[.*\]$/, '');
+};
+/**
+ * 将批量操作应用到 app 实例
+ * 处理批量操作（create/update/delete），并将其应用到 app 中
+ * @param app - NASL 应用实例，需传入 Vue 劫持后的响应式 app
+ * @param batchActions - 需要应用的批量操作
+ */
+const applyBatchActions = (app, batchActions) => {
+    const { actionMsg, sourceType, actions } = batchActions;
+    app.emit('collect:start', {
+        actionMsg,
+        sourceType,
+    });
+    for (const event of actions) {
+        const { action, path, object } = event;
+        try {
+            switch (action) {
+                case 'create': {
+                    const pathArr = (0, utils_1.splitPath)(path) || [];
+                    const lastPathItem = pathArr?.pop();
+                    if (!lastPathItem)
+                        break;
+                    const parentPath = pathArr.join('.');
+                    const parentKey = getParentKey(lastPathItem);
+                    const index = extractIndex(lastPathItem);
+                    const parentNode = app.findNodeByPath(parentPath);
+                    if (!parentNode)
+                        break;
+                    const node = concepts_1.BaseNode.from(object);
+                    node.createNode({
+                        parentNode,
+                        parentKey,
+                        index,
+                    });
+                    break;
+                }
+                case 'delete': {
+                    const node = app.findNodeByPath(path);
+                    node?.delete();
+                    break;
+                }
+                case 'update': {
+                    const node = app.findNodeByPath(path);
+                    node?.update(object);
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error applying ${action} operation for path ${path}:`, error);
+        }
+    }
+    app.emit('collect:end');
+    // return new Promise((resolve, reject) => {
+    //   app.on('save-nasl-success', resolve);
+    //   app.on('save-nasl-error', (error: any) => {
+    //     reject(error);
+    //   });
+    // });
+};
+exports.applyBatchActions = applyBatchActions;
+//# sourceMappingURL=transform2BatchActions.js.map