@lcap/nasl 2.18.0 → 2.20.0-beta.1

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 = exports.getDisplayString2Type = void 0;
+exports.NaslServer = void 0;
 /// #if process.env.BUILD_TARGET === 'node'
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
@@ -46,7 +46,6 @@ 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,
 };
@@ -55,40 +54,9 @@ const EmbeddedTSFileOffsetMap = {
 };
 // 要Check的文件
 const filesToCheck = new Set();
-// 单个文件正在change，不允许同时两个文件一起change
-let singleFileChangeIng = false;
 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;
@@ -101,9 +69,6 @@ class NaslServer {
     elementsLogic = {};
     // 错误日志收集
     diagnosticManager = undefined;
-    embeddedTSEmitter = undefined;
-    // 需要执行修改的文件
-    changeStackList = [];
     constructor() {
         /// #if process.env.BUILD_TARGET === 'node'
         if (globalThis.process) // For TS build
@@ -128,26 +93,10 @@ class NaslServer {
                 }
             },
         });
-        // 监听所有改变操作
-        this.embeddedTSEmitter = new EventEmitter_1.EventEmitter();
-        this.embeddedTSEmitter.on('change', ($event) => {
-            // 收集到一个行为集合
-            const eventValue = $event.value;
-            eventValue.forEach(async (item) => {
-                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文件
@@ -422,6 +371,32 @@ 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 传入当前已经选择的变量
@@ -444,7 +419,7 @@ class NaslServer {
                 });
                 if (quickInfo.responseRequired) {
                     const displayString = quickInfo?.response?.displayString || '';
-                    const typeList = getDisplayString2Type(displayString);
+                    const typeList = this.getDisplayString2Type(displayString);
                     const res = [];
                     typeList.forEach((type) => {
                         const typeAnnotation = coreTypeList_1.primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
@@ -502,17 +477,6 @@ 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);
@@ -538,49 +502,6 @@ 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);
-            let 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 文件信息数组
@@ -694,17 +615,6 @@ 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);
@@ -804,7 +714,7 @@ class NaslServer {
                                         }),
                                     ];
                                 }
-                                if (Array.isArray(enumerableItems) && enumerableItems.length) {
+                                if (Array.isArray(enumerableItems)) {
                                     const map = {};
                                     cases.forEach((caseItem) => {
                                         const { patterns } = caseItem || {};
@@ -903,33 +813,18 @@ class NaslServer {
             }
             if (removed)
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode.traverseChildren((node) => {
                 if (node instanceof concepts_1.ViewElement && node.view === fileNode) {
                     if (node.tag) {
                         node.bindAttrs.forEach((bindAttr) => {
-                            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);
-                                }
+                            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);
                             }
                         });
                     }
@@ -947,37 +842,30 @@ class NaslServer {
                                 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 内局部变量、输入参数直接提示系统无法推断类型
-                                    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 = '系统无法推断类型。';
+                                    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)
+                                        msg = '系统无法推断类型。';
                                 }
-                                if (!nodeIn.tsErrorDetail) {
-                                    const diagnostic = {
-                                        node: nodeIn,
-                                        severity: 'error',
-                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
-                                    };
-                                    nodeIn.tsErrorDetail = diagnostic;
-                                    diagnostics.push(diagnostic);
+                                else {
+                                    msg = '必须赋值有返回值的内容。';
                                 }
-                                msg = '必须赋值有返回值的内容。';
                             }
                         });
                         if (!msg)
@@ -990,9 +878,12 @@ class NaslServer {
                         node.tsErrorDetail = diagnostic;
                         diagnostics.push(diagnostic);
                     }
+                    else {
+                        node.tsErrorDetail = undefined;
+                    }
                 }
                 else {
-                    this.checkNodeError(node, diagnostics);
+                    this.checkMatchError(node, diagnostics);
                 }
             });
         }
@@ -1042,19 +933,10 @@ class NaslServer {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
                         let used = false;
                         fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
-                            if (!used && nodeIn
+                            if (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 ? '必须赋值有返回值的内容。' : '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
@@ -1070,56 +952,31 @@ class NaslServer {
                         node.tsErrorDetail = undefined;
                     }
                 }
-                this.checkNodeError(node, diagnostics);
+                this.checkMatchError(node, diagnostics);
             });
         }
         return diagnostics;
     }
-    checkNodeError(node, diagnostics) {
+    checkMatchError(node, diagnostics) {
         if (!node)
             return;
         // 如果节点是match的看看节点里是不是有重复的
         if (node instanceof concepts_1.Match) {
             const typeMap = {};
-            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];
-                                    }
-                                }
-                            });
+            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];
+                            }
                         }
                     });
                 }
-            }
+            });
             Object.keys(typeMap).forEach((item) => {
                 if (typeMap[item].length > 1) {
                     typeMap[item].forEach((nodeItem) => {
@@ -1136,7 +993,7 @@ class NaslServer {
             });
         }
         // 如果节点是match的patterns 里的
-        if (node?.parentKey === 'patterns' && node.parentNode instanceof concepts_1.MatchCase) {
+        if (node.parentNode instanceof concepts_1.MatchCase && node.parentNode.patterns.includes(node)) {
             const matchNode = node.getAncestor('Match');
             const matchExpressionType = matchNode?.expression?.__TypeAnnotation;
             // 判断union类型是不是重复
@@ -1155,6 +1012,7 @@ class NaslServer {
                 }
             }
             if (node.tsErrorDetail) {
+                // console.log(matchExpressionType);
                 if (matchExpressionType?.typeNamespace?.includes('enums')) {
                     node.tsErrorDetail.titleTip = '该枚举值已被删除';
                 }
@@ -1163,16 +1021,6 @@ 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);
-        }
     }
     /* 接口导入查找 */
     existStructureFix(semanticDiagnostics, node, that) {
@@ -1480,10 +1328,6 @@ class NaslServer {
                 return null;
             const minRange = this._findMinRange(record, fileNode);
             if (minRange) {
-                // 节点上ts临时变量标识，如果有这个就不rename
-                if (minRange.node.noTsReName) {
-                    return null;
-                }
                 // 如果节点是TypeAnnotation类型,
                 // 很复杂，可能是多级嵌套结构
                 // 不一定只修改typeName
@@ -1570,16 +1414,10 @@ class NaslServer {
                         minRange.newValue = newTextValue;
                     }
                 }
-                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.Enum) {
+                    minRange.newValue = newValue;
+                    minRange.setTypeMethods = 'setName';
                 }
                 // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
                 if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Logic) {
@@ -1798,7 +1636,7 @@ class NaslServer {
                         minRange.newValue = newValue;
                     }
                     else if (minRange.node instanceof concepts_1.SqlQueryComponent || minRange.node instanceof concepts_1.OqlQueryComponent) {
-                        minRange.setTypeMethods = 'renameDataSource';
+                        minRange.setTypeMethods = 'setDataSource';
                     }
                 }
                 if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.EntityProperty) {
@@ -1875,7 +1713,8 @@ class NaslServer {
                 }
             }
             else {
-                console.log('没找到节点需要排查', record, fileNode.sourceMap);
+                console.log('没找到节点需要排查');
+                console.log(record, fileNode.sourceMap);
             }
             return minRange;
         })
@@ -2204,34 +2043,18 @@ class NaslServer {
         if (node instanceof concepts_1.BinaryExpression && (['==', '!=', '>', '<', '>=', '<='].includes(node.operator))) {
             return concepts_1.TypeAnnotation.createPrimitive('Boolean');
         }
-        // Convert和new都是自身携带类型的，就不进行修改
-        if (node instanceof concepts_1.CallFunction && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'Convert' || node.calleeName === 'New')) {
-            if (node.typeArguments.length) {
-                return node.typeArguments[0];
-            }
-        }
-        // Convert和new都是自身携带类型的，就不进行修改
-        if (node instanceof concepts_1.CallLogic && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'jsonDeserialize')) {
+        // Convert是
+        if (node instanceof concepts_1.CallFunction && node.calleeNamespace === 'nasl.util' && node.calleeName === 'Convert') {
             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;
         }
-        // 老数据可能typeKind 的primitive缺失
-        if (node instanceof concepts_1.NumericLiteral && node.typeAnnotation) {
-            return concepts_1.TypeAnnotation.from({
-                ...node.typeAnnotation?.toJSON(),
-                typeKind: 'primitive',
-            });
+        if (node instanceof concepts_1.NumericLiteral) {
+            return node.typeAnnotation;
         }
     }
     /**
@@ -2257,6 +2080,7 @@ class NaslServer {
             const nodeTypeAnnotation = this.getCurrentNodeKnownTypeAnnotation(node);
             if (nodeTypeAnnotation) {
                 types.set(node, nodeTypeAnnotation);
+                node.__TypeAnnotation = nodeTypeAnnotation;
                 return;
             }
             // 要通过自己或者依赖关系拿的，二次遍历
@@ -2271,7 +2095,7 @@ class NaslServer {
                 'Return',
                 'Variable',
             ].includes(node.concept) && node.typeAnnotation) {
-                types.set(node, node.typeAnnotation);
+                node.__TypeAnnotation = node.typeAnnotation;
                 return;
             }
             if (![
@@ -2301,13 +2125,12 @@ class NaslServer {
                 // 如果没有括号 ，括号就在外面，就 -1
                 // 有括号就找到括号的位置 然后 -1
                 let indexOf = 0;
-                if (!item.code.includes('(')) {
+                if (item.code.indexOf('(') === -1) {
                     indexOf = -1;
                 }
                 else {
-                    // 如果有泛型先往前找一找
-                    if (item.code.includes('<')) {
-                        indexOf = Math.min(item.code.indexOf('<'), item.code.indexOf('('));
+                    if (item.code.includes('>(')) {
+                        indexOf = item.code.indexOf('<');
                     }
                     else {
                         indexOf = item.code.indexOf('(');
@@ -2338,12 +2161,9 @@ class NaslServer {
             }
             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];
@@ -2352,21 +2172,24 @@ 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, nodeTypeAnnotation?.typeKey);
+            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, item?.[0]?.nodeType);
             types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
-            newQuickInfoNodes[index].node.__nodeType = Object.freeze(item?.[0]?.nodeType);
+            newQuickInfoNodes[index].node.__TypeAnnotation = nodeTypeAnnotation;
+            newQuickInfoNodes[index].node.__nodeType = 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的类型
@@ -2375,22 +2198,11 @@ 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) => {
-            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);
-                }
-            }
-        });
         // newQuickInfoNodes.forEach((itemDetail, index) => {
         //     const { node, filePath } = itemDetail;
         //     if (!result[index] || node.concept === 'Argument')
@@ -2438,10 +2250,12 @@ class NaslServer {
         //         types.set(node, argType);
         //     }
         // });
+        console.timeEnd('批量请求');
         return types;
     }
-    // 全量标注并且返回json
+    // 全量标注
     async getNaslAnnotatedJSON(app, releaseFlag) {
+        // 全量标注
         console.time('全量标注');
         const nodes = [];
         this.file2NodeMap.forEach((fileNode, filePath) => {
@@ -2463,13 +2277,14 @@ class NaslServer {
         const json = app.toJSON();
         if (releaseFlag) {
             // 全量标注后对json进行一些修改，为了服务端翻译处理
-            this.annotationToJson(typesMap, json);
+            this.annitationToJson(typesMap, json);
         }
         return json;
     }
     // 加载全量nasl节点标注
     async createdNaslAnnotatedJSON(app) {
         // 全量标注
+        console.time('全量标注');
         const nodes = [];
         this.file2NodeMap.forEach((fileNode, filePath) => {
             // 先不排除view，传递给后端的时候，去除views下的标注
@@ -2484,10 +2299,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);
@@ -2506,9 +2321,8 @@ class NaslServer {
             }
         });
         await this.getQuickInfoNodesTypeMap(nodes);
-        console.timeEnd('增量标注');
     }
-    annotationToJson(typesMap, json) {
+    annitationToJson(typesMap, json) {
         typesMap.forEach((value, node) => {
             // 如果节点本身有类型就不去在塞一遍了
             // 有值而且没有类型再去设置
@@ -2525,8 +2339,8 @@ class NaslServer {
                     }
                 }
             }
-            // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
-            if (node instanceof concepts_1.CallQueryComponent && node.ideVersion !== '2.11') {
+            if (node instanceof concepts_1.CallQueryComponent && node.ideVersion !== '2.11' && node.typeAnnotation.properties
+                && (node.typeAnnotation.properties.length !== 2 || node.typeAnnotation.properties[0].name !== 'list')) {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 jsonNode.typeAnnotation = {
                     concept: 'TypeAnnotation',
@@ -2569,14 +2383,6 @@ 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)) {
@@ -2589,14 +2395,6 @@ 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();
-                }
-            }
         });
     }
     /**
@@ -2635,7 +2433,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 {
@@ -2650,18 +2448,13 @@ class NaslServer {
         }
         return new Promise((resolve, reject) => {
             const myTimer = setTimeout(() => {
-                console.warn(node, '没有获取到类型');
+                console.log(node, '没有获取到类型');
                 clearTimeout(myTimer);
                 clearInterval(mySetInterval);
-                if (node.__isCorrectTypeAnnotation) {
-                    resolve(node.__TypeAnnotation);
-                }
-                else {
-                    resolve(null);
-                }
+                resolve(node.__TypeAnnotation);
             }, 600);
             const mySetInterval = setInterval(() => {
-                if (node.__isCorrectTypeAnnotation) {
+                if (node.__TypeAnnotation) {
                     resolve(node.__TypeAnnotation);
                     clearInterval(mySetInterval);
                     clearTimeout(myTimer);
@@ -2715,311 +2508,320 @@ 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生成的内容
+     * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
      */
-    async handleDelete(fileNode, targetNode, result) {
-        const filePath = fileNode.getEmbeddedFilePath();
-        // 如果要删除，而且当前要删Logic就直接删除并且清除错误
-        /**
-         * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
-         */
-        let outputFiles = [];
-        // 删除之前先查一下内容的依赖
-        const newRefs = await this.references({
-            file: result.filePath,
+    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,
             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 }];
-        }
+        oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+        filesToCheck.delete(oldFilePath);
         // 更新文件之后
-        await this.updateFiles({ outputFiles });
-        newRefs.refs.forEach((ref) => 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 });
+        await naslServer.updateFiles({ outputFiles });
         // 查一下新函数名的依赖
-        const newRefs = await this.references({
+        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, () => { });
-            }
-        }
+        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, () => {});
+        // }
     }
-    /**
- * 重命名的更新
- * @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) => filesToCheck.add(ref.file));
-            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) => {
-                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) {
+    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));
+    }
+    else {
+        // 查一下当前属性依赖的文件
+        const { currentSource, fileNode } = naslServer.getCurrentSource(targetNode);
+        // 如果当前节点存在
+        if (currentSource) {
             /**
-             * 因为页面组件比较特殊
-             * 修改之后只用查页面本身就好了
+             * 其余的节点修改之后直接查本身就可以了
              */
+            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 this.updateFiles({ outputFiles });
-            const newRefs2 = await this.references({
+            await naslServer.updateFiles({ outputFiles });
+            const newRefs2 = await naslServer.references({
                 file: fileNode.getEmbeddedFilePath(),
-                line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
-                offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
+                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
             });
             newRefs2.refs.forEach((ref) => 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) => 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) => filesToCheck.add(ref.file));
-            }
-        }
     }
-    /**
-     * 处理一些节点操作，子节点需要更新并且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.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);
-                    }
+}
+/**
+ * 处理一些节点操作，子节点需要更新并且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);
+                }
+                else {
+                    await handleDelete(node, node, result);
                 }
             }
-            // 删除或新增模块
-            // 需要把下面的哦内容全部都更新一遍
-            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);
-                    }
+            // 删除模块通知更新列表
+            if (action === 'delete') {
+                try {
+                    // 如果已经
+                    (0, common_1.invokeCommand)('module.delete', true);
                 }
-                // 删除模块通知更新列表
-                if (action === 'delete') {
-                    try {
-                        // 如果已经
-                        (0, common_1.invokeCommand)('module.delete', true);
-                    }
-                    catch (err) {
-                        console.log('module.delete', '组件销毁了,不用唤起了');
-                    }
+                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 this.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 handleRename(entity, entity, result, currentOldPath);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            });
         }
     }
-    async receiveHandleChange($event) {
-        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;
+}
+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);
         }
-        const result = fileNode.toEmbeddedTSFile();
-        // 当前操作的节点
-        // 如果当前没有生成tsFile
-        if (!result) {
-            return;
+        else {
+            const oldpath = fileNode.getEmbeddedFilePath($event.oldObject.name);
+            await handleRename(fileNode, targetNode, result, oldpath);
+            await incidentalAction(action, fileNode, targetNode, oldpath);
         }
-        // 修改触发修改文件
-        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);
+    }
+    // 删除
+    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();
             }
             else {
-                const oldpath = fileNode.getEmbeddedFilePath($event.oldObject.name);
-                await this.handleRename(fileNode, targetNode, result, oldpath);
-                await this.incidentalAction(action, fileNode, targetNode, oldpath);
+                await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
+                filesToCheck.clear();
             }
-        }
-        // 删除
-        if (action === 'delete') {
-            await this.incidentalAction(action, fileNode, targetNode);
-            await this.handleDelete(fileNode, targetNode, result);
-        }
-        return true;
+        });
     }
-    changeFileNext() {
-        if (!singleFileChangeIng) {
-            const item = this.changeStackList.shift();
-            this.receiveHandleChange(item).catch((err) => {
-                console.log(err, 'receiveHandleChangeErr');
-            }).finally(async () => {
-                // 每一个文件与change接触就把状态置为false，让下一个进入
-                singleFileChangeIng = false;
-                if (this.changeStackList.length) {
-                    this.changeFileNext();
-                }
-                else {
-                    console.log(Array.from(filesToCheck));
-                    await this.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-                    filesToCheck.clear();
-                }
-            });
-        }
+    // 如果有长度开始执行状态机
+    if (stackList.length) {
+        next();
     }
-}
-exports.NaslServer = NaslServer;
+});
+// naslServer.messager.options.context = naslServer;
+exports.default = naslServer;
 //# sourceMappingURL=naslServer.js.map