@lcap/nasl 2.20.0-beta.1 → 2.20.0-beta.2

package/out/server/naslServer.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NaslServer = void 0;
+exports.NaslServer = exports.getDisplayString2Type = void 0;
 /// #if process.env.BUILD_TARGET === 'node'
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
@@ -46,17 +46,45 @@ const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
 const formatTsUtils_1 = require("./formatTsUtils");
 const naslStdlibMap_1 = __importDefault(require("./naslStdlibMap"));
 const jsoner = __importStar(require("../service/storage/jsoner"));
+const EventEmitter_1 = require("../common/EventEmitter");
 const EmbeddedTSFileLineMap = {
     Entity: 3,
 };
 const EmbeddedTSFileOffsetMap = {
     Variable: 12,
 };
-// 要Check的文件
-const filesToCheck = new Set();
 let isChangeInterface = false; //判断是否导入接口
 let actionArr = []; //用于导入接口收集更改的节点
 let timer = null; //超时器用于收集导入接口相关
+// 联合类型切割取出类型
+function getDisplayString2Type(displayString) {
+    // 取出匹配的内容
+    const reg = /<([^()]+)>/g;
+    // 解决extends 导致类型缺失的问题
+    displayString = displayString?.replace('T extends ', '') || '';
+    const types = reg.exec(displayString);
+    // 取出提示的类型，组成是数组
+    const typeList = types[1].split(' | ').map((item) => {
+        if (/<([^()]+)>/g.exec(item)) {
+            return item;
+        }
+        else if (item.includes(' ')) {
+            const strs = item.split(' ');
+            const type = strs[strs.length - 1];
+            return type;
+        }
+        else if (item.includes('.')) {
+            const strs = item.split('.');
+            const type = strs[strs.length - 1];
+            return type;
+        }
+        else {
+            return item;
+        }
+    });
+    return typeList;
+}
+exports.getDisplayString2Type = getDisplayString2Type;
 class NaslServer {
     messager = undefined;
     worker = undefined;
@@ -69,6 +97,11 @@ class NaslServer {
     elementsLogic = {};
     // 错误日志收集
     diagnosticManager = undefined;
+    embeddedTSEmitter = undefined;
+    // 需要执行修改的文件
+    changeStackList = [];
+    filesToCheck;
+    singleFileChangeIng;
     constructor() {
         /// #if process.env.BUILD_TARGET === 'node'
         if (globalThis.process) // For TS build
@@ -79,6 +112,10 @@ class NaslServer {
         if (globalThis.window) // For TS build
             this.worker = new worker_threads_1.Worker('/ts-worker.js');
         /// #endif
+        // 要Check的文件
+        this.filesToCheck = new Set();
+        // 单个文件正在change，不允许同时两个文件一起change
+        this.singleFileChangeIng = false;
         this.diagnosticManager = new diagnostic_1.DiagnosticManager();
         this.messager = new Messager_1.default({
             protocol: 'ts-worker',
@@ -93,10 +130,54 @@ class NaslServer {
                 }
             },
         });
+        // 监听所有改变操作
+        this.embeddedTSEmitter = new EventEmitter_1.EventEmitter();
+        this.embeddedTSEmitter.on('change', ($event) => {
+            // 收集到一个行为集合
+            const eventValue = $event.value;
+            eventValue.forEach(async (item) => {
+                /**
+                 * 多个行为进行合并
+                 * 合并规则是
+                 * 1.[a,b,c,c] 在cc的时候，在已有一个c，又来一个c的时候，如果他们不都是file级别的节点
+                 *   就可以前面的内容去掉，只保留最后一个
+                 * 2.[a,b,c,b,c] 在bc已存在，又来了bc 这就都要保留，因为可能顺序有相关性，不能去掉
+                 * 理论上只处理同时几个操作 合并，
+                 * 3.有field的也直接保留
+                 */
+                try {
+                    const changeEvent = item.originEvent;
+                    const changeNode = changeEvent.target;
+                    const { fileNode } = this.getCurrentSource(changeNode);
+                    if (changeNode !== fileNode || !changeEvent.field) {
+                        const findIndex = this.changeStackList.findIndex((changeStackItem) => {
+                            const target = changeStackItem.target;
+                            const { fileNode: targetFileNode } = this.getCurrentSource(target);
+                            return targetFileNode === fileNode;
+                        });
+                        if (findIndex === this.changeStackList.length - 1) {
+                            this.changeStackList.pop();
+                        }
+                    }
+                    this.changeStackList.push(item.originEvent);
+                }
+                catch (err) {
+                    console.log(err);
+                    this.changeStackList.push(item.originEvent);
+                }
+            });
+            // 如果有长度开始执行状态机
+            if (this.changeStackList.length) {
+                this.changeFileNext();
+            }
+        });
     }
     start() {
         return this.messager.requestCommand('start');
     }
+    terminate() {
+        this.worker.terminate();
+    }
     async createUiTs(allComponent) {
         const { code, elementsLogic } = await (0, createUiTs_1.default)(allComponent);
         // 放入生產的uits文件
@@ -126,17 +207,34 @@ class NaslServer {
             catch (err) {
             }
         });
-        module.frontendVariables?.forEach((frontendVariable) => {
+        module.frontends?.forEach((frontend) => {
             try {
-                const result = frontendVariable.toEmbeddedTSFile();
+                const result = frontend.toEmbeddedTSFile();
                 results.push(result);
                 // sourceMap都存在目录级别内容下，在页面层级下去找
-                frontendVariable.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, frontendVariable);
+                frontend.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, frontend);
             }
             catch (err) {
                 console.log(err);
             }
+            frontend.variables?.forEach((frontendVariable) => {
+                try {
+                    const result = frontendVariable.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    frontendVariable.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, frontendVariable);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            });
+            // view的生成
+            if (!config_1.config.closeViews) {
+                this.view2TSFile(frontend.views, results);
+            }
+            frontend.componentDependencies?.forEach((item) => this.contentToFile(item, results));
         });
         module.dataSources?.forEach((dataSource) => {
             // 本身dataSource也要生成一个文件用于改名
@@ -195,10 +293,6 @@ class NaslServer {
             catch (err) {
             }
         });
-        // view的生成
-        if (!config_1.config.closeViews) {
-            this.view2TSFile(module.views, results);
-        }
         module.processes.forEach((process) => {
             try {
                 const result = process.toEmbeddedTSFile();
@@ -249,7 +343,6 @@ class NaslServer {
             // 其他模块的创建内容
             app.dependencies.forEach((item) => this.contentToFile(item, results));
             app.interfaceDependencies.forEach((item) => this.contentToFile(item, results));
-            app.componentDependencies.forEach((item) => this.contentToFile(item, results));
         }
         catch (err) {
             console.log(err);
@@ -371,32 +464,6 @@ class NaslServer {
     _getValueSelectCompletion(args) {
         return this.messager.requestCommand('getValueSelectCompletion', args);
     }
-    // 联合类型切割取出类型
-    getDisplayString2Type(displayString) {
-        // 取出匹配的内容
-        const reg = /<([^()]+)>/g;
-        const types = reg.exec(displayString);
-        // 取出提示的类型，组成是数组
-        const typeList = types[1].split(' | ').map((item) => {
-            if (/<([^()]+)>/g.exec(item)) {
-                return item;
-            }
-            else if (item.includes(' ')) {
-                const strs = item.split(' ');
-                const type = strs[strs.length - 1];
-                return type;
-            }
-            else if (item.includes('.')) {
-                const strs = item.split('.');
-                const type = strs[strs.length - 1];
-                return type;
-            }
-            else {
-                return item;
-            }
-        });
-        return typeList;
-    }
     /**
      * 获取 Convert 的可选类型
      * @param node 传入当前已经选择的变量
@@ -419,7 +486,7 @@ class NaslServer {
                 });
                 if (quickInfo.responseRequired) {
                     const displayString = quickInfo?.response?.displayString || '';
-                    const typeList = this.getDisplayString2Type(displayString);
+                    const typeList = getDisplayString2Type(displayString);
                     const res = [];
                     typeList.forEach((type) => {
                         const typeAnnotation = coreTypeList_1.primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
@@ -477,6 +544,17 @@ class NaslServer {
                         .replace(/__name:"AStructure_\w{8}";/g, '')
                         .replace(/dataSources.([^.]+).entities.([^;]+)/g, ($1, $2, $3) => (`${$3}(${$2})`));
                 }
+                else if (typeStr.startsWith('{') && typeStr.endsWith('}')) {
+                    /**
+                     *  {
+                            text: nasl.core.String;
+                            value: nasl.core.String;
+                        }
+                     */
+                    return typeStr.replaceAll(' ', '')
+                        .replaceAll('\n', '')
+                        .replaceAll('nasl.core.', '');
+                }
                 let str = '';
                 // 取出T的值
                 typeStr = (0, formatTsUtils_1.getPlatformType)(typeStr);
@@ -502,6 +580,49 @@ class NaslServer {
         }
         return '';
     }
+    async getDataSchemaStructureOrTypeAnnotation(node) {
+        if (!(node instanceof concepts_1.ViewElement))
+            return;
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        const quickInfo = await this._getTypeQuickinfo({
+            file: fileNode.getEmbeddedFilePath(),
+            line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+            offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `new nasl.ui.`.length,
+        });
+        if (quickInfo.responseRequired) {
+            const displayString = quickInfo?.response?.displayString || '';
+            const flag = displayString.includes('<') && displayString.includes('>');
+            if (!flag)
+                return;
+            const types = /\<([^()]+)\>/g.exec(displayString);
+            const typeStr = types && types[1];
+            const app = node.app;
+            if (typeStr.includes('__name: "AStructure_')) {
+                const properties = [];
+                typeStr
+                    .replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
+                    if (name === '__name')
+                        return;
+                    typeKey = `app.${typeKey}`;
+                    const keys = typeKey.split('.');
+                    const typeName = keys.pop();
+                    const typeNamespace = keys.join('.');
+                    properties.push(concepts_1.StructureProperty.from({
+                        name,
+                        typeAnnotation: concepts_1.TypeAnnotation.from({
+                            typeKind: 'reference',
+                            typeName,
+                            typeNamespace,
+                        }),
+                    }));
+                    return '';
+                });
+                return concepts_1.TypeAnnotation.createTypeAnonymousStructure(properties);
+            }
+            else if (typeStr.startsWith('structures'))
+                return app.findNodeByCompleteName(`app.${typeStr}`);
+        }
+    }
     /**
      * ts的 quickInfo方法，查询指定位置的详情
      * @param args 文件信息数组
@@ -615,6 +736,17 @@ class NaslServer {
             if (isChangeInterface) {
                 this.existStructureFix(record.semanticDiagnostics, node, this);
             }
+            // 单独处理 oql 语义错误提示
+            if (record.node instanceof concepts_1.Logic) {
+                record?.syntaxDiagnostics.forEach((item) => {
+                    const minRange = this._findMinRange(item, record.node);
+                    if (minRange.node instanceof concepts_1.OqlQueryComponent) {
+                        if (item.text === 'Invalid character.') {
+                            record.semanticDiagnostics.push(item);
+                        }
+                    }
+                });
+            }
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag, node, record))
                 .filter((diag) => !!diag);
@@ -633,7 +765,8 @@ class NaslServer {
             //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
             // }
             record.suggestionDiagnostics = record.suggestionDiagnostics
-                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`].includes(item.text))
+                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`,
+                `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
                 .map((diag) => this._resolveDiagnostic(diag, node, record))
                 .filter((diag) => !!diag);
             record.suggestionDiagnostics.push(...this._attachSuggestionDiagnostics(node));
@@ -657,14 +790,14 @@ class NaslServer {
             // 递归检查，防止从顶层页面开始删除影响子页面内容检查
             while (curNode instanceof concepts_1.View && !removed) {
                 if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof concepts_1.App && !curNode.parentNode.views.includes(curNode)) {
+                    || curNode.parentNode instanceof concepts_1.Frontend && !curNode.parentNode.views.includes(curNode)) {
                     removed = true;
                 }
                 curNode = curNode.parentNode;
             }
             if (removed)
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof concepts_1.Match) {
                     const { cases, expression } = node || {};
                     const typeAnnotationMap = {};
@@ -674,7 +807,7 @@ class NaslServer {
                         count: 0,
                     };
                     if (Array.isArray(cases)) {
-                        cases.forEach(async (caseItem, index) => {
+                        cases.forEach((caseItem, index) => {
                             let isDisabled = false;
                             // 是最后一项
                             if (index === cases.length - 1) {
@@ -714,7 +847,7 @@ class NaslServer {
                                         }),
                                     ];
                                 }
-                                if (Array.isArray(enumerableItems)) {
+                                if (Array.isArray(enumerableItems) && enumerableItems.length) {
                                     const map = {};
                                     cases.forEach((caseItem) => {
                                         const { patterns } = caseItem || {};
@@ -806,25 +939,40 @@ class NaslServer {
             // 递归检查，防止从顶层页面开始删除影响子页面内容检查
             while (curNode instanceof concepts_1.View && !removed) {
                 if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof concepts_1.App && !curNode.parentNode.views.includes(curNode)) {
+                    || curNode.parentNode instanceof concepts_1.Frontend && !curNode.parentNode.views.includes(curNode)) {
                     removed = true;
                 }
                 curNode = curNode.parentNode;
             }
             if (removed)
                 return diagnostics;
-            fileNode.traverseChildren((node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof concepts_1.ViewElement && node.view === fileNode) {
                     if (node.tag) {
                         node.bindAttrs.forEach((bindAttr) => {
-                            if ((bindAttr.model || bindAttr.sync) && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
-                                const diagnostic = {
-                                    node: bindAttr,
-                                    severity: 'error',
-                                    message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
-                                };
-                                bindAttr.tsErrorDetail = diagnostic;
-                                diagnostics.push(diagnostic);
+                            if ((bindAttr.model || bindAttr.sync) && bindAttr.expression) {
+                                const bindExpression = bindAttr.expression;
+                                let diagnostic;
+                                if (bindExpression.concept !== 'Identifier' && bindExpression.concept !== 'MemberExpression') {
+                                    diagnostic = {
+                                        node: bindAttr,
+                                        severity: 'error',
+                                        message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                    };
+                                }
+                                else {
+                                    if (bindExpression.isEnum()) {
+                                        diagnostic = {
+                                            node: bindAttr,
+                                            severity: 'error',
+                                            message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                        };
+                                    }
+                                }
+                                if (diagnostic) {
+                                    bindAttr.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                }
                             }
                         });
                     }
@@ -838,34 +986,44 @@ class NaslServer {
                                 // 子页面内部逻辑过滤
                                 if (nodeIn.view !== fileNode)
                                     return;
+                                // 当局部变量、输出参数属于页面内逻辑时，需过滤同页面下不同逻辑下的同名变量
+                                if (node.logic && node.logic !== nodeIn.logic)
+                                    return;
                                 // 跟变量无关的赋值过滤
                                 const jsCode = nodeIn.toJS();
                                 if (!jsCode.includes(`${node.name} = `))
                                     return;
-                                // 逻辑内局部变量、输出参数、输入参数过滤
-                                if ((nodeIn.logic?.variables || []).find((lVar) => jsCode.includes(`${lVar.name} = `))
-                                    || (nodeIn.logic?.returns || []).find((lRet) => jsCode.includes(`${lRet.name} = `))
-                                    || (nodeIn.logic?.params || []).find((lPar) => jsCode.includes(`${lPar.name} = `)))
-                                    return;
+                                // 页面局部变量
                                 if (node instanceof concepts_1.Variable && node.parentNode instanceof concepts_1.View) {
+                                    // 跟页面局部变量无关的赋值过滤
+                                    if (!jsCode.includes(`this.${node.name} = `))
+                                        return;
                                     // 直接赋值 logic 内局部变量、输入参数直接提示系统无法推断类型
-                                    let hasVar = false;
-                                    nodeIn.logic?.params.forEach((param) => {
-                                        if (jsCode.includes(param.name))
-                                            hasVar = true;
-                                    });
-                                    if (!hasVar) {
-                                        nodeIn.logic?.variables.forEach((variable) => {
-                                            if (jsCode.includes(variable.name))
-                                                hasVar = true;
-                                        });
-                                    }
-                                    if (hasVar)
+                                    if (nodeIn.logic?.params.find((param) => jsCode.includes(param.name))
+                                        || nodeIn.logic?.virtualParams.find((vParam) => jsCode.includes(vParam.name))
+                                        || nodeIn.logic?.variables.find((variable) => jsCode.includes(variable.name))) {
+                                        if (!nodeIn.tsErrorDetail) {
+                                            const diagnostic = {
+                                                node: nodeIn,
+                                                severity: 'error',
+                                                message: `页面${nodeTypeName} ${node.name} 赋值页面逻辑内局部变量或输入参数时，系统无法推导类型。`,
+                                            };
+                                            nodeIn.tsErrorDetail = diagnostic;
+                                            diagnostics.push(diagnostic);
+                                        }
                                         msg = '系统无法推断类型。';
+                                    }
                                 }
-                                else {
-                                    msg = '必须赋值有返回值的内容。';
+                                if (!nodeIn.tsErrorDetail) {
+                                    const diagnostic = {
+                                        node: nodeIn,
+                                        severity: 'error',
+                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                    };
+                                    nodeIn.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
                                 }
+                                msg = '必须赋值有返回值的内容。';
                             }
                         });
                         if (!msg)
@@ -878,12 +1036,9 @@ class NaslServer {
                         node.tsErrorDetail = diagnostic;
                         diagnostics.push(diagnostic);
                     }
-                    else {
-                        node.tsErrorDetail = undefined;
-                    }
                 }
                 else {
-                    this.checkMatchError(node, diagnostics);
+                    this.checkNodeError(node, diagnostics);
                 }
             });
         }
@@ -909,6 +1064,44 @@ class NaslServer {
                             };
                             diagnostics.push(diagnostic);
                         }
+                        else if (propertyValue.value) {
+                            const dataSource = fileNode;
+                            // 数据源有连接错误
+                            let envText;
+                            if (propertyValue.env === 'dev') {
+                                if (dataSource.__devConnectError) {
+                                    envText = '开发';
+                                }
+                                else if (dataSource.__devConnectError === false) {
+                                    return;
+                                }
+                            }
+                            else if (propertyValue.env === 'online') {
+                                if (dataSource.__onlineConnectError) {
+                                    envText = '生产';
+                                }
+                                else if (dataSource.__onlineConnectError === false) {
+                                    return;
+                                }
+                            }
+                            // 手动插入报错
+                            if (envText) {
+                                const diagnostic = {
+                                    node: fileNode,
+                                    severity: 'error',
+                                    message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
+                                    // 保留原来的内容方便查询一些问题
+                                    originalDiagnostic: {
+                                        fileName: '',
+                                        start: null,
+                                        end: null,
+                                        category: 'error',
+                                        text: `DataSource connection error`,
+                                    },
+                                };
+                                return diagnostics.push(diagnostic);
+                            }
+                        }
                     });
                 }
             }
@@ -917,26 +1110,36 @@ class NaslServer {
             // 判断逻辑是否已经删除
             if (fileNode.parentNode instanceof concepts_1.App && !fileNode.parentNode.logics.includes(fileNode))
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
+                //OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
-                if ((node instanceof concepts_1.OqlQueryComponent || node instanceof concepts_1.SqlQueryComponent) && node.getTypeBanError()) {
-                    const diagnostic = {
-                        node,
-                        severity: 'error',
-                        message: 'SQL查询：返回类型内部,不支持复杂类型。',
-                    };
-                    node.tsErrorDetail = diagnostic;
-                    diagnostics.push(diagnostic);
-                }
+                // if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
+                //     const diagnostic = {
+                //         node,
+                //         severity: 'error',
+                //         message: 'SQL查询：返回类型内部,不支持复杂类型。',
+                //     };
+                //     node.tsErrorDetail = diagnostic;
+                //     diagnostics.push(diagnostic);
+                // }
                 if (node instanceof concepts_1.Return || node instanceof concepts_1.Variable) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
                         let used = false;
                         fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
-                            if (nodeIn
+                            if (!used && nodeIn
                                 && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))
                                 && nodeIn.toJS().includes(`${node.name} = `)) {
                                 used = true;
+                                if (!nodeIn.tsErrorDetail) {
+                                    const diagnostic = {
+                                        node: nodeIn,
+                                        severity: 'error',
+                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                    };
+                                    nodeIn.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                }
                             }
                         });
                         const msg = used ? '必须赋值有返回值的内容。' : '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
@@ -952,31 +1155,61 @@ class NaslServer {
                         node.tsErrorDetail = undefined;
                     }
                 }
-                this.checkMatchError(node, diagnostics);
+                this.checkNodeError(node, diagnostics);
+            });
+        }
+        if (fileNode instanceof concepts_1.Process) {
+            fileNode?.sourceMap.forEach((value, node) => {
+                this.checkNodeError(node, diagnostics);
             });
         }
         return diagnostics;
     }
-    checkMatchError(node, diagnostics) {
+    checkNodeError(node, diagnostics) {
         if (!node)
             return;
         // 如果节点是match的看看节点里是不是有重复的
         if (node instanceof concepts_1.Match) {
             const typeMap = {};
-            node.cases.forEach((item) => {
-                if (Array.isArray(item.patterns)) {
-                    item.patterns.forEach((pattern) => {
-                        if (pattern instanceof concepts_1.TypeAnnotation) {
-                            if (typeMap[pattern.sortedTypeKey]) {
-                                typeMap[pattern.sortedTypeKey].push(pattern);
-                            }
-                            else {
-                                typeMap[pattern.sortedTypeKey] = [pattern];
-                            }
+            if (node.expression?.__TypeAnnotation) {
+                const { typeName, typeNamespace } = node.expression.__TypeAnnotation;
+                if (typeName === 'Union' || typeName === 'Boolean' || typeNamespace?.endsWith('enums')) {
+                    node.cases.forEach((item) => {
+                        if (Array.isArray(item.patterns)) {
+                            item.patterns.forEach((pattern) => {
+                                if (pattern instanceof concepts_1.TypeAnnotation) {
+                                    if (typeMap[pattern.sortedTypeKey]) {
+                                        typeMap[pattern.sortedTypeKey].push(pattern);
+                                    }
+                                    else {
+                                        typeMap[pattern.sortedTypeKey] = [pattern];
+                                    }
+                                }
+                                else if (pattern instanceof concepts_1.MemberExpression) {
+                                    if (pattern.completeName && pattern.object?.namespace?.endsWith('enums')) {
+                                        const onlyKey = pattern.completeName;
+                                        if (typeMap[onlyKey]) {
+                                            typeMap[onlyKey].push(pattern);
+                                        }
+                                        else {
+                                            typeMap[onlyKey] = [pattern];
+                                        }
+                                    }
+                                }
+                                else if (pattern instanceof concepts_1.BooleanLiteral) {
+                                    const onlyKey = pattern.concept + pattern.value;
+                                    if (typeMap[onlyKey]) {
+                                        typeMap[onlyKey].push(pattern);
+                                    }
+                                    else {
+                                        typeMap[onlyKey] = [pattern];
+                                    }
+                                }
+                            });
                         }
                     });
                 }
-            });
+            }
             Object.keys(typeMap).forEach((item) => {
                 if (typeMap[item].length > 1) {
                     typeMap[item].forEach((nodeItem) => {
@@ -993,7 +1226,7 @@ class NaslServer {
             });
         }
         // 如果节点是match的patterns 里的
-        if (node.parentNode instanceof concepts_1.MatchCase && node.parentNode.patterns.includes(node)) {
+        if (node?.parentKey === 'patterns' && node.parentNode instanceof concepts_1.MatchCase) {
             const matchNode = node.getAncestor('Match');
             const matchExpressionType = matchNode?.expression?.__TypeAnnotation;
             // 判断union类型是不是重复
@@ -1010,10 +1243,32 @@ class NaslServer {
                     node.tsErrorDetail = diagnostic;
                     diagnostics.push(diagnostic);
                 }
+                // 如果TypeAnnotation 还存在，但是本身已经不是union类型，就是已经从union换别的类型了就都要报错
+            }
+            else if (node instanceof concepts_1.TypeAnnotation && matchExpressionType?.typeKind !== 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择类型不存在',
+                    titleTip: '该类型已被删除',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+                // 如果可枚举变量的 ，变量 还存在，但是本身已经是union类型，就是已经从别的类型 换了union就都要报错
+            }
+            else if (!(node instanceof concepts_1.TypeAnnotation) && matchExpressionType?.typeKind === 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择值不存在',
+                    titleTip: '该值无法匹配，请重新选择类型',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
             }
             if (node.tsErrorDetail) {
-                // console.log(matchExpressionType);
-                if (matchExpressionType?.typeNamespace?.includes('enums')) {
+                // 如果父级是枚举，而且子集选的是变量，就提示枚举值已被删除
+                if (matchExpressionType?.typeNamespace?.includes('enums') && (node instanceof concepts_1.MemberExpression)) {
                     node.tsErrorDetail.titleTip = '该枚举值已被删除';
                 }
                 else if (!node.tsErrorDetail.titleTip) {
@@ -1021,6 +1276,35 @@ class NaslServer {
                 }
             }
         }
+        // 如果forEach 中的each的内容是union类型就要提示报错
+        if (node?.parentKey === 'each' && node?.__TypeAnnotation?.typeKind === 'union') {
+            const diagnostic = {
+                node,
+                severity: 'error',
+                message: 'ForEach：参数类型不一致！传入类型：联合类型。接受类型：List类型。',
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
+        /**
+         * 如果节点是内置函数
+         * 穷举在线上的情况，不在线上就void报错， calllogic 和 callinterface 因为原来有报错，所以就忽略掉
+         * && 他在父级中，不在body
+         * && 也不再 if的线上
+         * && 也不再 switch的线上consequent
+         * && 也不再草稿区域
+         * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
+         * && 而且也没有类型，就说明在槽位里，就需要报错
+         */
+        if (node instanceof concepts_1.CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallLogic' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
+            const diagnostic = {
+                node,
+                severity: 'error',
+                message: `类型不一致，当前内置函数${node.calleeName || ''}无返回值。`,
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
     }
     /* 接口导入查找 */
     existStructureFix(semanticDiagnostics, node, that) {
@@ -1328,6 +1612,10 @@ class NaslServer {
                 return null;
             const minRange = this._findMinRange(record, fileNode);
             if (minRange) {
+                // 节点上ts临时变量标识，如果有这个就不rename
+                if (minRange.node.noTsReName) {
+                    return null;
+                }
                 // 如果节点是TypeAnnotation类型,
                 // 很复杂，可能是多级嵌套结构
                 // 不一定只修改typeName
@@ -1400,7 +1688,7 @@ class NaslServer {
                     // 因为要用下面的点位信息
                     const name = minRange.node.name;
                     // 如果name不改，那就是要改命名空间
-                    if (newValue === name) {
+                    if (node instanceof concepts_1.Frontend || newValue === name) {
                         const namespace = minRange.node.namespace;
                         // 先看下标位置
                         const lineText = record.lineText;
@@ -1414,10 +1702,16 @@ class NaslServer {
                         minRange.newValue = newTextValue;
                     }
                 }
-                // 如果是枚举修改，枚举的值刚好在Identifier 中选了 就修改值
-                if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Enum) {
-                    minRange.newValue = newValue;
-                    minRange.setTypeMethods = 'setName';
+                if (node instanceof concepts_1.Enum) {
+                    // 如果是枚举修改，枚举的值刚好在Identifier 中选了 就修改值
+                    if (minRange.node instanceof concepts_1.Identifier) {
+                        minRange.newValue = newValue;
+                        minRange.setTypeMethods = 'setName';
+                    }
+                    else if (minRange.node instanceof concepts_1.EntityProperty) {
+                        // 如果枚举自己改名引用到了实体字段，而不是实体字段下的类型，就说明是默认值，默认值可以不处理
+                        return null;
+                    }
                 }
                 // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
                 if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Logic) {
@@ -1517,6 +1811,24 @@ class NaslServer {
                         minRange.newValue = newTsNameSpace;
                     }
                 }
+                if (node instanceof concepts_1.Frontend && minRange.node instanceof concepts_1.Destination) {
+                    const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                    const tsName = minRange.node.tsName;
+                    const oldValue = tsCalleeNamespace + '.' + tsName;
+                    // 先看下标位置
+                    const lineText = record.lineText;
+                    const index = lineText.indexOf(oldValue);
+                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                    const start = record.start.offset - index - 1;
+                    const end = record.end.offset - index - 1;
+                    if (start <= tsCalleeNamespace.length) {
+                        // 新的完整的value
+                        let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                        minRange.setTypeMethods = 'setViewNamespace';
+                        newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                        minRange.newValue = newTsNameSpace;
+                    }
+                }
                 // 如果是事件修改
                 // 如果是view也需要加前缀
                 // logic 和 views名称修改 可能会触发bindEvent修改
@@ -1636,7 +1948,7 @@ class NaslServer {
                         minRange.newValue = newValue;
                     }
                     else if (minRange.node instanceof concepts_1.SqlQueryComponent || minRange.node instanceof concepts_1.OqlQueryComponent) {
-                        minRange.setTypeMethods = 'setDataSource';
+                        minRange.setTypeMethods = 'renameDataSource';
                     }
                 }
                 if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.EntityProperty) {
@@ -1713,8 +2025,7 @@ class NaslServer {
                 }
             }
             else {
-                console.log('没找到节点需要排查');
-                console.log(record, fileNode.sourceMap);
+                console.log('没找到节点需要排查', record, fileNode.sourceMap);
             }
             return minRange;
         })
@@ -1732,12 +2043,8 @@ class NaslServer {
             const minRange = this._findMinRange(record, fileNode);
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
-                if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
-                    minRange.node.setCalleeArgName(parantNode);
-                }
-                // 如果节点参数增加页面也要更新
-                if (minRange.node instanceof concepts_1.Destination && node instanceof concepts_1.Param) {
-                    minRange.node.setViewArgument(parantNode);
+                if ((minRange.node instanceof concepts_1.CallLogic || minRange.node instanceof concepts_1.Destination) && node instanceof concepts_1.Param) {
+                    minRange.node.addCalleeArg(parantNode);
                 }
             }
         });
@@ -2043,18 +2350,34 @@ class NaslServer {
         if (node instanceof concepts_1.BinaryExpression && (['==', '!=', '>', '<', '>=', '<='].includes(node.operator))) {
             return concepts_1.TypeAnnotation.createPrimitive('Boolean');
         }
-        // Convert是
-        if (node instanceof concepts_1.CallFunction && node.calleeNamespace === 'nasl.util' && node.calleeName === 'Convert') {
+        // Convert和new都是自身携带类型的，就不进行修改
+        if (node instanceof concepts_1.CallFunction && node.calleeNamespace === 'nasl.util' && (['Convert', 'New', 'FromString'].includes(node.calleeName))) {
+            if (node.typeArguments.length) {
+                return node.typeArguments[0];
+            }
+        }
+        // Convert和new都是自身携带类型的，就不进行修改
+        if (node instanceof concepts_1.CallLogic && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'jsonDeserialize')) {
             if (node.typeArguments.length) {
                 return node.typeArguments[0];
             }
         }
-        // --------------------------------下面的都是为了获取节点类型的， 全量标注走不进来------------------------------------------------------------------
+        // 特殊处理param有类型错误的
+        if (node instanceof concepts_1.Param) {
+            // index在nasl foreach上有脏数据
+            if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
+                return concepts_1.TypeAnnotation.createPrimitive('Integer');
+            }
+        }
         if (node instanceof concepts_1.CallQueryComponent || node instanceof concepts_1.SqlQueryComponent || node instanceof concepts_1.OqlQueryComponent) {
             return node.typeAnnotation;
         }
-        if (node instanceof concepts_1.NumericLiteral) {
-            return node.typeAnnotation;
+        // 老数据可能typeKind 的primitive缺失
+        if (node instanceof concepts_1.NumericLiteral && node.typeAnnotation) {
+            return concepts_1.TypeAnnotation.from({
+                ...node.typeAnnotation?.toJSON(),
+                typeKind: 'primitive',
+            });
         }
     }
     /**
@@ -2080,7 +2403,6 @@ class NaslServer {
             const nodeTypeAnnotation = this.getCurrentNodeKnownTypeAnnotation(node);
             if (nodeTypeAnnotation) {
                 types.set(node, nodeTypeAnnotation);
-                node.__TypeAnnotation = nodeTypeAnnotation;
                 return;
             }
             // 要通过自己或者依赖关系拿的，二次遍历
@@ -2095,7 +2417,7 @@ class NaslServer {
                 'Return',
                 'Variable',
             ].includes(node.concept) && node.typeAnnotation) {
-                node.__TypeAnnotation = node.typeAnnotation;
+                types.set(node, node.typeAnnotation);
                 return;
             }
             if (![
@@ -2109,6 +2431,9 @@ class NaslServer {
                 'Return',
                 'Variable',
                 'Match',
+                'NewComposite',
+                'NewList',
+                'NewMap',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2125,12 +2450,13 @@ class NaslServer {
                 // 如果没有括号 ，括号就在外面，就 -1
                 // 有括号就找到括号的位置 然后 -1
                 let indexOf = 0;
-                if (item.code.indexOf('(') === -1) {
+                if (!item.code.includes('(')) {
                     indexOf = -1;
                 }
                 else {
-                    if (item.code.includes('>(')) {
-                        indexOf = item.code.indexOf('<');
+                    // 如果有泛型先往前找一找
+                    if (item.code.includes('<')) {
+                        indexOf = Math.min(item.code.indexOf('<'), item.code.indexOf('('));
                     }
                     else {
                         indexOf = item.code.indexOf('(');
@@ -2159,11 +2485,21 @@ class NaslServer {
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
                 fileDetail.offset = newCode.length + 'return '.length;
             }
+            else if (['NewComposite', 'NewList', 'NewMap'].includes(node.concept)) {
+                fileDetail.line = item.range.end.line;
+                const indexOf = item.code.indexOf('return __newComposite');
+                let newCode = item.code.substring(0, indexOf);
+                newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+                fileDetail.offset = newCode.length + 'return '.length;
+            }
             args.push(fileDetail);
         });
+        console.time('请求');
         const resultMap = (await this.getNaslNodeTypeFull(args)).response;
+        console.timeEnd('请求');
         // console.log(resultMap);
         // const result = (await this.getNaslNodeQuickInfoFull(args)).response;
+        // console.log(result);
         args.forEach((arg, index) => {
             const { file, line, offset } = arg;
             const item = resultMap?.[file]?.[line]?.[offset];
@@ -2172,24 +2508,21 @@ class NaslServer {
             // console.log('原始：', displayString);
             // console.log('方案2：', item?.[0]?.nodeType);
             const nodeTypeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(item?.[0]?.nodeType);
-            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, item?.[0]?.nodeType);
+            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
             types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
-            newQuickInfoNodes[index].node.__TypeAnnotation = nodeTypeAnnotation;
-            newQuickInfoNodes[index].node.__nodeType = item?.[0]?.nodeType;
+            newQuickInfoNodes[index].node.__nodeType = Object.freeze(item?.[0]?.nodeType);
             // console.log('方案1：', displayString1);
         });
         getFromOthers.forEach((type, node) => {
             if (node instanceof concepts_1.Assignment) {
                 if (!types.get(node.left)) {
                     types.set(node.left, types.get(node.right));
-                    node.left.__TypeAnnotation = types.get(node.right);
                 }
             }
             else if (node instanceof concepts_1.Argument) {
                 // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
                 const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, types);
                 types.set(node, argType);
-                node.__TypeAnnotation = argType.typeAnnotation;
             }
             else if (node instanceof concepts_1.MatchCase) {
                 // matchCase的类型
@@ -2198,11 +2531,30 @@ class NaslServer {
                     const last = node.body[node.body.length - 1];
                     if (last.__TypeAnnotation) {
                         types.set(node, last.__TypeAnnotation);
-                        node.__TypeAnnotation = last.__TypeAnnotation;
                     }
                 }
             }
         });
+        // 重置类型状态, 并且赋值
+        types.forEach((value, node) => {
+            try {
+                // 因为node可能是经过处理的TypeAnnotation
+                node.__isCorrectTypeAnnotation = true;
+                if (value) {
+                    if (value instanceof concepts_1.TypeAnnotation) {
+                        node.__TypeAnnotation = Object.freeze(value);
+                    }
+                    else if (value.typeAnnotation) {
+                        node.__TypeAnnotation = Object.freeze(value.typeAnnotation);
+                    }
+                }
+            }
+            catch (err) {
+                if (globalThis.window) {
+                    console.log(err);
+                }
+            }
+        });
         // newQuickInfoNodes.forEach((itemDetail, index) => {
         //     const { node, filePath } = itemDetail;
         //     if (!result[index] || node.concept === 'Argument')
@@ -2250,12 +2602,10 @@ class NaslServer {
         //         types.set(node, argType);
         //     }
         // });
-        console.timeEnd('批量请求');
         return types;
     }
-    // 全量标注
+    // 全量标注并且返回json
     async getNaslAnnotatedJSON(app, releaseFlag) {
-        // 全量标注
         console.time('全量标注');
         const nodes = [];
         this.file2NodeMap.forEach((fileNode, filePath) => {
@@ -2277,14 +2627,13 @@ class NaslServer {
         const json = app.toJSON();
         if (releaseFlag) {
             // 全量标注后对json进行一些修改，为了服务端翻译处理
-            this.annitationToJson(typesMap, json);
+            this.annotationToJson(typesMap, json);
         }
         return json;
     }
     // 加载全量nasl节点标注
     async createdNaslAnnotatedJSON(app) {
         // 全量标注
-        console.time('全量标注');
         const nodes = [];
         this.file2NodeMap.forEach((fileNode, filePath) => {
             // 先不排除view，传递给后端的时候，去除views下的标注
@@ -2299,10 +2648,10 @@ class NaslServer {
             }
         });
         await this.getQuickInfoNodesTypeMap(nodes, true);
-        console.timeEnd('全量标注');
     }
     // 增量标注
     async IncrementalAnnotationJSON(records) {
+        console.time('增量标注');
         const nodes = [];
         records.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.filePath);
@@ -2321,8 +2670,9 @@ class NaslServer {
             }
         });
         await this.getQuickInfoNodesTypeMap(nodes);
+        console.timeEnd('增量标注');
     }
-    annitationToJson(typesMap, json) {
+    annotationToJson(typesMap, json) {
         typesMap.forEach((value, node) => {
             // 如果节点本身有类型就不去在塞一遍了
             // 有值而且没有类型再去设置
@@ -2339,8 +2689,8 @@ class NaslServer {
                     }
                 }
             }
-            if (node instanceof concepts_1.CallQueryComponent && node.ideVersion !== '2.11' && node.typeAnnotation.properties
-                && (node.typeAnnotation.properties.length !== 2 || node.typeAnnotation.properties[0].name !== 'list')) {
+            // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
+            if (node instanceof concepts_1.CallQueryComponent && node.ideVersion !== '2.11') {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 jsonNode.typeAnnotation = {
                     concept: 'TypeAnnotation',
@@ -2383,6 +2733,14 @@ class NaslServer {
                         }],
                 };
             }
+            // 特殊处理param有类型错误的
+            if (node instanceof concepts_1.Param) {
+                // index在nasl foreach上有脏数据
+                if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
+                    const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Integer').toJSON();
+                }
+            }
             if (node instanceof concepts_1.Match) {
                 const matchExpression = node.expression;
                 if (matchExpression?.__TypeAnnotation?.typeKind === 'union' && (matchExpression instanceof concepts_1.Identifier || matchExpression instanceof concepts_1.MemberExpression)) {
@@ -2395,6 +2753,14 @@ class NaslServer {
                     });
                 }
             }
+            // 特殊处理param有类型错误的
+            if (node instanceof concepts_1.Param && value) {
+                // index在nasl foreach上有脏数据
+                if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
+                    const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                    jsonNode.typeAnnotation = value.toJSON();
+                }
+            }
         });
     }
     /**
@@ -2433,7 +2799,7 @@ class NaslServer {
         // 用户自己声明的用用户的
         const callObj = App.findNodeByCompleteName(parent.calleeNamespace + '.' + parent.calleeName);
         const index = parent.arguments.indexOf(node);
-        const param = callObj?.params[index] || {};
+        const param = callObj?.params?.[index] || {};
         // 取出参数的类型
         // 设置类型
         return {
@@ -2442,19 +2808,24 @@ class NaslServer {
             option: { defaultValue: param.defaultValue },
         };
     }
-    async getCurrentTypeAnnotation(node) {
+    async getCurrentTypeAnnotation(node, outTime = 600) {
         if (node.__TypeAnnotation) {
             return node.__TypeAnnotation;
         }
         return new Promise((resolve, reject) => {
             const myTimer = setTimeout(() => {
-                console.log(node, '没有获取到类型');
+                console.warn(node, '没有获取到类型');
                 clearTimeout(myTimer);
                 clearInterval(mySetInterval);
-                resolve(node.__TypeAnnotation);
-            }, 600);
+                if (node.__isCorrectTypeAnnotation) {
+                    resolve(node.__TypeAnnotation);
+                }
+                else {
+                    resolve(null);
+                }
+            }, outTime);
             const mySetInterval = setInterval(() => {
-                if (node.__TypeAnnotation) {
+                if (node.__isCorrectTypeAnnotation) {
                     resolve(node.__TypeAnnotation);
                     clearInterval(mySetInterval);
                     clearTimeout(myTimer);
@@ -2508,320 +2879,336 @@ class NaslServer {
         const result = await this._getTypeStrFull(args);
         return result;
     }
-}
-exports.NaslServer = NaslServer;
-const naslServer = new NaslServer();
-/**
- * 处理删除节点
- * @param fileNode 当前删除节点的文件级别节点
- * @param targetNode 当前操作的节点
- * @param result toTs生成的内容
- */
-async function handleDelete(fileNode, targetNode, result) {
-    const filePath = fileNode.getEmbeddedFilePath();
-    // 如果要删除，而且当前要删Logic就直接删除并且清除错误
     /**
-     * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
+     * 处理删除节点
+     * @param fileNode 当前删除节点的文件级别节点
+     * @param targetNode 当前操作的节点
+     * @param result toTs生成的内容
      */
-    let outputFiles = [];
-    // 删除之前先查一下内容的依赖
-    const newRefs = await naslServer.references({
-        file: result.filePath,
-        line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
-        offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
-    });
-    // 如果是要删除的内容，就是当前的file节点，要关闭当前文件，就把内容置为空
-    if (fileNode === targetNode) {
-        outputFiles = [{ file: filePath, fileContent: '' }];
-    }
-    else {
-        // 如果是要删除logic一个小内容，要覆盖全部内容
-        // 其余要删除的都是把原来的file节点的内容全部覆盖一把
-        outputFiles = [{ file: result.filePath, fileContent: result.code }];
-    }
-    // 更新文件之后
-    await naslServer.updateFiles({ outputFiles });
-    newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-}
-/**
- * 除去rename场景下的更新
- * @param fileNode 文件级别的节点
- * @param targetNode 触发修改的节点
- * @param result 生成代码的code 和位置信息
- */
-async function handleChange(fileNode, targetNode, result, action) {
-    naslServer.file2NodeMap.set(result.filePath, fileNode);
-    const outputFiles = [{ file: result.filePath, fileContent: result.code }];
-    // 创建和更新都用update，内部会做判断
-    await naslServer.updateFiles({ outputFiles });
-    // 查一下新函数名的依赖
-    const newRefs = await naslServer.references({
-        file: result.filePath,
-        line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
-        offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
-    });
-    newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-    // 唤起建立连接弹框
-    // 文件级别的建立连接采取提醒
-    if (action === 'create' && targetNode.__init) {
-        // 清除临时状态, 完成本次创建
-        delete targetNode.__init;
-        if (fileNode === targetNode && filesToCheck.size > 1) {
-            const confirmParms = {
-                actionType: 'createEstablishConnection',
-                node: fileNode,
-                icon: 'success',
-            };
-            (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => { });
-        }
-    }
-}
-/**
- * 重命名的更新
- * @param fileNode 文件级别的节点
- * @param targetNode 触发修改的节点
- * @param result 生成代码的code 和位置信息
- * @param isRename 是不是修改名字
- * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
- */
-async function handleRename(fileNode, targetNode, result, oldFilePath) {
-    // rename 场景
-    const outputFiles = [{ file: result.filePath, fileContent: result.code }];
-    // 如果是要修改顶级文件名
-    // file节点和当前改得是同一节点
-    if (fileNode === targetNode) {
-        naslServer.file2NodeMap.delete(oldFilePath);
-        naslServer.file2NodeMap.set(result.filePath, fileNode);
-        // 修改名字新的添加进去，旧的置为空
-        outputFiles.unshift({ file: oldFilePath, fileContent: '' });
-        // 查一下旧文件名的依赖
-        const oldRefs = await naslServer.references({
-            file: oldFilePath,
+    async handleDelete(fileNode, targetNode, result) {
+        const filePath = fileNode.getEmbeddedFilePath();
+        // 如果要删除，而且当前要删Logic就直接删除并且清除错误
+        /**
+         * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
+         */
+        let outputFiles = [];
+        // 删除之前先查一下内容的依赖
+        const newRefs = await this.references({
+            file: result.filePath,
             line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
             offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
         });
-        oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-        filesToCheck.delete(oldFilePath);
+        // 如果是要删除的内容，就是当前的file节点，要关闭当前文件，就把内容置为空
+        if (fileNode === targetNode) {
+            outputFiles = [{ file: filePath, fileContent: '' }];
+        }
+        else {
+            // 如果是要删除logic一个小内容，要覆盖全部内容
+            // 其余要删除的都是把原来的file节点的内容全部覆盖一把
+            outputFiles = [{ file: result.filePath, fileContent: result.code }];
+        }
         // 更新文件之后
-        await naslServer.updateFiles({ outputFiles });
+        await this.updateFiles({ outputFiles });
+        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+    }
+    /**
+     * 除去rename场景下的更新
+     * @param fileNode 文件级别的节点
+     * @param targetNode 触发修改的节点
+     * @param result 生成代码的code 和位置信息
+     */
+    async handleChange(fileNode, targetNode, result, action) {
+        this.file2NodeMap.set(result.filePath, fileNode);
+        const outputFiles = [{ file: result.filePath, fileContent: result.code }];
+        // 创建和更新都用update，内部会做判断
+        await this.updateFiles({ outputFiles });
         // 查一下新函数名的依赖
-        const newRefs = await naslServer.references({
+        const newRefs = await this.references({
             file: result.filePath,
             line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
             offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
         });
-        const newRefFileList = new Set();
-        newRefs.refs.forEach((ref) => {
-            filesToCheck.add(ref.file);
-            newRefFileList.add(ref.file);
-        });
-        // 文件级别重命名，有依赖才唤起弹框
-        // 唤起重命名，提示有连接弹框
-        // 重命名建立连接先不展示弹框了
-        // if (newRefFileList.size > 1) {
-        //     const confirmParms = {
-        //         actionType: 'renameEstablishConnection',
-        //         node: fileNode,
-        //         icon: 'success',
-        //     };
-        //     invokeCommand('tsConfirm.open', confirmParms, () => {});
-        // }
-    }
-    else if (targetNode instanceof concepts_1.ViewElement) {
-        /**
-         * 因为页面组件比较特殊
-         * 修改之后只用查页面本身就好了
-         */
-        // 更新文件之后
-        await naslServer.updateFiles({ outputFiles });
-        const newRefs2 = await naslServer.references({
-            file: fileNode.getEmbeddedFilePath(),
-            line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
-            offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
-        });
-        newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+        // 唤起建立连接弹框
+        // 文件级别的建立连接采取提醒
+        if (action === 'create' && targetNode.__init) {
+            // 清除临时状态, 完成本次创建
+            delete targetNode.__init;
+            if (fileNode === targetNode && this.filesToCheck.size > 1) {
+                const confirmParms = {
+                    actionType: 'createEstablishConnection',
+                    node: fileNode,
+                    icon: 'success',
+                };
+                (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => { });
+            }
+        }
     }
-    else {
-        // 查一下当前属性依赖的文件
-        const { currentSource, fileNode } = naslServer.getCurrentSource(targetNode);
-        // 如果当前节点存在
-        if (currentSource) {
+    /**
+ * 重命名的更新
+ * @param fileNode 文件级别的节点
+ * @param targetNode 触发修改的节点
+ * @param result 生成代码的code 和位置信息
+ * @param isRename 是不是修改名字
+ * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
+ */
+    async handleRename(fileNode, targetNode, result, oldFilePath) {
+        // rename 场景
+        const outputFiles = [{ file: result.filePath, fileContent: result.code }];
+        // 如果是要修改顶级文件名
+        // file节点和当前改得是同一节点
+        if (fileNode === targetNode) {
+            this.file2NodeMap.delete(oldFilePath);
+            this.file2NodeMap.set(result.filePath, fileNode);
+            // 修改名字新的添加进去，旧的置为空
+            outputFiles.unshift({ file: oldFilePath, fileContent: '' });
+            // 查一下旧文件名的依赖
+            const oldRefs = await this.references({
+                file: oldFilePath,
+                line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
+                offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
+            });
+            oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+            this.filesToCheck.delete(oldFilePath);
+            // 更新文件之后
+            await this.updateFiles({ outputFiles });
+            // 查一下新函数名的依赖
+            const newRefs = await this.references({
+                file: result.filePath,
+                line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
+                offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
+            });
+            const newRefFileList = new Set();
+            newRefs.refs.forEach((ref) => {
+                this.filesToCheck.add(ref.file);
+                newRefFileList.add(ref.file);
+            });
+            // 文件级别重命名，有依赖才唤起弹框
+            // 唤起重命名，提示有连接弹框
+            // 重命名建立连接先不展示弹框了
+            // if (newRefFileList.size > 1) {
+            //     const confirmParms = {
+            //         actionType: 'renameEstablishConnection',
+            //         node: fileNode,
+            //         icon: 'success',
+            //     };
+            //     invokeCommand('tsConfirm.open', confirmParms, () => {});
+            // }
+        }
+        else if (targetNode instanceof concepts_1.ViewElement) {
             /**
-             * 其余的节点修改之后直接查本身就可以了
+             * 因为页面组件比较特殊
+             * 修改之后只用查页面本身就好了
              */
-            const oldRefs = await naslServer.references({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-            });
-            oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
             // 更新文件之后
-            await naslServer.updateFiles({ outputFiles });
-            const newRefs2 = await naslServer.references({
+            await this.updateFiles({ outputFiles });
+            const newRefs2 = await this.references({
                 file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
+                line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
+                offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
             });
-            newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+            newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+        }
+        else {
+            // 查一下当前属性依赖的文件
+            const { currentSource, fileNode } = this.getCurrentSource(targetNode);
+            // 如果当前节点存在
+            if (currentSource) {
+                /**
+                 * 其余的节点修改之后直接查本身就可以了
+                 */
+                const oldRefs = await this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
+                });
+                oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+                // 更新文件之后
+                await this.updateFiles({ outputFiles });
+                const newRefs2 = await this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
+                });
+                newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+            }
         }
     }
-}
-/**
- * 处理一些节点操作，子节点需要更新并且check的场景
- * 因为删除，新增父页面，或者重命名会一起
- * 删除或者新增view而且他有子集 就要执行同样的操作
- * @param action 当前操作类型
- * @param fileNode 文件节点
- * @param targetNode 操作节点  这里要两个相等才会走家去面对哦逻辑
- * @param oldpath 触发内容的oldpath
- */
-async function incidentalAction(action, fileNode, targetNode, oldpath) {
-    if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
-        // 删除或者新增页面
-        if (fileNode instanceof concepts_1.View && fileNode.children?.length) {
-            const fileNodeChildren = fileNode.children;
-            for (let i = 0; i < fileNodeChildren.length; i++) {
-                const fileNodeItem = fileNodeChildren[i];
-                const result = fileNodeItem.toEmbeddedTSFile();
-                fileNodeItem.sourceMap = result.sourceMap;
-                if (action === 'create') {
-                    await handleChange(fileNodeItem, fileNodeItem, result, action);
-                    await incidentalAction(action, fileNodeItem, fileNodeItem);
-                }
-                else if (action === 'delete') {
-                    await handleDelete(fileNodeItem, fileNodeItem, result);
-                    await incidentalAction(action, fileNodeItem, fileNodeItem);
-                }
-                else if (action === 'update' && oldpath) {
-                    const parentPath = oldpath.replace('.ts', '/');
-                    const currentOldPath = parentPath + fileNodeItem.name + '.ts';
-                    // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
-                    await handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
-                    await incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
-                }
-            }
-        }
-        // 删除或新增模块
-        // 需要把下面的哦内容全部都更新一遍
-        if (fileNode instanceof concepts_1.Module) {
-            if (fileNode.type === 'interface' && fileNode.isAdd && action === 'create') {
-                isChangeInterface = true;
-            }
-            const module = targetNode;
-            const results = [];
-            naslServer.contentToFile(module, results);
-            for (let i = 0; i < results.length; i++) {
-                const result = results[i];
-                const node = naslServer.file2NodeMap.get(result.filePath);
-                if (action === 'create') {
-                    await handleChange(node, node, result, action);
+    /**
+     * 处理一些节点操作，子节点需要更新并且check的场景
+     * 因为删除，新增父页面，或者重命名会一起
+     * 删除或者新增view而且他有子集 就要执行同样的操作
+     * @param action 当前操作类型
+     * @param fileNode 文件节点
+     * @param targetNode 操作节点  这里要两个相等才会走家去面对哦逻辑
+     * @param oldpath 触发内容的oldpath
+     */
+    async incidentalAction(action, fileNode, targetNode, oldpath) {
+        if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
+            //删除、更改、新增端
+            if (fileNode instanceof concepts_1.Frontend && (fileNode.views?.length || fileNode.variables?.length)) {
+                const fileNodeChildren = [...fileNode.views, ...fileNode.variables];
+                for (let i = 0; i < fileNodeChildren.length; i++) {
+                    const fileNodeItem = fileNodeChildren[i];
+                    const result = fileNodeItem.toEmbeddedTSFile();
+                    fileNodeItem.sourceMap = result.sourceMap;
+                    if (action === 'create') {
+                        await this.handleChange(fileNodeItem, fileNodeItem, result, action);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'delete') {
+                        await this.handleDelete(fileNodeItem, fileNodeItem, result);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'update' && oldpath) {
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const foldName = fileNodeItem.concept === 'View' ? 'views' : 'variables';
+                        const currentOldPath = parentPath + foldName + '/' + fileNodeItem.name + '.ts';
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
+                    }
                 }
-                else {
-                    await handleDelete(node, node, result);
+            }
+            // 删除或者新增页面
+            if (fileNode instanceof concepts_1.View && fileNode.children?.length) {
+                const fileNodeChildren = fileNode.children;
+                for (let i = 0; i < fileNodeChildren.length; i++) {
+                    const fileNodeItem = fileNodeChildren[i];
+                    const result = fileNodeItem.toEmbeddedTSFile();
+                    fileNodeItem.sourceMap = result.sourceMap;
+                    if (action === 'create') {
+                        await this.handleChange(fileNodeItem, fileNodeItem, result, action);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'delete') {
+                        await this.handleDelete(fileNodeItem, fileNodeItem, result);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'update' && oldpath) {
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const currentOldPath = parentPath + fileNodeItem.name + '.ts';
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
+                    }
                 }
             }
-            // 删除模块通知更新列表
-            if (action === 'delete') {
-                try {
-                    // 如果已经
-                    (0, common_1.invokeCommand)('module.delete', true);
+            // 删除或新增模块
+            // 需要把下面的哦内容全部都更新一遍
+            if (fileNode instanceof concepts_1.Module) {
+                if (fileNode.type === 'interface' && fileNode.isAdd && action === 'create') {
+                    isChangeInterface = true;
+                }
+                const module = targetNode;
+                const results = [];
+                this.contentToFile(module, results);
+                for (let i = 0; i < results.length; i++) {
+                    const result = results[i];
+                    const node = this.file2NodeMap.get(result.filePath);
+                    if (action === 'create') {
+                        await this.handleChange(node, node, result, action);
+                    }
+                    else {
+                        await this.handleDelete(node, node, result);
+                    }
                 }
-                catch (err) {
-                    console.log('module.delete', '组件销毁了,不用唤起了');
+                // 删除模块通知更新列表
+                if (action === 'delete') {
+                    try {
+                        // 如果已经
+                        (0, common_1.invokeCommand)('module.delete', true);
+                    }
+                    catch (err) {
+                        console.log('module.delete', '组件销毁了,不用唤起了');
+                    }
                 }
             }
-        }
-        /**
+            /**
          * DataSource只会重命名时候，需要把子集全部重新生成一下
          */
-        if (fileNode instanceof concepts_1.DataSource) {
-            fileNode.entities.forEach(async (entity) => {
-                try {
-                    const result = entity.toEmbeddedTSFile();
-                    const parentPath = oldpath.replace('.ts', '/');
-                    const currentOldPath = parentPath + '/entities/' + entity.name + '.ts';
-                    // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
-                    await handleRename(entity, entity, result, currentOldPath);
-                }
-                catch (err) {
-                    console.log(err);
-                }
-            });
+            if (fileNode instanceof concepts_1.DataSource) {
+                fileNode.entities.forEach(async (entity) => {
+                    try {
+                        const result = entity.toEmbeddedTSFile();
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const currentOldPath = parentPath + '/entities/' + entity.name + '.ts';
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(entity, entity, result, currentOldPath);
+                    }
+                    catch (err) {
+                        console.log(err);
+                    }
+                });
+            }
         }
     }
-}
-async function receiveHandleChange($event) {
-    // 行为
-    const action = $event.action;
-    const targetNode = $event.target;
-    // 当前操作的文件节点
-    const { fileNode } = naslServer.getCurrentSource(targetNode);
-    // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
-    if (!fileNode || fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration) {
-        // module单独处理
-        if (fileNode instanceof concepts_1.Module) {
-            await incidentalAction(action, fileNode, targetNode);
-        }
-        return;
-    }
-    const result = fileNode.toEmbeddedTSFile();
-    // 当前操作的节点
-    // 如果当前没有生成tsFile
-    if (!result) {
-        return;
-    }
-    // 修改触发修改文件
-    naslServer._debugInFileStorage($event.currentTarget, [
-        {
-            file: result.filePath,
-            fileContent: result.code,
-        },
-    ]);
-    fileNode.sourceMap = result.sourceMap;
-    if (action === 'update' || action === 'create') {
-        if ($event?.field !== 'name') {
-            await handleChange(fileNode, targetNode, result, action);
-            await incidentalAction(action, fileNode, targetNode);
+    async receiveHandleChange($event) {
+        this.singleFileChangeIng = true;
+        // 行为
+        const action = $event.action;
+        const targetNode = $event.target;
+        // 当前操作的文件节点
+        const { fileNode } = this.getCurrentSource(targetNode);
+        // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
+        if (!fileNode || fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration) {
+            // module单独处理
+            if (fileNode instanceof concepts_1.Module) {
+                await this.incidentalAction(action, fileNode, targetNode);
+            }
+            return;
         }
-        else {
-            const oldpath = fileNode.getEmbeddedFilePath($event.oldObject.name);
-            await handleRename(fileNode, targetNode, result, oldpath);
-            await incidentalAction(action, fileNode, targetNode, oldpath);
+        const result = fileNode.toEmbeddedTSFile();
+        // 当前操作的节点
+        // 如果当前没有生成tsFile
+        if (!result) {
+            return;
         }
-    }
-    // 删除
-    if (action === 'delete') {
-        await incidentalAction(action, fileNode, targetNode);
-        await handleDelete(fileNode, targetNode, result);
-    }
-    return true;
-}
-// 监听所有改变操作
-translator_1.embeddedTSEmitter.on('change', ($event) => {
-    // 收集到一个行为集合
-    const eventValue = $event.value;
-    const stackList = [];
-    eventValue.forEach(async (item) => {
-        stackList.push(item.originEvent);
-    });
-    // 异步状态机,一个完成了在执行下一个
-    function next() {
-        const item = stackList.shift();
-        receiveHandleChange(item).then(async () => {
-            if (stackList.length) {
-                next();
+        // 修改触发修改文件
+        this._debugInFileStorage(targetNode, [
+            {
+                file: result.filePath,
+                fileContent: result.code,
+            },
+        ]);
+        fileNode.sourceMap = result.sourceMap;
+        if (action === 'update' || action === 'create') {
+            if ($event?.field !== 'name') {
+                await this.handleChange(fileNode, targetNode, result, action);
+                await this.incidentalAction(action, fileNode, targetNode);
             }
             else {
-                await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-                filesToCheck.clear();
+                const oldpath = fileNode.getEmbeddedFilePath($event.oldObject.name);
+                await this.handleRename(fileNode, targetNode, result, oldpath);
+                await this.incidentalAction(action, fileNode, targetNode, oldpath);
             }
-        });
+        }
+        // 删除
+        if (action === 'delete') {
+            await this.incidentalAction(action, fileNode, targetNode);
+            await this.handleDelete(fileNode, targetNode, result);
+        }
+        return true;
     }
-    // 如果有长度开始执行状态机
-    if (stackList.length) {
-        next();
+    changeFileNext() {
+        if (!this.singleFileChangeIng) {
+            const item = this.changeStackList.shift();
+            this.receiveHandleChange(item).catch((err) => {
+                console.log(err, 'receiveHandleChangeErr');
+            }).finally(async () => {
+                // 每一个文件与change接触就把状态置为false，让下一个进入
+                this.singleFileChangeIng = false;
+                if (this.changeStackList.length) {
+                    this.changeFileNext();
+                }
+                else {
+                    console.log(Array.from(this.filesToCheck));
+                    await this.getDiagnosticRecordsAndPushAll(Array.from(this.filesToCheck));
+                    this.filesToCheck.clear();
+                }
+            });
+        }
     }
-});
-// naslServer.messager.options.context = naslServer;
-exports.default = naslServer;
+}
+exports.NaslServer = NaslServer;
 //# sourceMappingURL=naslServer.js.map