@lcap/nasl 3.2.0-beta.3 → 3.3.0-alpha

package/out/server/naslServer.js

@@ -37,11 +37,11 @@ exports.NaslServer = exports.getDisplayString2Type = void 0;
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 const worker_threads_1 = require("worker_threads");
-/// #endif
+const decimal_js_1 = require("decimal.js");
 const config_1 = require("../config");
 const sentry_1 = require("../sentry");
 const Messager_1 = __importDefault(require("../common/Messager"));
-const getMemberIdentifier_1 = require("../server/getMemberIdentifier");
+const getMemberIdentifier_1 = require("./getMemberIdentifier");
 const concepts_1 = require("../concepts");
 const translator_1 = require("../translator");
 const storage_1 = __importDefault(require("../service/storage"));
@@ -56,7 +56,7 @@ const naslStdlibMap_1 = __importDefault(require("./naslStdlibMap"));
 const jsoner = __importStar(require("../service/storage/jsoner"));
 const EventEmitter_1 = require("../common/EventEmitter");
 const utils_1 = require("../utils");
-const decimal_js_1 = require("decimal.js");
+const decorators_1 = require("../decorators");
 const utils_2 = require("../automate/engine/utils");
 const EmbeddedTSFileLineMap = {
     Entity: 3,
@@ -69,13 +69,13 @@ const EmbeddedTSFileOffsetMap = {
     ConfigProperty: 12,
 };
 const SentryMessager = (0, sentry_1.sentryMonitorTSWorkerMessager)(Messager_1.default);
-let isChangeInterface = false; //判断是否导入接口
-let actionArr = []; //用于导入接口收集更改的节点
-let timer = null; //超时器用于收集导入接口相关
+let isChangeInterface = false; // 判断是否导入接口
+let actionArr = []; // 用于导入接口收集更改的节点
+let timer = null; // 超时器用于收集导入接口相关
 const __naslStdlibFileCacheMap = new Map(); // naslStdlib文件缓存
 // 联合类型切割取出类型
 function getDisplayString2Type(displayString) {
-    const targetString = displayString.match(/value:\s(\S+)\)/)[1];
+    const targetString = displayString.match(/value:\s(\S+)\)/)?.[1] ?? '';
     let targetType = null;
     if (targetString.startsWith('nasl.core.')) {
         targetType = targetString.slice(10);
@@ -90,19 +90,17 @@ function getDisplayString2Type(displayString) {
         if (/<([^()]+)>/g.exec(item)) {
             return item;
         }
-        else if (item.includes(' ')) {
+        if (item.includes(' ')) {
             const strs = item.split(' ');
             const type = strs[strs.length - 1];
             return type;
         }
-        else if (item.includes('.')) {
+        if (item.includes('.')) {
             const strs = item.split('.');
             const type = strs[strs.length - 1];
             return type;
         }
-        else {
-            return item;
-        }
+        return item;
     });
     if (targetType) {
         return typeList.filter((item) => item !== targetType);
@@ -132,12 +130,14 @@ let NaslServer = class NaslServer {
     logicSetWithComponentLogic = new Set();
     constructor() {
         /// #if process.env.BUILD_TARGET === 'node'
-        if (globalThis.process) // For TS build
+        if (globalThis.process)
+            // For TS build
             this.worker = new worker_threads_1.Worker(path.join(__dirname, '../../ts-worker/src/index.js'));
         // worker = new Worker(path.join(__dirname, '../../../src/static/ts-worker.js'));
         /// #endif
         /// #if process.env.BUILD_TARGET !== 'node'
-        if (globalThis.window) // For TS build
+        if (globalThis.window)
+            // For TS build
             /* !!!如果改动这里需要看下关联的对应文件：webpack/ts-worker/loader.js */
             this.worker = new worker_threads_1.Worker('/ts-worker.js');
         /// #endif
@@ -187,7 +187,7 @@ let NaslServer = class NaslServer {
                     // 这个方法是 5.0 加入标准库的，但是这里 ts 版本是 4.x，ci 会挂，所以需要忽略
                     // @ts-ignore
                     const findLastIndex = this.changeStackList.findLastIndex((changeStackItem) => {
-                        const target = changeStackItem.target;
+                        const { target } = changeStackItem;
                         const { fileNode: targetFileNode } = this.getCurrentSource(target);
                         return targetFileNode === fileNode;
                     });
@@ -198,10 +198,8 @@ let NaslServer = class NaslServer {
                             // 如果当前列表里有，这个文件节点，最后一个是field的话，直接return掉，不用塞这个update了
                             return;
                         }
-                        else {
-                            // 如果最后一项是普通的update的话，就可以去掉，后面那个会在塞过来
-                            this.changeStackList.pop();
-                        }
+                        // 如果最后一项是普通的update的话，就可以去掉，后面那个会在塞过来
+                        this.changeStackList.pop();
                     }
                     this.changeStackList.push(item.originEvent);
                 }
@@ -231,7 +229,7 @@ let NaslServer = class NaslServer {
         }, { cache: true });
         Object.keys(naslStdlibMap_1.default).forEach(async (libFileName) => {
             await this.addFile({
-                file: '/' + libFileName,
+                file: `/${libFileName}`,
                 fileContent: naslStdlibMap_1.default[libFileName],
             }, { cache: true });
         });
@@ -252,8 +250,7 @@ let NaslServer = class NaslServer {
                 structure.sourceMap = result.sourceMap;
                 this.file2NodeMap.set(result.filePath, structure);
             }
-            catch (err) {
-            }
+            catch (err) { }
         });
         if (module instanceof concepts_1.App) {
             module.overriddenLogics?.forEach?.((logic) => {
@@ -304,7 +301,7 @@ let NaslServer = class NaslServer {
                         console.log(err);
                     }
                 });
-                frontend.bindEvents.forEach((bindEvent) => {
+                frontend.bindEvents?.forEach((bindEvent) => {
                     if (bindEvent?.logics && bindEvent?.logics?.length > 0) {
                         bindEvent.logics.forEach((logic) => {
                             try {
@@ -351,8 +348,7 @@ let NaslServer = class NaslServer {
                 dataSource.sourceMap = result.sourceMap;
                 this.file2NodeMap.set(result.filePath, dataSource);
             }
-            catch (err) {
-            }
+            catch (err) { }
             dataSource.entities.forEach((entity) => {
                 try {
                     const result = entity.toEmbeddedTSFile();
@@ -361,8 +357,7 @@ let NaslServer = class NaslServer {
                     entity.sourceMap = result.sourceMap;
                     this.file2NodeMap.set(result.filePath, entity);
                 }
-                catch (err) {
-                }
+                catch (err) { }
             });
         });
         module?.interfaces?.forEach((_interface) => {
@@ -373,8 +368,7 @@ let NaslServer = class NaslServer {
                 _interface.sourceMap = result.sourceMap;
                 this.file2NodeMap.set(result.filePath, _interface);
             }
-            catch (err) {
-            }
+            catch (err) { }
         });
         module?.enums?.forEach((_enum) => {
             try {
@@ -384,8 +378,7 @@ let NaslServer = class NaslServer {
                 _enum.sourceMap = result.sourceMap;
                 this.file2NodeMap.set(result.filePath, _enum);
             }
-            catch (err) {
-            }
+            catch (err) { }
         });
         module?.logics?.forEach((logic) => {
             try {
@@ -396,8 +389,7 @@ let NaslServer = class NaslServer {
                 logic.sourceMap = result.sourceMap;
                 this.file2NodeMap.set(result.filePath, logic);
             }
-            catch (err) {
-            }
+            catch (err) { }
         });
         module?.authLogics?.forEach?.((logic) => {
             try {
@@ -408,8 +400,7 @@ let NaslServer = class NaslServer {
                 logic.sourceMap = result.sourceMap;
                 this.file2NodeMap.set(result.filePath, logic);
             }
-            catch (err) {
-            }
+            catch (err) { }
         });
         module?.authLogicsForCallInterface?.forEach?.((logic) => {
             try {
@@ -420,8 +411,7 @@ let NaslServer = class NaslServer {
                 logic.sourceMap = result.sourceMap;
                 this.file2NodeMap.set(result.filePath, logic);
             }
-            catch (err) {
-            }
+            catch (err) { }
         });
         module.processes?.forEach((process) => {
             try {
@@ -430,8 +420,7 @@ let NaslServer = class NaslServer {
                 process.sourceMap = result.sourceMap;
                 this.file2NodeMap.set(result.filePath, process);
             }
-            catch (err) {
-            }
+            catch (err) { }
         });
         if (module instanceof concepts_1.Connector) {
             try {
@@ -456,8 +445,29 @@ let NaslServer = class NaslServer {
                     role.sourceMap = result.sourceMap;
                     this.file2NodeMap.set(result.filePath, role);
                 }
-                catch (err) {
+                catch (err) { }
+            });
+        }
+        if (module instanceof concepts_1.App) {
+            module.connections.forEach((connection) => {
+                try {
+                    const result = connection.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    connection.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, connection);
                 }
+                catch (err) { }
+            });
+            module.triggerLaunchers.forEach((triggerLauncher) => {
+                try {
+                    const result = triggerLauncher.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    triggerLauncher.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, triggerLauncher);
+                }
+                catch (err) { }
             });
         }
         module.configuration?.groups?.forEach((_group) => {
@@ -470,8 +480,7 @@ let NaslServer = class NaslServer {
                         _property.sourceMap = result.sourceMap;
                         this.file2NodeMap.set(result.filePath, _property);
                     }
-                    catch (err) {
-                    }
+                    catch (err) { }
                 });
             }
         });
@@ -489,12 +498,12 @@ let NaslServer = class NaslServer {
                         this.view2TSFile(view.children, results);
                     }
                 }
-                catch (err) {
-                }
+                catch (err) { }
             });
         }
     }
     async openApp(app) {
+        console.time('生成 TS 文件');
         const results = [];
         try {
             // app的创建内容
@@ -520,6 +529,7 @@ let NaslServer = class NaslServer {
         (0, common_1.registerCommand)('tsDelete.change', (callback) => {
             callback();
         });
+        console.timeEnd('生成 TS 文件');
     }
     async refreshApp(app) {
         // 清除所有问题
@@ -536,8 +546,8 @@ let NaslServer = class NaslServer {
         // check内容后，会自动走增量类型标注完善全部类型
     }
     /**
- * 初始化之前添加文件
- */
+     * 初始化之前添加文件
+     */
     addFile(file, { cache = false } = {}) {
         cache && this.cacheFile(file);
         return this.messager.requestCommand('addFile', file);
@@ -546,52 +556,57 @@ let NaslServer = class NaslServer {
     cacheFile(options) {
         __naslStdlibFileCacheMap.set(options.file, options);
     }
-    /**u
- * 只新增文件
- * @param {*} files
- */
+    /** u
+     * 只新增文件
+     * @param {*} files
+     */
     writeFiles(files) {
         return this.messager.requestCommand('writeFiles', files);
     }
     /**
- * 新增、修改
- * 删除文件 文件用修改内容为空模拟，防止报错
- * @param {*} args
- */
+     * 新增、修改
+     * 删除文件 文件用修改内容为空模拟，防止报错
+     * @param {*} args
+     */
     updateFiles(args) {
         return this.messager.requestCommand('updateFiles', args);
     }
     /**
- * 清除一个目录下的所有文件
- */
+     * 清除一个目录下的所有文件
+     */
     deleteDirectoryFiles(args) {
         return this.messager.requestCommand('deleteDirectoryFiles', args);
     }
     async _debugInFileStorage(node, openFiles) {
         let app = node;
+        let openDebugEmbedded = true;
         if (node.concept !== 'App') {
             app = node.rootNode || node.app;
         }
         /// #if process.env.NODE_ENV === 'development'
-        if (globalThis.window) { // For TS build
+        // 首次尝试请求
+        await storage_1.default.post(`/api/App/debugEmbedded?id=${app.id}`, openFiles[0]).catch(() => (openDebugEmbedded = false));
+        if (openDebugEmbedded && globalThis.window) {
+            // For TS build
             try {
                 let canDebug = true;
-                await storage_1.default.post('/api/App/debugEmbedded?id=' + app.id, openFiles[0])
-                    .catch(() => canDebug = false);
+                await storage_1.default.post(`/api/App/debugEmbedded?id=${app.id}`, openFiles[0]).catch(() => (canDebug = false));
                 if (canDebug) {
                     await Promise.all(openFiles.map(async (file) => {
-                        const res = await storage_1.default.post('/api/App/debugEmbedded?id=' + app.id, file);
+                        const res = await storage_1.default.post(`/api/App/debugEmbedded?id=${app.id}`, file);
                         return res.data;
                     }));
                 }
             }
             catch (e) {
-                console.error(e);
+                // 出现错误之后不再调用
+                openDebugEmbedded = false;
             }
         }
         /// #endif
         /// #if process.env.BUILD_TARGET === 'node'
-        if (globalThis.process) { // For TS build
+        if (globalThis.process) {
+            // For TS build
             try {
                 await Promise.all(openFiles.map(async (file) => fs.outputFile(path.join(__dirname, '../debug/apps', app.id, file.file), file.fileContent)));
             }
@@ -627,9 +642,7 @@ let NaslServer = class NaslServer {
                 noFilterList,
             });
         }
-        else {
-            console.log('没找到节点', node, currentSource, fileNode);
-        }
+        console.log('没找到节点', node, currentSource, fileNode);
     }
     _getValueSelectCompletion(args) {
         return this.messager.requestCommand('getValueSelectCompletion', args);
@@ -643,10 +656,10 @@ let NaslServer = class NaslServer {
         if (node && node instanceof concepts_1.BaseNode) {
             const callFunction = node.parentNode.parentNode;
             /**
-         * currentSource callFunction 的节点，要去到当前节点的位置
-         * nasl.util.Convert(xxx),所以取到的位置要 + `nasl.util.C` 的长度
-         * fileNode
-         */
+             * currentSource callFunction 的节点，要去到当前节点的位置
+             * nasl.util.Convert(xxx),所以取到的位置要 + `nasl.util.C` 的长度
+             * fileNode
+             */
             const { currentSource, fileNode } = this.getCurrentSource(callFunction);
             if (!currentSource) {
                 return [];
@@ -673,9 +686,7 @@ let NaslServer = class NaslServer {
                     if (!res.length) {
                         return [];
                     }
-                    else {
-                        return [{ title: '基础类型', children: res }];
-                    }
+                    return [{ title: '基础类型', children: res }];
                 }
             }
             catch (err) {
@@ -710,26 +721,25 @@ let NaslServer = class NaslServer {
         if (quickInfo.responseRequired) {
             const displayString = quickInfo?.response?.displayString || '';
             const flag = displayString.includes('<') && displayString.includes('>');
-            const types = /\<([^()]+)\>/g.exec(displayString);
+            const types = /<([^()]+)>/g.exec(displayString);
             let typeStr = types && types[1];
             if (flag) {
                 // 自定义结构的展示
                 if (typeStr.includes('__name: "AStructure_')) {
-                    return typeStr.replaceAll(' ', '')
+                    return typeStr
+                        .replaceAll(' ', '')
                         .replaceAll('\n', '')
                         .replace(/__name:"AStructure_\w{8}";/g, '')
-                        .replace(/dataSources.([^.]+).entities.([^;]+)/g, ($1, $2, $3) => (`${$3}(${$2})`));
+                        .replace(/dataSources.([^.]+).entities.([^;]+)/g, ($1, $2, $3) => `${$3}(${$2})`);
                 }
-                else if (typeStr.startsWith('{') && typeStr.endsWith('}')) {
+                if (typeStr.startsWith('{') && typeStr.endsWith('}')) {
                     /**
-                     *  {
-                            text: nasl.core.String;
-                            value: nasl.core.String;
-                        }
-                     */
-                    return typeStr.replaceAll(' ', '')
-                        .replaceAll('\n', '')
-                        .replaceAll('nasl.core.', '');
+                               *  {
+                                      text: nasl.core.String;
+                                      value: nasl.core.String;
+                                  }
+                               */
+                    return typeStr.replaceAll(' ', '').replaceAll('\n', '').replaceAll('nasl.core.', '');
                 }
                 let str = '';
                 // 取出T的值
@@ -739,7 +749,7 @@ let NaslServer = class NaslServer {
                     return typeStr;
                 }
                 // 取出剩下的剩下的类型的最后一项
-                if (/\<([^()]+)\>/g.exec(typeStr)) {
+                if (/<([^()]+)>/g.exec(typeStr)) {
                     str = typeStr;
                 }
                 else if (typeStr.includes('.')) {
@@ -773,13 +783,12 @@ let NaslServer = class NaslServer {
             const flag = displayString.includes('<') && displayString.includes('>');
             if (!flag)
                 return;
-            const types = /\<([^()]+)\>/g.exec(displayString);
+            const types = /<([^()]+)>/g.exec(displayString);
             const typeStr = types && types[1];
-            const app = node.app;
+            const { app } = node;
             if (typeStr.includes('__name: "AStructure_')) {
                 const properties = [];
-                typeStr
-                    .replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
+                typeStr.replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
                     if (name === '__name')
                         return;
                     typeKey = `app.${typeKey}`;
@@ -798,15 +807,15 @@ let NaslServer = class NaslServer {
                 });
                 return concepts_1.TypeAnnotation.createTypeAnonymousStructure(properties);
             }
-            else if (typeStr.startsWith('structures'))
+            if (typeStr.startsWith('structures'))
                 return app.findNodeByCompleteName(`app.${typeStr}`);
         }
     }
     /**
- * ts的 quickInfo方法，查询指定位置的详情
- * @param args 文件信息数组
- * @returns 查询到的
- */
+     * ts的 quickInfo方法，查询指定位置的详情
+     * @param args 文件信息数组
+     * @returns 查询到的
+     */
     _getTypeQuickinfo(args) {
         return this.messager.requestCommand('quickInfo', args);
     }
@@ -838,11 +847,11 @@ let NaslServer = class NaslServer {
         return result;
     }
     /**
- * 获取已经选中的内容的 下一级的内容
- * @param node 已经选中的内容
- * @param noFilterList 不过滤的key 的数据
- * @returns 可以选择的数据数组
- */
+     * 获取已经选中的内容的 下一级的内容
+     * @param node 已经选中的内容
+     * @param noFilterList 不过滤的key 的数据
+     * @returns 可以选择的数据数组
+     */
     getSelectNextCompletion(node, noFilterList) {
         const { currentSource, fileNode } = this.getCurrentSource(node);
         // console.log(currentSource, fileNode);
@@ -856,32 +865,18 @@ let NaslServer = class NaslServer {
                 noFilterList,
             });
         }
-        else {
-            console.log('没找到节点', currentSource, fileNode);
-        }
+        console.log('没找到节点', currentSource, fileNode);
     }
     _getSelectNextCompletion(args) {
         return this.messager.requestCommand('getSelectNextCompletion', args);
     }
-    /**
-     * 获取诊断信息
-     * @param fileNames 多个文件名
-     * @returns 诊断结果
-     */
-    async getDiagnosticRecords(fileNames) {
-        const records = (await this.messager.requestCommand('getDiagnosticRecords', fileNames));
-        const diagnosticRecords = await this._resolveDiagnosticRecords(records);
-        return diagnosticRecords;
-    }
-    async getDiagnosticRecordsAndPushAll(fileNames) {
-        // 开始诊断和标注
+    getDiagnosticRecordsAndPushAll(fileNames) {
         (0, common_1.invokeCommand)('naslServer:startWork');
-        const records = await this.getDiagnosticRecords(fileNames);
-        // diagnosticManager.pushAll(records);
+        return this.messager.requestCommand('getDiagnosticRecords', fileNames);
     }
     /**
- * 节点异常是只能挂载单个，如果已经了就不赋值了
- */
+     * 节点异常是只能挂载单个，如果已经了就不赋值了
+     */
     baseNodeAssignmentTsError(node, tsErrorDetail) {
         if (node.tsErrorDetail)
             return;
@@ -897,8 +892,8 @@ let NaslServer = class NaslServer {
         if (records.length) {
             await this.IncrementalAnnotationJSON(records);
         }
-        records.forEach((record) => {
-            const node = record.node;
+        await Promise.all(records.map(async (record) => {
+            const { node } = record;
             if (!node)
                 return;
             // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
@@ -923,7 +918,7 @@ let NaslServer = class NaslServer {
             });
             // 语义诊断
             if (isChangeInterface) {
-                this.existStructureFix(record.semanticDiagnostics, node, this);
+                this.existStructureFix(record.semanticDiagnostics, record.node, this);
             }
             // 单独处理 oql 语义错误提示
             if (record.node instanceof concepts_1.Logic) {
@@ -936,11 +931,12 @@ let NaslServer = class NaslServer {
                     }
                 });
             }
+            // 记录结构体数据
             record.semanticDiagnostics.forEach((diag) => (0, translator_2.checkAStructure_)(diag.text));
             record.semanticDiagnostics = record.semanticDiagnostics
-                .map((diag) => this._resolveDiagnostic(diag, node, record))
+                .map((diag) => this._resolveDiagnostic(diag, record.node, record))
                 .filter((diag) => !!diag);
-            record.semanticDiagnostics.push(...this._attachDiagnostics(node));
+            record.semanticDiagnostics.push(...(await this._attachDiagnostics(node)));
             // 报错降级逻辑
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diagnostic) => {
@@ -951,7 +947,7 @@ let NaslServer = class NaslServer {
                         record.suggestionDiagnostics.push(diagnostic);
                         return null;
                     }
-                    else if (currentNode.concept === 'OqlQueryComponent') {
+                    if (currentNode.concept === 'OqlQueryComponent') {
                         // OQL别名错误降级为警告
                         if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
                             // 重置 图标和错误等级
@@ -964,7 +960,7 @@ let NaslServer = class NaslServer {
                             return null;
                         }
                     }
-                    while (currentNode?.parentNode?.concept !== 'App') {
+                    while (currentNode && currentNode?.parentNode?.concept !== 'App') {
                         if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
                             // 草稿区降级
                             // 重置 图标和错误等级
@@ -985,53 +981,46 @@ let NaslServer = class NaslServer {
                     }
                 }
                 return diagnostic;
-            }).filter((diag) => !!diag);
-            // 建议诊断
-            // 实体下的建议不用展示，因为都是平台自己写的逻辑
-            // if (node instanceof Entity) {
-            //     record.suggestionDiagnostics = [];
-            // }
-            // if (node instanceof View) {
-            //     // event在view中不展示建议使用,提示关闭掉
-            //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`'event'`));
-            // }
-            // if (node instanceof Logic) {
-            //     // logic在for循环中，不展示any提示
-            //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
-            // }
+            })
+                .filter((diag) => !!diag);
             // 处理后的警告异常提示信息
-            record.suggestionDiagnostics = record.suggestionDiagnostics.map((diag) => {
+            record.suggestionDiagnostics = record.suggestionDiagnostics
+                .map((diag) => {
                 // 上面错误降级下来的
                 if (diag?.node) {
                     return diag;
                     // 一些已知警告的单独处理
                 }
-                else if ([`'__LogicEmpty' is declared but its value is never read.`,
+                if ([
+                    `'__LogicEmpty' is declared but its value is never read.`,
                     `'__destinationEmpty__' is declared but its value is never read.`,
                     `'__devConfigValueEmpty' is declared but its value is never read.`,
                     `'__onlineConfigValueEmpty' is declared but its value is never read.`,
-                    `'__UpdateNoProperty__' is declared but its value is never read.`].includes(diag.text)) {
-                    return this._resolveDiagnostic(diag, node, record);
+                    `'__UpdateNoProperty__' is declared but its value is never read.`,
+                ].includes(diag.text)) {
+                    return this._resolveDiagnostic(diag, record.node, record);
                 }
-                else if ((diag.text).includes(` is declared but its value is never read.`)) {
+                if (diag.text.includes(` is declared but its value is never read.`)) {
                     // 局部变量和输入变量未使用的警告
-                    const fromModule = node.parentNode.concept === 'Module';
-                    const fromConnector = node.parentNode.concept === 'Connector';
-                    if ((node.concept === 'View' || node.concept === 'Logic') && !(fromModule || fromConnector)) {
+                    const fromModule = record.node.parentNode.concept === 'Module';
+                    const fromConnector = record.node.parentNode.concept === 'Connector';
+                    if ((record.node.concept === 'View' || record.node.concept === 'Logic') && !(fromModule || fromConnector)) {
                         /**
                          * javalogic不用提示
                          */
-                        if (node.concept === 'Logic' && this._isJavalogic(node)) {
-                            return;
+                        if (record.node.concept === 'Logic' && this._isJavalogic(record.node)) {
+                            return null;
                         }
-                        const minRange = this._findMinRange(diag, node);
+                        const minRange = this._findMinRange(diag, record.node);
                         if (minRange) {
                             /**
                              * 如果节点是入参类型
                              * 而且不是foreach中
                              * 而且不是事件逻辑的入参
                              */
-                            if (minRange.node instanceof concepts_1.Param && minRange.node.parentNode.concept !== 'ForEachStatement' && !minRange.node.getAncestor('BindEvent')) {
+                            if (minRange.node instanceof concepts_1.Param &&
+                                minRange.node.parentNode.concept !== 'ForEachStatement' &&
+                                !minRange.node.getAncestor('BindEvent')) {
                                 const diagnostic = {
                                     node: minRange.node,
                                     severity: 'warning',
@@ -1039,7 +1028,7 @@ let NaslServer = class NaslServer {
                                 };
                                 return diagnostic;
                             }
-                            else if (minRange.node instanceof concepts_1.Variable) {
+                            if (minRange.node instanceof concepts_1.Variable) {
                                 const diagnostic = {
                                     node: minRange.node,
                                     severity: 'warning',
@@ -1051,9 +1040,10 @@ let NaslServer = class NaslServer {
                     }
                 }
                 return null;
-            }).filter((diag) => !!diag);
+            })
+                .filter((diag) => !!diag);
             record.suggestionDiagnostics.push(...this._attachSuggestionDiagnostics(node));
-        });
+        }));
         return records;
     }
     /**
@@ -1175,7 +1165,7 @@ let NaslServer = class NaslServer {
                             }
                         });
                     }
-                    const { typeAnnotation: maxTypeAnnotation, } = maxTypeAnnotationInfo;
+                    const { typeAnnotation: maxTypeAnnotation } = maxTypeAnnotationInfo;
                     for (const sortedTypeKey in typeAnnotationMap) {
                         const { typeAnnotation, cases } = typeAnnotationMap[sortedTypeKey];
                         if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
@@ -1202,9 +1192,9 @@ let NaslServer = class NaslServer {
                 else if (node instanceof concepts_1.NewList && !node.typeAnnotation) {
                     // 匿名函数返回值有可能是newList，需要过滤。代码来源：AnonymousFunction.__ts
                     const grandParent = node.parentNode?.parentNode?.parentNode;
-                    if (grandParent instanceof concepts_1.CallLogic
-                        && /dataSources\.[^.]+\.entities\.[^.]+\.logics/.test(grandParent.calleeNamespace)
-                        && ['update', 'updateBy', 'createOrUpdate', 'batchUpdate'].includes(grandParent.calleeName)) {
+                    if (grandParent instanceof concepts_1.CallLogic &&
+                        /dataSources\.[^.]+\.entities\.[^.]+\.logics/.test(grandParent.calleeNamespace) &&
+                        ['update', 'updateBy', 'createOrUpdate', 'batchUpdate'].includes(grandParent.calleeName)) {
                         return;
                     }
                     const { items } = node || {};
@@ -1219,7 +1209,7 @@ let NaslServer = class NaslServer {
                             const typeAnnotation = item.__TypeAnnotation;
                             // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
                             if (typeAnnotation) {
-                                const sortedTypeKey = typeAnnotation.sortedTypeKey;
+                                const { sortedTypeKey } = typeAnnotation;
                                 if (!typeAnnotationMap[sortedTypeKey]) {
                                     typeAnnotationMap[sortedTypeKey] = {
                                         typeAnnotation,
@@ -1240,7 +1230,7 @@ let NaslServer = class NaslServer {
                             }
                         });
                     }
-                    const { typeAnnotation: maxTypeAnnotation, } = maxTypeAnnotationInfo;
+                    const { typeAnnotation: maxTypeAnnotation } = maxTypeAnnotationInfo;
                     for (const sortedTypeKey in typeAnnotationMap) {
                         const { typeAnnotation, items } = typeAnnotationMap[sortedTypeKey];
                         if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
@@ -1273,7 +1263,7 @@ let NaslServer = class NaslServer {
                             const typeAnnotation = value.__TypeAnnotation;
                             // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
                             if (typeAnnotation) {
-                                const sortedTypeKey = typeAnnotation.sortedTypeKey;
+                                const { sortedTypeKey } = typeAnnotation;
                                 if (!typeAnnotationMap[sortedTypeKey]) {
                                     typeAnnotationMap[sortedTypeKey] = {
                                         typeAnnotation,
@@ -1294,7 +1284,7 @@ let NaslServer = class NaslServer {
                             }
                         });
                     }
-                    const { typeAnnotation: maxTypeAnnotation, } = maxTypeAnnotationInfo;
+                    const { typeAnnotation: maxTypeAnnotation } = maxTypeAnnotationInfo;
                     for (const sortedTypeKey in typeAnnotationMap) {
                         const { typeAnnotation, values } = typeAnnotationMap[sortedTypeKey];
                         if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
@@ -1348,7 +1338,8 @@ let NaslServer = class NaslServer {
                                 contentVariables.push(node);
                                 // QueryFromExpression QueryJoinExpression
                             }
-                            else if ((node?.concept === 'QueryFieldExpression' && !node.isDotStar) || node?.concept === 'QueryGroupByExpression') {
+                            else if ((node?.concept === 'QueryFieldExpression' && !node.isDotStar) ||
+                                node?.concept === 'QueryGroupByExpression') {
                                 contentVariables.push(node);
                             }
                         }
@@ -1387,7 +1378,8 @@ let NaslServer = class NaslServer {
                 if (node.isComponentLogic) {
                     flag = true;
                 }
-                else if (node.isViewLogic) { // 调用页面逻辑
+                else if (node.isViewLogic) {
+                    // 调用页面逻辑
                     const logicNode = node.view?.logics?.find?.((viewLogic) => viewLogic.name === node.calleeName);
                     if (logicNode) {
                         if (this.logicSetWithComponentLogic.has(logicNode.nodePath)) {
@@ -1421,12 +1413,59 @@ let NaslServer = class NaslServer {
         });
         return flag;
     }
+    /** 是否被 触发器依赖, 如果存在，返回第一个触发器对应的名称 */
+    async isRefedByTriggerAndReturnFirstRef(fileNode) {
+        const refs = await this._isHaveRef(fileNode);
+        const basePath = concepts_1.TriggerLauncher.getEmbeddedFileBasePath(fileNode.rootNode);
+        let flag = false;
+        let fRefName = '';
+        try {
+            for (const ref of refs) {
+                const { file } = ref;
+                if (file.startsWith(basePath)) {
+                    flag = true;
+                    // file: /embedded/tttta/triggerLaunchers/订阅配置_asd.ts
+                    fRefName = file.split(basePath)[1].split('.')[0];
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            console.error(error, refs);
+        }
+        return {
+            isRefedByTrigger: flag,
+            fRefName,
+        };
+    }
+    /**
+     * 是否符合 触发器规则
+     * 规则：
+     * 1. 入参仅有一个，且必须为string类型
+     */
+    isTriggerRule(fileNode) {
+        const { sourceMap } = fileNode;
+        let paramsLength = 0;
+        let flag = true;
+        sourceMap.forEach((_, k) => {
+            if (k instanceof concepts_1.Param) {
+                paramsLength++;
+                const typeAnnotation = k.typeAnnotation || k.__TypeAnnotation;
+                const { typeKind, typeName, typeNamespace } = typeAnnotation || {};
+                const isString = typeKind === 'primitive' && typeName === 'String' && typeNamespace === 'nasl.core';
+                if (!isString) {
+                    flag = false;
+                }
+            }
+        });
+        return paramsLength === 1 && flag;
+    }
     /**
- * 额外的诊断
- * @param fileNode 文件级别的节点
- * @returns 诊断结果
- */
-    _attachDiagnostics(fileNode) {
+     * 额外的诊断
+     * @param fileNode 文件级别的节点
+     * @returns 诊断结果
+     */
+    async _attachDiagnostics(fileNode) {
         // 每次诊断前先清空这个Set
         this.logicSetWithComponentLogic = new Set();
         const diagnostics = [];
@@ -1504,9 +1543,9 @@ let NaslServer = class NaslServer {
                                     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.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,
@@ -1546,17 +1585,17 @@ let NaslServer = class NaslServer {
                     if (Array.isArray(node.bindExpressions)) {
                         const exp = node.bindExpressions.find((bindExpression) => this.hasComponentLogics(bindExpression));
                         if (exp) {
-                            //const element: any = node.getAncestor('ViewElement');
-                            //const api = config.allNodesAPI[element?.tag];
-                            //const attr = api?.attrs?.find?.((attr) => {
+                            // const element: any = node.getAncestor('ViewElement');
+                            // const api = config.allNodesAPI[element?.tag];
+                            // const attr = api?.attrs?.find?.((attr) => {
                             //    return attr.name === node.name;
-                            //});
+                            // });
                             const map = {
                                 BindAttribute: '属性',
                                 BindDirective: '指令',
                                 BindStyle: '样式属性',
                             };
-                            //“${attr?.title || node.title || node.name}”
+                            // “${attr?.title || node.title || node.name}”
                             const diagnostic = {
                                 node,
                                 severity: 'error',
@@ -1586,7 +1625,7 @@ let NaslServer = class NaslServer {
                 }
             });
         }
-        if (fileNode instanceof concepts_1.DataSource) {
+        else if (fileNode instanceof concepts_1.DataSource) {
             const dataSourceGroup = fileNode.rootNode.configuration?.getGroup('dataSource');
             if (dataSourceGroup) {
                 const property = dataSourceGroup.getProperty(fileNode.name);
@@ -1651,7 +1690,7 @@ let NaslServer = class NaslServer {
             }
         }
         // 加上对实体属性存储类型的校验规则
-        if (fileNode instanceof concepts_1.Entity) {
+        else if (fileNode instanceof concepts_1.Entity) {
             const entity = fileNode;
             const dbType = entity.dataSource.dataSourceSqlType;
             const { origin, properties } = entity || {};
@@ -1728,7 +1767,7 @@ let NaslServer = class NaslServer {
                                 const { default: defaultVal } = precisionOption || {};
                                 const precision = databaseTypeAnnotation ? databaseTypeAnnotation.arguments?.precision : defaultVal;
                                 const ruleScale = typeAnnotation?.ruleMap?.scale;
-                                const scale = ruleScale !== undefined ? ruleScale + '' : '';
+                                const scale = ruleScale !== undefined ? `${ruleScale}` : '';
                                 let ensureScale = true;
                                 switch (typeName) {
                                     case 'String': {
@@ -1776,7 +1815,8 @@ let NaslServer = class NaslServer {
                                                 value: maxVal,
                                             },
                                         ].forEach(({ key, name, value }) => {
-                                            if (ruleMin && value && new decimal_js_1.Decimal(ruleMin).greaterThan(new decimal_js_1.Decimal(value))) { // 超出存储下限
+                                            if (ruleMin && value && new decimal_js_1.Decimal(ruleMin).greaterThan(new decimal_js_1.Decimal(value))) {
+                                                // 超出存储下限
                                                 const diag = {
                                                     node: property,
                                                     severity: 'warning',
@@ -1785,7 +1825,8 @@ let NaslServer = class NaslServer {
                                                 diagnostics.push(diag);
                                                 typeAnnotationErrorDetail.errorPos[key] = `${name}超出存储下限`;
                                             }
-                                            if (ruleMax && value && new decimal_js_1.Decimal(ruleMax).lessThan(new decimal_js_1.Decimal(value))) { // 超出存储上限
+                                            if (ruleMax && value && new decimal_js_1.Decimal(ruleMax).lessThan(new decimal_js_1.Decimal(value))) {
+                                                // 超出存储上限
                                                 const diag = {
                                                     node: property,
                                                     severity: 'warning',
@@ -1825,7 +1866,7 @@ let NaslServer = class NaslServer {
                                     // 储存小数部分
                                     const memoryScaleStr = memoryStr.slice(0, +(scale || '0'));
                                     // 储存绝对值
-                                    const memoryAbsVal = memoryIntAbsStr + (memoryScaleStr ? '.' + memoryScaleStr : '');
+                                    const memoryAbsVal = memoryIntAbsStr + (memoryScaleStr ? `.${memoryScaleStr}` : '');
                                     const decimalMemoryAbsVal = new decimal_js_1.Decimal(memoryAbsVal);
                                     [
                                         {
@@ -1883,8 +1924,17 @@ let NaslServer = class NaslServer {
             }
         }
         if (fileNode instanceof concepts_1.Logic || fileNode instanceof concepts_1.OverriddenLogic) {
+            const { isRefedByTrigger, fRefName } = await this.isRefedByTriggerAndReturnFirstRef(fileNode);
+            if (isRefedByTrigger && !this.isTriggerRule(fileNode)) {
+                const diagnostic = {
+                    node: fileNode,
+                    severity: 'error',
+                    message: `${fileNode.name} 已被Kafka消息订阅配置 ${fRefName} 引用，该逻辑入参只有一个入参，且入参类型为string，否则会导致无法接收Kafka消息`,
+                };
+                diagnostics.push(diagnostic);
+            }
             fileNode?.sourceMap.forEach((value, node) => {
-                //OQL支持返回复合类型数据了
+                // OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
                 // if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
                 //     const diagnostic = {
@@ -1900,7 +1950,7 @@ let NaslServer = class NaslServer {
                     const typeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(node.__nodeType);
                     if (!node.typeAnnotation && typeAnnotation) {
                         if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
-                            const typeArguments = typeAnnotation.typeArguments;
+                            const { typeArguments } = typeAnnotation;
                             if (typeArguments.length && typeArguments[0].isComplexType()) {
                                 const diagnostic = {
                                     node,
@@ -1918,8 +1968,7 @@ let NaslServer = class NaslServer {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
                         let used = false;
                         fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
-                            if (!used && nodeIn
-                                && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))) {
+                            if (!used && nodeIn && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))) {
                                 let jsCode = '';
                                 try {
                                     jsCode = nodeIn.toJS();
@@ -1957,11 +2006,12 @@ let NaslServer = class NaslServer {
                 this.checkNodeError(node, diagnostics);
             });
         }
-        if (fileNode instanceof concepts_1.Process) {
+        else if (fileNode instanceof concepts_1.Process) {
             fileNode?.sourceMap.forEach((value, node) => {
                 this.checkNodeError(node, diagnostics);
             });
         }
+        console.timeEnd('_attachDiagnostics');
         return diagnostics;
     }
     checkNodeError(node, diagnostics) {
@@ -2035,7 +2085,7 @@ let NaslServer = class NaslServer {
         }
         if (node instanceof concepts_1.MatchCase && node.getAncestor('Match')?.isExpression && node.body.length === 0) {
             // 如果不是其他就标红
-            if ((node?.getIndexOfParent() !== (node.getAncestor('Match')?.cases?.length || 0) - 1)) {
+            if (node?.getIndexOfParent() !== (node.getAncestor('Match')?.cases?.length || 0) - 1) {
                 const diagnostic = {
                     node,
                     severity: 'error',
@@ -2089,7 +2139,7 @@ let NaslServer = class NaslServer {
             }
             if (node.tsErrorDetail) {
                 // 如果父级是枚举，而且子集选的是变量，就提示枚举值已被删除
-                if (matchExpressionType?.typeNamespace?.includes('enums') && (node instanceof concepts_1.MemberExpression)) {
+                if (matchExpressionType?.typeNamespace?.includes('enums') && node instanceof concepts_1.MemberExpression) {
                     node.tsErrorDetail.titleTip = '该枚举值已被删除';
                 }
                 else if (!node.tsErrorDetail.titleTip) {
@@ -2108,24 +2158,31 @@ let NaslServer = class NaslServer {
             diagnostics.push(diagnostic);
         }
         /**
-     * 如果节点是内置函数
-     * 穷举在线上的情况，不在线上就void报错， 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 !== 'CallInterface' && !node.__TypeAnnotation) {
+         * 如果节点是内置函数
+         * 穷举在线上的情况，不在线上就void报错， 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 !== 'CallInterface' &&
+            !node.__TypeAnnotation) {
             let showErr = false;
             if (node.parentNode?.parentNode?.concept === 'CallLogic') {
                 // calllogic 中别的类型会强校验，但是内置函数，不会强制校验，下面这几个其实是走的内置函数的实现，所以需要手动增加一下校验
                 const { calleeNamespace, calleeName } = node.parentNode.parentNode;
-                if ((calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') && (calleeName === 'showMessage' || calleeName === 'consoleLog' || calleeName === 'jsonSerialize' || calleeName === 'jsonDeserialize')) {
+                if ((calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') &&
+                    (calleeName === 'showMessage' || calleeName === 'consoleLog' || calleeName === 'jsonSerialize' || calleeName === 'jsonDeserialize')) {
                     showErr = true;
                 }
             }
@@ -2162,23 +2219,23 @@ let NaslServer = class NaslServer {
             const rightType = node.right?.__TypeAnnotation || {};
             // 如果左边节点是 泛型，而且 左边泛型的名字 和 右边一样， 而且是list 或者map 就强制报错
             // 而且右边原来没有报错
-            if (leftType.typeKind === 'generic' && leftType.typeKind === rightType.typeKind && leftType.typeName === rightType.typeName && ['Map', 'List'].includes(leftType.typeName)) {
-                if (!(node.right.tsErrorDetail) && leftType.sortedTypeKey !== rightType.sortedTypeKey) {
+            if (leftType.typeKind === 'generic' &&
+                leftType.typeKind === rightType.typeKind &&
+                leftType.typeName === rightType.typeName &&
+                ['Map', 'List'].includes(leftType.typeName)) {
+                if (!node.right.tsErrorDetail && leftType.sortedTypeKey !== rightType.sortedTypeKey) {
                     const excludeList = [
                         'nasl.collection.List<nasl.core.String>',
                         'nasl.collection.List<nasl.core.Email>',
                         'nasl.collection.Map<nasl.core.String, nasl.core.String>',
                         'nasl.collection.Map<nasl.core.String, nasl.core.Email>',
                     ];
-                    const excludeList2 = [
-                        'nasl.collection.List<>',
-                        'nasl.collection.List<T>',
-                    ];
+                    const excludeList2 = ['nasl.collection.List<>', 'nasl.collection.List<T>'];
                     // 先特殊处理等 类型合并后就可以去掉了
                     if (excludeList.includes(leftType.sortedTypeKey) && excludeList.includes(rightType.sortedTypeKey)) {
                         return null;
                     }
-                    else if (excludeList2.includes(leftType.sortedTypeKey) || excludeList2.includes(rightType.sortedTypeKey)) {
+                    if (excludeList2.includes(leftType.sortedTypeKey) || excludeList2.includes(rightType.sortedTypeKey)) {
                         return null;
                     }
                     const diagnostic = {
@@ -2215,7 +2272,7 @@ let NaslServer = class NaslServer {
                 if (typeKeyArr[0] === 'apis') {
                     const structureName = typeKeyArr[3];
                     const moduleName = typeKeyArr[1];
-                    const app = typeAnnotation.upperNode.app;
+                    const { app } = typeAnnotation.upperNode;
                     if (!app) {
                         return null;
                     }
@@ -2232,15 +2289,13 @@ let NaslServer = class NaslServer {
                 }
                 return null;
             }
-            else {
-                return diag;
-            }
+            return diag;
         });
         if (actionArr.length) {
             if (timer)
                 return;
             timer = window.setTimeout(() => {
-                const app = actionArr[0].target.app;
+                const { app } = actionArr[0].target;
                 app.emit('collect:start', {
                     actionMsg: '设置导入接口数据类型错误',
                 });
@@ -2257,11 +2312,11 @@ let NaslServer = class NaslServer {
         }
     }
     /**
- * 单个问题的诊断处理
- * @param diagnostic 诊断问题
- * @param fileNode 页面节点
- * @returns 处理后的结果
- */
+     * 单个问题的诊断处理
+     * @param diagnostic 诊断问题
+     * @param fileNode 页面节点
+     * @returns 处理后的结果
+     */
     _resolveDiagnostic(diagnostic, fileNode, record) {
         // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
         if ((fileNode.module || fileNode.connector) && !(fileNode instanceof concepts_1.ConfigProperty)) {
@@ -2295,14 +2350,14 @@ let NaslServer = class NaslServer {
         return result;
     }
     /**
- * 通过节点诊断反过来查找节点
- * @param diagnostic 诊断信息
- * @param fileNode 文件级别节点
- * @returns 找到的节点
- */
+     * 通过节点诊断反过来查找节点
+     * @param diagnostic 诊断信息
+     * @param fileNode 文件级别节点
+     * @returns 找到的节点
+     */
     _findMinRange(diagnostic, fileNode) {
         let minRange;
-        const sourceMap = fileNode.sourceMap;
+        const { sourceMap } = fileNode;
         for (const [node, item] of sourceMap.entries()) {
             /**
              * 当前内容的开始行 <= 诊断开始的行 &&
@@ -2313,7 +2368,8 @@ let NaslServer = class NaslServer {
                 if ((0, translator_1.lsp2tspNumber)(item.range.start.line) === diagnostic.start.line && (0, translator_1.lsp2tspNumber)(item.range.end.line) === diagnostic.end.line) {
                     // 在行的范围但是又不在列的范围，不用给默认值，给了反而不对，
                     // 需要在列的范围内
-                    if ((0, translator_1.lsp2tspNumber)(item.range.start.character) <= diagnostic.start.offset && (0, translator_1.lsp2tspNumber)(item.range.end.character) >= diagnostic.end.offset) {
+                    if ((0, translator_1.lsp2tspNumber)(item.range.start.character) <= diagnostic.start.offset &&
+                        (0, translator_1.lsp2tspNumber)(item.range.end.character) >= diagnostic.end.offset) {
                         // 比列更靠近 ，满足条件且长度更短
                         // 如果先走到下面有一个默认值了就像在if for里面有个表达式
                         // if for的内容也是包括当前的所以会重新赋值
@@ -2328,17 +2384,16 @@ let NaslServer = class NaslServer {
                     if (!minRange) {
                         minRange = { node, item };
                     }
-                    else if ((0, translator_1.lsp2tspNumber)(item.range.start.line) === diagnostic.start.line && diagnostic.start.offset >= (0, translator_1.lsp2tspNumber)(item.range.start.character)) {
+                    else if ((0, translator_1.lsp2tspNumber)(item.range.start.line) === diagnostic.start.line &&
+                        diagnostic.start.offset >= (0, translator_1.lsp2tspNumber)(item.range.start.character)) {
                         // 如果当前遍历的内容的行和列都 小于之前的， 而且是有效的
                         // 如果两个内容位置行数是一样的，就比较下找到内容的位置信息
                         // 找到的内容的开始位置， 要大于申明内容开始的位置，要不就不包含在内了
                         if (diagnostic.start.offset - item.range.start.character <= diagnostic.start.offset - minRange.item.range.start.character) {
                             minRange = { node, item };
                         }
-                        else {
-                            if (diagnostic.start.offset < (0, translator_1.lsp2tspNumber)(minRange.item.range.start.character)) {
-                                minRange = { node, item };
-                            }
+                        else if (diagnostic.start.offset < (0, translator_1.lsp2tspNumber)(minRange.item.range.start.character)) {
+                            minRange = { node, item };
                         }
                     }
                     else if (item.range.end.line - item.range.start.line <= minRange.item.range.end.line - minRange.item.range.start.line) {
@@ -2373,8 +2428,8 @@ let NaslServer = class NaslServer {
         const { currentSource, fileNode } = this.getCurrentSource(node);
         let refsList = [];
         /**
-     * 未完成创建的节点 ，或者异常情况 可能找不到节点
-     */
+         * 未完成创建的节点 ，或者异常情况 可能找不到节点
+         */
         if (currentSource) {
             const newRefs = await this.references({
                 file: fileNode.getEmbeddedFilePath(),
@@ -2383,23 +2438,21 @@ let NaslServer = class NaslServer {
             });
             refsList = [...newRefs.refs];
         }
-        else {
-            if (node instanceof concepts_1.Module) {
-                const lists = node.logics || node.structures || node.enums;
-                const moduleName = fileNode.getEmbeddedFilePath();
-                if (lists.length) {
-                    const item = lists[0];
-                    const { fileNode } = this.getCurrentSource(item);
-                    if (fileNode) {
-                        const newRefs = await this.references({
-                            file: fileNode.getEmbeddedFilePath(),
-                            line: 1,
-                            offset: 22, //固定的位置，module的位置信息
-                        });
-                        refsList = newRefs.refs.filter((item) => !item.file.startsWith(moduleName));
-                        // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
-                        refsList.unshift(newRefs.refs[0]);
-                    }
+        else if (node instanceof concepts_1.Module) {
+            const lists = node.logics || node.structures || node.enums;
+            const moduleName = fileNode.getEmbeddedFilePath();
+            if (lists.length) {
+                const item = lists[0];
+                const { fileNode } = this.getCurrentSource(item);
+                if (fileNode) {
+                    const newRefs = await this.references({
+                        file: fileNode.getEmbeddedFilePath(),
+                        line: 1,
+                        offset: 22, // 固定的位置，module的位置信息
+                    });
+                    refsList = newRefs.refs.filter((item) => !item.file.startsWith(moduleName));
+                    // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
+                    refsList.unshift(newRefs.refs[0]);
                 }
             }
         }
@@ -2410,12 +2463,12 @@ let NaslServer = class NaslServer {
                 const dataSourceFile = fileNode.getEmbeddedFilePath();
                 const entityFilePrefix = dataSourceFile.replace('.ts', '');
                 /**
-             * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
-             * 所以全部过滤掉了,
-             * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了11个函数之外的引用
-             * 所以底部内容是11个函数,所以这里就 用entity的行数 减去11个函数的行数,然后其余的在进行处理
-             * 进行过滤
-             */
+                 * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
+                 * 所以全部过滤掉了,
+                 * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了11个函数之外的引用
+                 * 所以底部内容是11个函数,所以这里就 用entity的行数 减去11个函数的行数,然后其余的在进行处理
+                 * 进行过滤
+                 */
                 // 不要数据源下面的实体里的引用 ,保留原始的节点内容
                 let flag = false;
                 if (item.file.includes(entityFilePrefix)) {
@@ -2458,7 +2511,7 @@ let NaslServer = class NaslServer {
                             const groupByLength = callQueryComponent.groupBy.filter((item) => item.groupElement?.propertyName && item.groupElement.asName).length;
                             if (!groupByLength && !aggregateLength && callQueryComponentTypeAnnotation.typeKind === 'anonymousStructure') {
                                 // 拿到 List 的泛型（匿名数据结构）的所有属性
-                                const properties = callQueryComponentTypeAnnotation.properties[0].typeAnnotation.typeArguments[0].properties;
+                                const { properties } = callQueryComponentTypeAnnotation.properties[0].typeAnnotation.typeArguments[0];
                                 const targetProperty = properties.find((p) => p.name === utils.firstLowerCase(node.name));
                                 if (!targetProperty) {
                                     continue;
@@ -2508,7 +2561,7 @@ let NaslServer = class NaslServer {
         if (node instanceof concepts_1.Param && (node.parentNode instanceof concepts_1.View || node.parentNode instanceof concepts_1.Process)) {
             const viewNode = node.parentNode;
             const { currentSource } = this.getCurrentSource(viewNode);
-            const code = currentSource.code;
+            const { code } = currentSource;
             const viewIndex = code.indexOf(' {');
             const viewRefs = await this.references({
                 file: fileNode.getEmbeddedFilePath(),
@@ -2526,12 +2579,12 @@ let NaslServer = class NaslServer {
             refsList = [...refsList, ...filterViewRefs];
         }
         /**
-     * 暂时不要了， 因为生成的结构发生了变化
-     * view 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
-     * 找到第一个 { 之前的变量 进行修改
-     * 如果是VIew的查找，比较特殊，他查的是当前抛出的 {} 大括号前的
-     * 最后一个，因为生成的规则不一样
-     */
+         * 暂时不要了， 因为生成的结构发生了变化
+         * view 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
+         * 找到第一个 { 之前的变量 进行修改
+         * 如果是VIew的查找，比较特殊，他查的是当前抛出的 {} 大括号前的
+         * 最后一个，因为生成的规则不一样
+         */
         // if (node instanceof View) {
         //     const code = currentSource.code;
         //     const viewIndex = code.indexOf(' {');
@@ -2543,11 +2596,11 @@ let NaslServer = class NaslServer {
         //     refsList = [...viewRefs.refs];
         // }
         /**
-     * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
-     */
+         * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
+         */
         if (node instanceof concepts_1.ViewElement) {
             if (currentSource) {
-                const code = currentSource.code;
+                const { code } = currentSource;
                 const prefix = '__elements.';
                 const prefixIndex = code.indexOf(prefix) !== -1 ? code.indexOf(prefix) : 0;
                 const methodsNameIndex = prefixIndex + prefix.length;
@@ -2572,7 +2625,7 @@ let NaslServer = class NaslServer {
         }
         if (node instanceof concepts_1.Process) {
             if (currentSource) {
-                const code = currentSource.code;
+                const { code } = currentSource;
                 const prefix = '__ProcessIdentification__';
                 let positions = [];
                 let pos = code.indexOf(prefix);
@@ -2597,7 +2650,7 @@ let NaslServer = class NaslServer {
         if ((node instanceof concepts_1.Param || node instanceof concepts_1.Return) && node.parentNode instanceof concepts_1.Process) {
             const { currentSource } = this.getCurrentSource(node.parentNode);
             if (currentSource) {
-                const code = currentSource.code;
+                const { code } = currentSource;
                 const prefix = '__ProcessIdentification__';
                 const positions = [];
                 let pos = code.indexOf(prefix);
@@ -2625,7 +2678,7 @@ let NaslServer = class NaslServer {
         }
         if (node instanceof concepts_1.ProcessElement) {
             if (currentSource) {
-                const code = currentSource.code;
+                const { code } = currentSource;
                 const prefix = '__ProcessIdentification__';
                 let positions = [];
                 let pos = code.indexOf(prefix);
@@ -2649,7 +2702,7 @@ let NaslServer = class NaslServer {
         if (node instanceof concepts_1.Return && node.parentNode instanceof concepts_1.ProcessElement) {
             const { currentSource } = this.getCurrentSource(node.parentNode);
             if (currentSource) {
-                const code = currentSource.code;
+                const { code } = currentSource;
                 const prefix = '__ProcessIdentification__';
                 const positions = [];
                 let pos = code.indexOf(prefix);
@@ -2682,13 +2735,13 @@ let NaslServer = class NaslServer {
         return refsList;
     }
     /**
- * 查找引用，并且做一些 修改前的准备工作，
- * 有引用有的话，就返回集合
- * @param node 当前重命名的节点
- * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
- * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
- * @returns 找到的引用
- */
+     * 查找引用，并且做一些 修改前的准备工作，
+     * 有引用有的话，就返回集合
+     * @param node 当前重命名的节点
+     * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+     * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+     * @returns 找到的引用
+     */
     _renamePrepare(node, refsList, newValue) {
         const oldName = node?.name;
         const result = refsList
@@ -2719,10 +2772,11 @@ let NaslServer = class NaslServer {
                 }
                 if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.ViewElement) {
                     minRange.setTypeMethods = 'setCalleeNamespace';
-                    minRange.newValue = 'elements.' + newValue + '.logics';
+                    minRange.newValue = `elements.${newValue}.logics`;
                 }
                 // 如果节点是实体修改引发calllogic修改
-                if (minRange.node instanceof concepts_1.CallLogic && (node instanceof concepts_1.Entity || node instanceof concepts_1.View || node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
+                if (minRange.node instanceof concepts_1.CallLogic &&
+                    (node instanceof concepts_1.Entity || node instanceof concepts_1.View || node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
                     // 匹配到的内容，当前这一行的内容；
                     // 因为要用下面的点位信息
                     /**
@@ -2735,9 +2789,9 @@ let NaslServer = class NaslServer {
                      * 3.然后把namespace中的 $替换成 ''
                      *
                      */
-                    const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                    const { tsCalleeNamespace } = minRange.node;
                     // 先看下标位置
-                    const lineText = record.lineText;
+                    const { lineText } = record;
                     const index = lineText.indexOf(tsCalleeNamespace);
                     // 在把开始结束位置的-开始位置，来知道是哪里要替换
                     const start = record.start.offset - index - 1;
@@ -2772,12 +2826,12 @@ let NaslServer = class NaslServer {
                 if (minRange.node instanceof concepts_1.Identifier) {
                     // 匹配到的内容，当前这一行的内容；
                     // 因为要用下面的点位信息
-                    const name = minRange.node.name;
+                    const { name } = minRange.node;
                     // 如果name不改，那就是要改命名空间
                     if (node instanceof concepts_1.Frontend || newValue === name) {
-                        const namespace = minRange.node.namespace;
+                        const { namespace } = minRange.node;
                         // 先看下标位置
-                        const lineText = record.lineText;
+                        const { lineText } = record;
                         const index = lineText.indexOf(namespace);
                         // 在把开始结束位置的-开始位置，来知道是哪里要替换
                         const start = record.start.offset - index - 1;
@@ -2809,7 +2863,7 @@ let NaslServer = class NaslServer {
                     // 枚举key的特殊性，因为它不是原来的key+value形式的
                     // 是加了中括号啥的，所以直接赋值新值
                     if (node instanceof concepts_1.EnumItem) {
-                        const newTextValue = node.parentNode.name + '.' + newValue;
+                        const newTextValue = `${node.parentNode.name}.${newValue}`;
                         minRange.newValue = newTextValue;
                     }
                     else {
@@ -2834,7 +2888,7 @@ let NaslServer = class NaslServer {
                         minRange.setTypeMethods = 'setRelationEntity';
                     }
                     else if (minRange.node instanceof concepts_1.QueryFieldExpression) {
-                        if (minRange.node.parentKey === "selectElements") {
+                        if (minRange.node.parentKey === 'selectElements') {
                             minRange.setTypeMethods = 'setEntityAsNameAndEffect';
                         }
                         else {
@@ -2849,7 +2903,7 @@ let NaslServer = class NaslServer {
                     }
                     else if (minRange.node instanceof concepts_1.BindAttribute && minRange.node.name === 'url') {
                         // 如果是查找到 上传地址的链接引用
-                        let newName = newValue.replace(/[A-Z]/g, (item) => '-' + item.toLowerCase());
+                        let newName = newValue.replace(/[A-Z]/g, (item) => `-${item.toLowerCase()}`);
                         newName = newName[0] === '-' ? newName.slice(1) : newName;
                         const newTextValue = node.parentNode.name === 'defaultDS' ? `/api/${newName}/import` : `/api/${node.parentNode.name}/${newName}/import`;
                         minRange.setTypeMethods = 'setUrlValue';
@@ -2860,7 +2914,9 @@ let NaslServer = class NaslServer {
                     }
                 }
                 // 如果是修改实体属性，要同步实体属性
-                if (minRange.node instanceof concepts_1.EntityProperty && node instanceof concepts_1.EntityProperty && record.lineText.includes('@nasl.annotation.EntityRelation')) {
+                if (minRange.node instanceof concepts_1.EntityProperty &&
+                    node instanceof concepts_1.EntityProperty &&
+                    record.lineText.includes('@nasl.annotation.EntityRelation')) {
                     minRange.setTypeMethods = 'setRelationProperty';
                 }
                 // 如果要修改索引的
@@ -2887,11 +2943,11 @@ let NaslServer = class NaslServer {
                      * 3.然后把namespace中的 $替换成 ''
                      *
                      */
-                    const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
-                    const tsName = minRange.node.tsName;
-                    const oldValue = tsCalleeNamespace + '.' + tsName;
+                    const { tsCalleeNamespace } = minRange.node;
+                    const { tsName } = minRange.node;
+                    const oldValue = `${tsCalleeNamespace}.${tsName}`;
                     // 先看下标位置
-                    const lineText = record.lineText;
+                    const { lineText } = record;
                     const index = lineText.indexOf(oldValue);
                     // 在把开始结束位置的-开始位置，来知道是哪里要替换
                     const start = record.start.offset - index - 1;
@@ -2909,11 +2965,11 @@ let NaslServer = class NaslServer {
                     }
                 }
                 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 { tsCalleeNamespace } = minRange.node;
+                    const { tsName } = minRange.node;
+                    const oldValue = `${tsCalleeNamespace}.${tsName}`;
                     // 先看下标位置
-                    const lineText = record.lineText;
+                    const { lineText } = record;
                     const index = lineText.indexOf(oldValue);
                     // 在把开始结束位置的-开始位置，来知道是哪里要替换
                     const start = record.start.offset - index - 1;
@@ -2933,7 +2989,7 @@ let NaslServer = class NaslServer {
                     // 页面逻辑直接赋值就可以, 因为是相对路径
                     if (node instanceof concepts_1.ViewElement) {
                         minRange.setTypeMethods = 'setCalleeNamespace';
-                        minRange.newValue = 'elements.' + newValue + '.logics';
+                        minRange.newValue = `elements.${newValue}.logics`;
                     }
                     else {
                         /**
@@ -2945,10 +3001,10 @@ let NaslServer = class NaslServer {
                          * 2.在匹配到的内容中取转后的namespace的位置
                          * 3.然后把namespace中的 $替换成 ''
                          */
-                        const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                        const { tsCalleeNamespace } = minRange.node;
                         const oldValue = tsCalleeNamespace;
                         // 先看下标位置
-                        const lineText = record.lineText;
+                        const { lineText } = record;
                         const index = lineText.indexOf(oldValue);
                         // 在把开始结束位置的-开始位置，来知道是哪里要替换
                         const start = record.start.offset - index - 1;
@@ -3011,7 +3067,7 @@ let NaslServer = class NaslServer {
                 if (node instanceof concepts_1.DataSource) {
                     const setTypeNamespace = (typeNamespace, record) => {
                         // 先看下标位置
-                        const lineText = record.lineText;
+                        const { lineText } = record;
                         const index = lineText.indexOf(typeNamespace);
                         // 在把开始结束位置的-开始位置，来知道是哪里要替换
                         const start = record.start.offset - index - 1;
@@ -3055,8 +3111,8 @@ let NaslServer = class NaslServer {
                     minRange.setTypeMethods = 'setPropertyName';
                 }
                 // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
-                if ((minRange.node instanceof concepts_1.Param || minRange.node instanceof concepts_1.Variable || minRange.node instanceof concepts_1.Return)
-                    && (node instanceof concepts_1.Entity || node instanceof concepts_1.Enum || node instanceof concepts_1.Structure)) {
+                if ((minRange.node instanceof concepts_1.Param || minRange.node instanceof concepts_1.Variable || minRange.node instanceof concepts_1.Return) &&
+                    (node instanceof concepts_1.Entity || node instanceof concepts_1.Enum || node instanceof concepts_1.Structure)) {
                     return null;
                 }
                 if (minRange.node instanceof concepts_1.Destination && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
@@ -3078,11 +3134,11 @@ let NaslServer = class NaslServer {
                     minRange.setTypeMethods = 'setKeyword';
                 }
                 /**
-             * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
-             * 流程改名不触发Logic改名
-             * 如果是修改param查找到logic就不操作
-             * 除非想在内部修改别的内容所以暂时屏蔽掉
-             */
+                 * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
+                 * 流程改名不触发Logic改名
+                 * 如果是修改param查找到logic就不操作
+                 * 除非想在内部修改别的内容所以暂时屏蔽掉
+                 */
                 if (minRange.node instanceof concepts_1.Logic && node !== minRange.node) {
                     return null;
                 }
@@ -3137,7 +3193,7 @@ let NaslServer = class NaslServer {
             if (a.node.concept === 'QueryFieldExpression') {
                 return 1;
             }
-            else if (b.node.concept === 'QueryFieldExpression') {
+            if (b.node.concept === 'QueryFieldExpression') {
                 return -1;
             }
             return 0;
@@ -3334,11 +3390,11 @@ let NaslServer = class NaslServer {
         return treeNodeMap;
     }
     /**
- * 处理tree的队列，把相同节点进行合并
- * 这里把当前二维数组进行一个整合
- * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
- * @returns 最后要使用到的节点和对应的子集
- */
+     * 处理tree的队列，把相同节点进行合并
+     * 这里把当前二维数组进行一个整合
+     * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
+     * @returns 最后要使用到的节点和对应的子集
+     */
     handleTreeQueue(queueLists) {
         const map = new Map();
         let root = null;
@@ -3366,11 +3422,11 @@ let NaslServer = class NaslServer {
         return children;
     }
     /**
- * 递归调用输出结果
- * @param root 一个根节点
- * @param map 当前所有节点的map对象
- * @returns 当前节点，最后输出所有节点
- */
+     * 递归调用输出结果
+     * @param root 一个根节点
+     * @param map 当前所有节点的map对象
+     * @returns 当前节点，最后输出所有节点
+     */
     _recursionCreateResult(root, map) {
         const children = (map.get(root) || []).map((item) => this._recursionCreateResult(item, map));
         if (children && children.length) {
@@ -3379,27 +3435,27 @@ let NaslServer = class NaslServer {
         return root;
     }
     /**
- *  获取
- *  当前this上下文 的Source 和 父级文件级别的节点
- */
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
     getCurrentSource(node) {
         if (node instanceof concepts_1.App || node instanceof concepts_1.Theme)
             return { fileNode: null };
-        let sourceMap = node.sourceMap;
+        let { sourceMap } = node;
         let fileNode = node;
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
         // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
         // 如果当前节点是view就不要向上查找了
         // 配置参数的ConfigProperty也不需要向上找
-        while (!sourceMap
-            && fileNode
-            && !(fileNode.parentNode instanceof concepts_1.App)
-            && !(fileNode.parentNode instanceof concepts_1.Module)
-            && !(fileNode.parentNode instanceof concepts_1.DataSource)
-            && !(fileNode.parentNode instanceof concepts_1.Frontend)
-            && !(fileNode.parentNode instanceof concepts_1.Backend)
-            && !(fileNode instanceof concepts_1.View)
-            && !(fileNode instanceof concepts_1.ConfigProperty)) {
+        while (!sourceMap &&
+            fileNode &&
+            !(fileNode.parentNode instanceof concepts_1.App) &&
+            !(fileNode.parentNode instanceof concepts_1.Module) &&
+            !(fileNode.parentNode instanceof concepts_1.DataSource) &&
+            !(fileNode.parentNode instanceof concepts_1.Frontend) &&
+            !(fileNode.parentNode instanceof concepts_1.Backend) &&
+            !(fileNode instanceof concepts_1.View) &&
+            !(fileNode instanceof concepts_1.ConfigProperty)) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -3432,9 +3488,7 @@ let NaslServer = class NaslServer {
                 getFieldKey: fieldKey,
             });
         }
-        else {
-            console.log('没找到节点', currentSource, fileNode);
-        }
+        console.log('没找到节点', currentSource, fileNode);
     }
     _getFieldKeySelectCompletion(args) {
         return this.messager.requestCommand('getFieldKeySelectCompletion', args);
@@ -3482,12 +3536,15 @@ let NaslServer = class NaslServer {
         });
         return [...fileNodes];
     }
-    /**获取当前节点的已知类型
- * @param node 当前要获取类型的节点
- * @returns 不需要去查就可以返回类型的节点
- */
+    /** 获取当前节点的已知类型
+     * @param node 当前要获取类型的节点
+     * @returns 不需要去查就可以返回类型的节点
+     */
     getCurrentNodeKnownTypeAnnotation(node) {
-        if (node.concept === 'StringLiteral' || node.concept === 'StringInterpolation' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
+        if (node.concept === 'StringLiteral' ||
+            node.concept === 'StringInterpolation' ||
+            node.concept === 'BooleanLiteral' ||
+            node.concept === 'NullLiteral') {
             let type = 'String';
             switch (node.concept) {
                 case 'NullLiteral':
@@ -3500,17 +3557,17 @@ let NaslServer = class NaslServer {
             return concepts_1.TypeAnnotation.createPrimitive(type);
         }
         // 这些原有类型的 比较的 返回值肯定就是布尔值，就不去调用ls
-        if (node instanceof concepts_1.BinaryExpression && (['==', '!=', '>', '<', '>=', '<='].includes(node.operator))) {
+        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' && (['Convert', 'New', 'FromString'].includes(node.calleeName))) {
+        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 instanceof concepts_1.CallLogic && node.calleeNamespace === 'nasl.util' && node.calleeName === 'jsonDeserialize') {
             if (node.typeArguments.length) {
                 return node.typeArguments[0];
             }
@@ -3548,7 +3605,7 @@ let NaslServer = class NaslServer {
         // 总共要返回出去的
         const types = new Map();
         const newQuickInfoNodes = [];
-        nodes.forEach((itemDetail) => {
+        await utils.timeSlicing(nodes, (itemDetail) => {
             const { node, filePath, item } = itemDetail;
             // 先按照顺序占位
             types.set(node, null);
@@ -3559,23 +3616,16 @@ let NaslServer = class NaslServer {
                 return;
             }
             // 要通过自己或者依赖关系拿的，二次遍历
-            if ([
-                'Argument',
-                'Assignment',
-                'MatchCase',
-            ].includes(node.concept)) {
+            if (['Argument', 'Assignment', 'MatchCase'].includes(node.concept)) {
                 getFromOthers.set(node, null);
             }
-            if ([
-                'Return',
-                'Variable',
-            ].includes(node.concept) && node.typeAnnotation) {
+            if (['Return', 'Variable'].includes(node.concept) && node.typeAnnotation) {
                 types.set(node, node.typeAnnotation);
                 return;
             }
             // 如果 入参不是虚拟节点的，就不去请求类型
             // 只有虚拟节点的入参，才没有类型
-            if (node.concept === 'Param' && node.parentKey !== 'virtualParams') {
+            if (node.concept === 'Param' && node.parentKey !== 'virtualParams' && node.parentKey !== 'item') {
                 return;
             }
             if (![
@@ -3611,11 +3661,12 @@ let NaslServer = class NaslServer {
                 offset: (0, translator_1.lsp2tspNumber)(item.range.start.character),
             };
             // 位置计算偏移
-            if (node.concept === 'CallLogic' && node.useIife) {
-                fileDetail.line += 2;
-                fileDetail.offset = 8;
+            if ('getQuickInfoOffset' in node) {
+                Object.assign(fileDetail, node.getQuickInfoOffset(fileDetail, item.code));
             }
-            else if (node.concept === 'BinaryExpression' ||
+            // 位置计算偏移2
+            // TODO: 之后考虑把这些偏移量计算全都挪到节点内部去
+            if (node.concept === 'BinaryExpression' ||
                 node.concept === 'CallLogic' ||
                 node.concept === 'CallFunction' ||
                 node.concept === 'CallInterface') {
@@ -3638,15 +3689,18 @@ let NaslServer = class NaslServer {
                     const lastLen = codeArr?.[codeArr.length - 1]?.length;
                     indexOf = subStr.length - lastLen;
                 }
-                fileDetail.offset = fileDetail.offset + indexOf;
+                fileDetail.offset += indexOf;
             }
-            else if (node.concept === 'MemberExpression' || node.concept === 'Identifier' || node.concept === 'QueryFieldExpression' || node.concept === 'QueryGroupByExpression') {
+            else if (node.concept === 'MemberExpression' ||
+                node.concept === 'Identifier' ||
+                node.concept === 'QueryFieldExpression' ||
+                node.concept === 'QueryGroupByExpression') {
                 if (item.code.includes('.')) {
                     const codeArr = item.code?.split('.');
                     const lastLen = codeArr?.[codeArr.length - 1]?.length;
                     // MemberExpression取最后一位当做类型
                     const indexOf = item.code.length - lastLen;
-                    fileDetail.offset = fileDetail.offset + indexOf;
+                    fileDetail.offset += indexOf;
                 }
             }
             else if (node.concept === 'Match') {
@@ -3673,27 +3727,17 @@ let NaslServer = class NaslServer {
                 fileDetail.offset += 10;
             }
             args.push(fileDetail);
-        });
-        // console.time('请求');
+        }, { minimum: 1000 });
         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;
+        await utils.timeSlicing(args, ({ file, line, offset }, index) => {
             const item = resultMap?.[file]?.[line]?.[offset];
-            //const displayString1 = resule1[index]?.displayString;
-            // console.log('位置：', file, line, offset);
-            // 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);
-            types.set(newQuickInfoNodes[index].node, Object.freeze(nodeTypeAnnotation));
-            newQuickInfoNodes[index].node.__nodeType = Object.freeze(item?.[0]?.nodeType);
-            // console.log('方案1：', displayString1);
+            const itemType = item?.[0]?.nodeType;
+            const nodeTypeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(itemType);
+            const { node } = newQuickInfoNodes[index];
+            types.set(node, Object.freeze(nodeTypeAnnotation));
+            node.__nodeType = itemType ? (Object.isFrozen(itemType) ? itemType : Object.freeze(itemType)) : null;
         });
-        getFromOthers.forEach((type, node) => {
+        await utils.timeSlicing(Array.from(getFromOthers.entries()), ([node]) => {
             if (node instanceof concepts_1.Assignment) {
                 if (!types.get(node.left)) {
                     types.set(node.left, types.get(node.right));
@@ -3715,8 +3759,7 @@ let NaslServer = class NaslServer {
                 }
             }
         });
-        // 重置类型状态, 并且赋值
-        types.forEach((value, node) => {
+        await utils.timeSlicing(Array.from(types.entries()), ([node, value]) => {
             try {
                 // 因为node可能是经过处理的TypeAnnotation
                 node.__isCorrectTypeAnnotation = true;
@@ -3726,7 +3769,7 @@ let NaslServer = class NaslServer {
                         const typeAnnotation = value;
                         if (!node.typeAnnotation && typeAnnotation) {
                             if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
-                                const typeArguments = typeAnnotation.typeArguments;
+                                const { typeArguments } = typeAnnotation;
                                 if (typeArguments.length && typeArguments[0].isComplexType()) {
                                     node.__TypeAnnotation = null;
                                     return;
@@ -3752,53 +3795,6 @@ let NaslServer = class NaslServer {
                 }
             }
         });
-        // newQuickInfoNodes.forEach((itemDetail, index) => {
-        //     const { node, filePath } = itemDetail;
-        //     if (!result[index] || node.concept === 'Argument')
-        //         return;
-        //     // console.log(result[index].displayString, node);
-        //     /**
-        //      * 这个前缀是给会自动省略命名空间的内容设置的，下个版本干掉，应急的方法
-        //      */
-        //     let parentPrefix;
-        //     if (filePath && (filePath.split('/').length > 3)) {
-        //         const arr = filePath.split('/');
-        //         if (arr[3] === 'dependencies' || arr[3] === 'interfaceDependencies' || arr[3] === 'componentDependencies') {
-        //             const map = {
-        //                 dependencies: 'extensions',
-        //                 interfaceDependencies: 'apis',
-        //                 componentDependencies: 'components',
-        //             };
-        //             parentPrefix = `${map[arr[3]]}.${arr[4]}.`;
-        //         }
-        //     }
-        //     const nodeTypeAnnotation = displayString2TypeAnnotation(result[index].displayString, parentPrefix);
-        //     // console.log(result[index].displayString, items[index], '************', typeAnnotation);
-        //     // console.log(node, index, items[index].code, result[index].displayString, '+++++++++++++++++++++++++++', typeAnnotation && typeAnnotation.typeKey)
-        //     try {
-        //         types.set(node, nodeTypeAnnotation);
-        //         /**
-        //         * 没有类型标注的情况
-        //         * 1.void 没有返回值
-        //         * 2.Argment
-        //         */
-        //         // if (!typeAnnotation) {
-        //         //     console.log(items[index].code, jsonNode, result[index]);
-        //         //     console.log(result[index].displayString)
-        //         // }
-        //     } catch (e) {
-        //         console.log(node, node.getNodePath(false));
-        //     }
-        // });
-        // // Argument的标注，因为这个位置上可能放任何东西所以直接在其内部去取
-        // newQuickInfoNodes.forEach((itemDetail, index) => {
-        //     const { node } = itemDetail;
-        //     if (node instanceof Argument) {
-        //         // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
-        //         const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, result, (types as any));
-        //         types.set(node, argType);
-        //     }
-        // });
         return types;
     }
     // 全量标注并且返回json
@@ -3821,9 +3817,7 @@ let NaslServer = class NaslServer {
         });
         console.time('全量标注');
         const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
-        // console.log(typesMap, 'typesMap')
         console.timeEnd('全量标注');
-        //console.log('一共处理节点数：', types.size);
         const json = app.toJSON();
         if (releaseFlag) {
             // 全量标注后对json进行一些修改，为了服务端翻译处理
@@ -3842,13 +3836,14 @@ let NaslServer = class NaslServer {
             record.id = fileNode.id;
             record.node = fileNode;
             if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
-                fileNode.sourceMap && fileNode.sourceMap.forEach((item, nodeItem) => {
-                    nodes.push({
-                        filePath: record.filePath,
-                        node: nodeItem,
-                        item,
+                fileNode.sourceMap &&
+                    fileNode.sourceMap.forEach((item, nodeItem) => {
+                        nodes.push({
+                            filePath: record.filePath,
+                            node: nodeItem,
+                            item,
+                        });
                     });
-                });
             }
         });
         await this.getQuickInfoNodesTypeMap(nodes);
@@ -3882,7 +3877,8 @@ let NaslServer = class NaslServer {
                     typeArguments: [],
                     inferred: false,
                     ruleMap: null,
-                    properties: [{
+                    properties: [
+                        {
                             concept: 'StructureProperty',
                             name: 'list',
                             label: null,
@@ -3897,7 +3893,8 @@ let NaslServer = class NaslServer {
                             },
                             required: null,
                             defaultValue: null,
-                        }, {
+                        },
+                        {
                             concept: 'StructureProperty',
                             name: 'total',
                             label: null,
@@ -3912,7 +3909,8 @@ let NaslServer = class NaslServer {
                             },
                             required: null,
                             defaultValue: null,
-                        }],
+                        },
+                    ],
                 };
             }
             // 特殊处理param有类型错误的
@@ -3925,7 +3923,8 @@ let NaslServer = class NaslServer {
             }
             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)) {
+                if (matchExpression?.__TypeAnnotation?.typeKind === 'union' &&
+                    (matchExpression instanceof concepts_1.Identifier || matchExpression instanceof concepts_1.MemberExpression)) {
                     const { currentSource, fileNode } = matchExpression?.getCurrentSource();
                     fileNode.sourceMap.forEach((item, itemNode) => {
                         if (itemNode.concept === matchExpression.concept && item.code === currentSource.code) {
@@ -3950,13 +3949,16 @@ let NaslServer = class NaslServer {
         });
     }
     /**
- * 获取getArgument的参数位的类型
- * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
- * 获取logic的默认值和原来Arg的类型和默认值对应
- */
+     * 获取getArgument的参数位的类型
+     * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
+     * 获取logic的默认值和原来Arg的类型和默认值对应
+     */
     getArgumentTypeAnnotation(node, QuickInfoNodes, types) {
         // 直接复用内部expression的type类型
-        if (node.parentNode instanceof concepts_1.CallLogic && node.parentNode.calleeNamespace?.includes('entities') && node.parentNode.calleeNamespace?.includes('logics') && node.parentNode.calleeName === 'delete') {
+        if (node.parentNode instanceof concepts_1.CallLogic &&
+            node.parentNode.calleeNamespace?.includes('entities') &&
+            node.parentNode.calleeNamespace?.includes('logics') &&
+            node.parentNode.calleeName === 'delete') {
             const nodeType = node.parentNode?.__nodeType;
             if (nodeType && Array.isArray(nodeType.fnParams)) {
                 const index = node.parentNode.arguments.indexOf(node);
@@ -3972,7 +3974,7 @@ let NaslServer = class NaslServer {
         }
         // 获取返回值结果里找到父级的callLogic || CallInterface的类型填充进去Argument
         const App = node.app;
-        const parent = (node.parentNode);
+        const parent = node.parentNode;
         // 如果nasl包下的 ，很多声明都含有T啥的先用自己内部的
         if (!parent.calleeNamespace || parent.calleeNamespace?.startsWith('nasl')) {
             if (types.get(node.expression)) {
@@ -3983,7 +3985,7 @@ let NaslServer = class NaslServer {
             }
         }
         // 用户自己声明的用用户的
-        const callObj = App.findNodeByCompleteName(parent.calleeNamespace + '.' + parent.calleeName);
+        const callObj = App.findNodeByCompleteName(`${parent.calleeNamespace}.${parent.calleeName}`);
         const index = parent.arguments.indexOf(node);
         const param = callObj?.params?.[index] || {};
         // 取出参数的类型
@@ -4075,8 +4077,8 @@ let NaslServer = class NaslServer {
         const filePath = fileNode.getEmbeddedFilePath();
         // 如果要删除，而且当前要删Logic就直接删除并且清除错误
         /**
-     * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
-     */
+         * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
+         */
         let outputFiles = [];
         // 删除之前先查一下内容的依赖
         const newRefs = await this.references({
@@ -4136,18 +4138,20 @@ let NaslServer = class NaslServer {
                     node: fileNode,
                     icon: 'success',
                 };
-                (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => { });
+                (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => {
+                    // ..
+                });
             }
         }
     }
     /**
- * 重命名的更新
- * @param fileNode 文件级别的节点
- * @param targetNode 触发修改的节点
- * @param result 生成代码的code 和位置信息
- * @param isRename 是不是修改名字
- * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
- */
+     * 重命名的更新
+     * @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 }];
@@ -4241,7 +4245,7 @@ let NaslServer = class NaslServer {
      */
     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++) {
@@ -4259,7 +4263,7 @@ let NaslServer = class NaslServer {
                     else if (action === 'update' && oldpath) {
                         const parentPath = oldpath.replace('.ts', '/');
                         const foldName = fileNodeItem.concept === 'View' ? 'views' : 'variables';
-                        const currentOldPath = parentPath + foldName + '/' + fileNodeItem.name + '.ts';
+                        const currentOldPath = `${parentPath + foldName}/${fileNodeItem.name}.ts`;
                         // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
                         await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
                         await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
@@ -4283,7 +4287,7 @@ let NaslServer = class NaslServer {
                     }
                     else if (action === 'update' && oldpath) {
                         const parentPath = oldpath.replace('.ts', '/');
-                        const currentOldPath = parentPath + fileNodeItem.name + '.ts';
+                        const currentOldPath = `${parentPath + fileNodeItem.name}.ts`;
                         // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
                         await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
                         await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
@@ -4321,14 +4325,14 @@ let NaslServer = class NaslServer {
                 }
             }
             /**
-     * DataSource只会重命名时候，需要把子集全部重新生成一下
-     */
+             * 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';
+                        const currentOldPath = `${parentPath}/entities/${entity.name}.ts`;
                         // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
                         await this.handleRename(entity, entity, result, currentOldPath);
                     }
@@ -4342,8 +4346,12 @@ let NaslServer = class NaslServer {
     async receiveHandleChange($event) {
         this.singleFileChangeIng = true;
         // 行为
-        const action = $event.action;
+        const { action } = $event;
         const targetNode = $event.target;
+        // Connection 相关配置的更新不需要写入文件
+        if (targetNode?.parentNode instanceof concepts_1.Connection) {
+            return;
+        }
         // 当前操作的文件节点
         const { fileNode } = this.getCurrentSource(targetNode);
         // 不处理系统配置参数
@@ -4358,7 +4366,9 @@ let NaslServer = class NaslServer {
             }
             return;
         }
+        console.time('重新生成 TS 文件');
         const result = fileNode.toEmbeddedTSFile();
+        console.timeEnd('重新生成 TS 文件');
         // 当前操作的节点
         // 如果当前没有生成tsFile
         if (!result) {
@@ -4393,9 +4403,11 @@ let NaslServer = class NaslServer {
     changeFileNext() {
         if (!this.singleFileChangeIng) {
             const item = this.changeStackList.shift();
-            this.receiveHandleChange(item).catch((err) => {
+            this.receiveHandleChange(item)
+                .catch((err) => {
                 console.log(err, 'receiveHandleChangeErr');
-            }).finally(async () => {
+            })
+                .finally(async () => {
                 // 每一个文件与change接触就把状态置为false，让下一个进入
                 this.singleFileChangeIng = false;
                 if (this.changeStackList.length) {
@@ -4410,6 +4422,15 @@ let NaslServer = class NaslServer {
         }
     }
 };
+__decorate([
+    (0, decorators_1.withQueueExecute)('diagnostic')
+], NaslServer.prototype, "_resolveDiagnosticRecords", null);
+__decorate([
+    (0, decorators_1.withQueueExecute)('annotation')
+], NaslServer.prototype, "getNaslAnnotatedJSON", null);
+__decorate([
+    (0, decorators_1.withQueueExecute)('annotation')
+], NaslServer.prototype, "IncrementalAnnotationJSON", null);
 NaslServer = __decorate([
     sentry_1.sentryMonitorNaslServer
 ], NaslServer);