@lcap/nasl 2.18.0-beta.3 → 2.18.0

package/src/server/dist/naslServer.js

@@ -0,0 +1,3396 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.NaslServer = exports.getDisplayString2Type = void 0;
+/// #if process.env.BUILD_TARGET === 'node'
+var fs = require("fs-extra");
+var path = require("path");
+var worker_threads_1 = require("worker_threads");
+/// #endif
+var config_1 = require("../config");
+var Messager_1 = require("../common/Messager");
+var getMemberIdentifier_1 = require("../server/getMemberIdentifier");
+var concepts_1 = require("../concepts");
+var translator_1 = require("../translator");
+var storage_1 = require("../service/storage");
+var translator_2 = require("./translator");
+var common_1 = require("../common");
+var diagnostic_1 = require("../manager/diagnostic");
+var createUiTs_1 = require("./createUiTs");
+var coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
+var formatTsUtils_1 = require("./formatTsUtils");
+var naslStdlibMap_1 = require("./naslStdlibMap");
+var jsoner = require("../service/storage/jsoner");
+var EventEmitter_1 = require("../common/EventEmitter");
+var EmbeddedTSFileLineMap = {
+    Entity: 3
+};
+var EmbeddedTSFileOffsetMap = {
+    Variable: 12
+};
+// 要Check的文件
+var filesToCheck = new Set();
+// 单个文件正在change，不允许同时两个文件一起change
+var singleFileChangeIng = false;
+var isChangeInterface = false; //判断是否导入接口
+var actionArr = []; //用于导入接口收集更改的节点
+var timer = null; //超时器用于收集导入接口相关
+// 联合类型切割取出类型
+function getDisplayString2Type(displayString) {
+    // 取出匹配的内容
+    var reg = /<([^()]+)>/g;
+    // 解决extends 导致类型缺失的问题
+    displayString = (displayString === null || displayString === void 0 ? void 0 : displayString.replace('T extends ', '')) || '';
+    var types = reg.exec(displayString);
+    // 取出提示的类型，组成是数组
+    var typeList = types[1].split(' | ').map(function (item) {
+        if (/<([^()]+)>/g.exec(item)) {
+            return item;
+        }
+        else if (item.includes(' ')) {
+            var strs = item.split(' ');
+            var type = strs[strs.length - 1];
+            return type;
+        }
+        else if (item.includes('.')) {
+            var strs = item.split('.');
+            var type = strs[strs.length - 1];
+            return type;
+        }
+        else {
+            return item;
+        }
+    });
+    return typeList;
+}
+exports.getDisplayString2Type = getDisplayString2Type;
+var NaslServer = /** @class */ (function () {
+    function NaslServer() {
+        var _this = this;
+        this.messager = undefined;
+        this.worker = undefined;
+        /**
+         * 按道理 fileSourceMap: new Map<string, SourceMap>() 比较合理，
+         * 但是要多维护一层 vertex 增删 -> file 增删的关系问题，
+         * 先用挂在点上面，简单的方法实现，后期再考虑解耦
+         */
+        this.file2NodeMap = new Map();
+        this.elementsLogic = {};
+        // 错误日志收集
+        this.diagnosticManager = undefined;
+        this.embeddedTSEmitter = undefined;
+        // 需要执行修改的文件
+        this.changeStackList = [];
+        /// #if process.env.BUILD_TARGET === 'node'
+        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
+            this.worker = new worker_threads_1.Worker('/ts-worker.js');
+        /// #endif
+        this.diagnosticManager = new diagnostic_1.DiagnosticManager();
+        this.messager = new Messager_1["default"]({
+            protocol: 'ts-worker',
+            sender: 'ide',
+            context: this,
+            getReceiver: function () { return _this.worker; },
+            getSender: function () { return _this.worker; },
+            handleMessage: function (_a) {
+                var data = _a.data;
+                return __awaiter(_this, void 0, void 0, function () {
+                    var records;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                if (!(data && data.event === 'publishDiagnostics')) return [3 /*break*/, 2];
+                                return [4 /*yield*/, this._resolveDiagnosticRecords(data.records)];
+                            case 1:
+                                records = _b.sent();
+                                this.diagnosticManager.pushAll(records);
+                                _b.label = 2;
+                            case 2: return [2 /*return*/];
+                        }
+                    });
+                });
+            }
+        });
+        // 监听所有改变操作
+        this.embeddedTSEmitter = new EventEmitter_1.EventEmitter();
+        this.embeddedTSEmitter.on('change', function ($event) {
+            // 收集到一个行为集合
+            var eventValue = $event.value;
+            eventValue.forEach(function (item) { return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    this.changeStackList.push(item.originEvent);
+                    return [2 /*return*/];
+                });
+            }); });
+            // 如果有长度开始执行状态机
+            if (_this.changeStackList.length) {
+                _this.changeFileNext();
+            }
+        });
+    }
+    NaslServer.prototype.start = function () {
+        return this.messager.requestCommand('start');
+    };
+    NaslServer.prototype.terminate = function () {
+        this.worker.terminate();
+    };
+    NaslServer.prototype.createUiTs = function (allComponent) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, code, elementsLogic;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, createUiTs_1["default"](allComponent)];
+                    case 1:
+                        _a = _b.sent(), code = _a.code, elementsLogic = _a.elementsLogic;
+                        // 放入生產的uits文件
+                        return [4 /*yield*/, this.addFile({
+                                file: 'nasl.ui.definition.ts',
+                                fileContent: code
+                            })];
+                    case 2:
+                        // 放入生產的uits文件
+                        _b.sent();
+                        Object.keys(naslStdlibMap_1["default"]).forEach(function (libFileName) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.addFile({
+                                            file: '/' + libFileName,
+                                            fileContent: naslStdlibMap_1["default"][libFileName]
+                                        })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        this.elementsLogic = elementsLogic;
+                        // 全部文件加载完毕开始初始化
+                        return [4 /*yield*/, this.getDiagnosticRecordsAndPushAll()];
+                    case 3:
+                        // 全部文件加载完毕开始初始化
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.contentToFile = function (module, results) {
+        var _this = this;
+        var _a, _b;
+        module.structures.forEach(function (structure) {
+            try {
+                var result = structure.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                structure.sourceMap = result.sourceMap;
+                _this.file2NodeMap.set(result.filePath, structure);
+            }
+            catch (err) {
+            }
+        });
+        (_a = module.frontendVariables) === null || _a === void 0 ? void 0 : _a.forEach(function (frontendVariable) {
+            try {
+                var result = frontendVariable.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                frontendVariable.sourceMap = result.sourceMap;
+                _this.file2NodeMap.set(result.filePath, frontendVariable);
+            }
+            catch (err) {
+                console.log(err);
+            }
+        });
+        (_b = module.dataSources) === null || _b === void 0 ? void 0 : _b.forEach(function (dataSource) {
+            // 本身dataSource也要生成一个文件用于改名
+            try {
+                var result = dataSource.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                dataSource.sourceMap = result.sourceMap;
+                _this.file2NodeMap.set(result.filePath, dataSource);
+            }
+            catch (err) {
+            }
+            dataSource.entities.forEach(function (entity) {
+                try {
+                    var result = entity.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    entity.sourceMap = result.sourceMap;
+                    _this.file2NodeMap.set(result.filePath, entity);
+                }
+                catch (err) {
+                }
+            });
+        });
+        module.interfaces.forEach(function (_interface) {
+            try {
+                var result = _interface.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                _interface.sourceMap = result.sourceMap;
+                _this.file2NodeMap.set(result.filePath, _interface);
+            }
+            catch (err) {
+            }
+        });
+        module.enums.forEach(function (_enum) {
+            try {
+                var result = _enum.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                _enum.sourceMap = result.sourceMap;
+                _this.file2NodeMap.set(result.filePath, _enum);
+            }
+            catch (err) {
+            }
+        });
+        module.logics.forEach(function (logic) {
+            try {
+                if (!(logic instanceof concepts_1.Logic))
+                    return;
+                var result = logic.toEmbeddedTSFile();
+                results.push(result);
+                logic.sourceMap = result.sourceMap;
+                _this.file2NodeMap.set(result.filePath, logic);
+            }
+            catch (err) {
+            }
+        });
+        // view的生成
+        if (!config_1.config.closeViews) {
+            this.view2TSFile(module.views, results);
+        }
+        module.processes.forEach(function (process) {
+            try {
+                var result = process.toEmbeddedTSFile();
+                results.push(result);
+                process.sourceMap = result.sourceMap;
+                _this.file2NodeMap.set(result.filePath, process);
+            }
+            catch (err) {
+            }
+        });
+        if (module instanceof concepts_1.App) {
+            module.roles.forEach(function (role) {
+                try {
+                    var result = role.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    role.sourceMap = result.sourceMap;
+                    _this.file2NodeMap.set(result.filePath, role);
+                }
+                catch (err) {
+                }
+            });
+        }
+    };
+    NaslServer.prototype.view2TSFile = function (viewsChildren, results) {
+        var _this = this;
+        // 如果有子页面
+        if (viewsChildren && viewsChildren.length) {
+            viewsChildren.forEach(function (view) {
+                try {
+                    var result = view.toEmbeddedTSFile();
+                    results.push(result);
+                    view.sourceMap = result.sourceMap;
+                    _this.file2NodeMap.set(result.filePath, view);
+                    if (view.children.length) {
+                        _this.view2TSFile(view.children, results);
+                    }
+                }
+                catch (err) {
+                }
+            });
+        }
+    };
+    NaslServer.prototype.openApp = function (app) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, files;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        results = [];
+                        try {
+                            // app的创建内容
+                            this.contentToFile(app, results);
+                            // 其他模块的创建内容
+                            app.dependencies.forEach(function (item) { return _this.contentToFile(item, results); });
+                            app.interfaceDependencies.forEach(function (item) { return _this.contentToFile(item, results); });
+                            app.componentDependencies.forEach(function (item) { return _this.contentToFile(item, results); });
+                        }
+                        catch (err) {
+                            console.log(err);
+                        }
+                        files = results.map(function (result) { return ({
+                            file: result.filePath,
+                            fileContent: result.code
+                        }); });
+                        return [4 /*yield*/, this.writeFiles(files)];
+                    case 1:
+                        _a.sent();
+                        this._debugInFileStorage(app, files);
+                        // 修改名称回调
+                        common_1.registerCommand('tsRename.change', function (value, callback) {
+                            callback(value);
+                        });
+                        // 删除回调
+                        common_1.registerCommand('tsDelete.change', function (callback) {
+                            callback();
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.refreshApp = function (app) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // 清除所有问题
+                        this.diagnosticManager.clear();
+                        return [4 /*yield*/, this.deleteDirectoryFiles({ directoryName: '/embedded' })];
+                    case 1:
+                        _a.sent();
+                        // 清楚check count的数量
+                        return [4 /*yield*/, this.messager.requestCommand('_clearTimeout')];
+                    case 2:
+                        // 清楚check count的数量
+                        _a.sent();
+                        // 重新加载app下内容
+                        return [4 /*yield*/, this.openApp(app)];
+                    case 3:
+                        // 重新加载app下内容
+                        _a.sent();
+                        // 重新check一遍所有内容
+                        return [4 /*yield*/, this.getDiagnosticRecordsAndPushAll()];
+                    case 4:
+                        // 重新check一遍所有内容
+                        _a.sent();
+                        // 重新补一遍标注
+                        return [4 /*yield*/, this.createdNaslAnnotatedJSON(app)];
+                    case 5:
+                        // 重新补一遍标注
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 初始化之前添加文件
+     */
+    NaslServer.prototype.addFile = function (file) {
+        return this.messager.requestCommand('addFile', file);
+    };
+    /**
+     * 只新增文件
+     * @param {*} files
+     */
+    NaslServer.prototype.writeFiles = function (files) {
+        return this.messager.requestCommand('writeFiles', files);
+    };
+    /**
+     * 新增、修改
+     * 删除文件 文件用修改内容为空模拟，防止报错
+     * @param {*} args
+     */
+    NaslServer.prototype.updateFiles = function (args) {
+        return this.messager.requestCommand('updateFiles', args);
+    };
+    /**
+     * 清除一个目录下的所有文件
+     */
+    NaslServer.prototype.deleteDirectoryFiles = function (args) {
+        return this.messager.requestCommand('deleteDirectoryFiles', args);
+    };
+    NaslServer.prototype._debugInFileStorage = function (node, openFiles) {
+        return __awaiter(this, void 0, void 0, function () {
+            var app, e_1, e_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        app = node;
+                        if (node.concept !== 'App') {
+                            app = node.rootNode || node.app;
+                        }
+                        if (!globalThis.window) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, Promise.all(openFiles.map(function (file) { return __awaiter(_this, void 0, void 0, function () {
+                                var res;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, storage_1["default"].post('/api/App/debugEmbedded?id=' + app.id, file)];
+                                        case 1:
+                                            res = _a.sent();
+                                            return [2 /*return*/, res.data];
+                                    }
+                                });
+                            }); }))];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        console.error(e_1);
+                        return [3 /*break*/, 4];
+                    case 4:
+                        if (!globalThis.process) return [3 /*break*/, 8];
+                        _a.label = 5;
+                    case 5:
+                        _a.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, Promise.all(openFiles.map(function (file) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2 /*return*/, fs.outputFile(path.join(__dirname, '../debug/apps', app.id, file.file), file.fileContent)];
+                            }); }); }))];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        e_2 = _a.sent();
+                        console.error(e_2);
+                        return [3 /*break*/, 8];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.open = function () {
+        return this.messager.requestCommand('open');
+    };
+    NaslServer.prototype.updateOpen = function (args) {
+        return this.messager.requestCommand('updateOpen', args);
+    };
+    NaslServer.prototype.fileReferences = function (filePath) {
+        return this.messager.requestCommand('fileReferences', filePath);
+    };
+    NaslServer.prototype.references = function (args) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.messager.requestCommand('references', args)];
+                    case 1: return [2 /*return*/, (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.response];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.getValueSelectCompletion = function (node, value, noFilterList) {
+        var _a = this.getCurrentSource(node), currentSource = _a.currentSource, fileNode = _a.fileNode;
+        // console.log(currentSource, fileNode);
+        if (currentSource && fileNode) {
+            return this._getValueSelectCompletion({
+                file: fileNode.getEmbeddedFilePath(),
+                range: {
+                    line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                    offset: translator_1.lsp2tspNumber(currentSource.range.start.character)
+                },
+                value: value,
+                noFilterList: noFilterList
+            });
+        }
+        else {
+            console.log('没找到节点', node, currentSource, fileNode);
+        }
+    };
+    NaslServer.prototype._getValueSelectCompletion = function (args) {
+        return this.messager.requestCommand('getValueSelectCompletion', args);
+    };
+    /**
+     * 获取 Convert 的可选类型
+     * @param node 传入当前已经选择的变量
+     * @returns 可以选择的类型数组
+     */
+    NaslServer.prototype.getConvertTypeInfo = function (node) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var callFunction, _b, currentSource, fileNode, quickInfo, displayString, typeList, res_1, err_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(node && node instanceof concepts_1.BaseNode)) return [3 /*break*/, 5];
+                        callFunction = node.parentNode.parentNode;
+                        _b = this.getCurrentSource(callFunction), currentSource = _b.currentSource, fileNode = _b.fileNode;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this._getTypeQuickinfo({
+                                file: fileNode.getEmbeddedFilePath(),
+                                line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                                offset: translator_1.lsp2tspNumber(currentSource.range.start.character) + "nasl.util.C".length
+                            })];
+                    case 2:
+                        quickInfo = _c.sent();
+                        if (quickInfo.responseRequired) {
+                            displayString = ((_a = quickInfo === null || quickInfo === void 0 ? void 0 : quickInfo.response) === null || _a === void 0 ? void 0 : _a.displayString) || '';
+                            typeList = getDisplayString2Type(displayString);
+                            res_1 = [];
+                            typeList.forEach(function (type) {
+                                var typeAnnotation = coreTypeList_1.primitiveTypeList.find(function (typeAnnotation) { return typeAnnotation.typeName === type; });
+                                if (typeAnnotation) {
+                                    res_1.push(typeAnnotation);
+                                }
+                                else if (type === 'unknown' || type === 'never') {
+                                    return null;
+                                }
+                            });
+                            if (!res_1.length) {
+                                return [2 /*return*/, []];
+                            }
+                            else {
+                                return [2 /*return*/, [{ title: '基础类型', children: res_1 }]];
+                            }
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _c.sent();
+                        console.log(err_1);
+                        // 如果有异常就先放开全部可选，兜底逻辑
+                        return [2 /*return*/, []];
+                    case 4: return [3 /*break*/, 6];
+                    case 5: 
+                    // 字符串 和 inter
+                    return [2 /*return*/, [{ title: '基础类型', children: [coreTypeList_1.primitiveTypeList[4]] }]];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 获取表单的dataschema类型
+     * @param node 当前表单节点
+     * @param allType 是不是需要全部类型 默认不要
+     * @returns 全部类型的str 或者 最后一个.后的内容
+     */
+    NaslServer.prototype.getDataSchemaType = function (node, allType) {
+        var _a;
+        if (allType === void 0) { allType = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _b, currentSource, fileNode, quickInfo, displayString, flag, types, typeStr, str, strs, type;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(node instanceof concepts_1.ViewElement))
+                            return [2 /*return*/];
+                        _b = this.getCurrentSource(node), currentSource = _b.currentSource, fileNode = _b.fileNode;
+                        return [4 /*yield*/, this._getTypeQuickinfo({
+                                file: fileNode.getEmbeddedFilePath(),
+                                line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                                offset: translator_1.lsp2tspNumber(currentSource.range.start.character) + "new nasl.ui.".length
+                            })];
+                    case 1:
+                        quickInfo = _c.sent();
+                        if (quickInfo.responseRequired) {
+                            displayString = ((_a = quickInfo === null || quickInfo === void 0 ? void 0 : quickInfo.response) === null || _a === void 0 ? void 0 : _a.displayString) || '';
+                            flag = displayString.includes('<') && displayString.includes('>');
+                            types = /\<([^()]+)\>/g.exec(displayString);
+                            typeStr = types && types[1];
+                            if (flag) {
+                                // 自定义结构的展示
+                                if (typeStr.includes('__name: "AStructure_')) {
+                                    return [2 /*return*/, typeStr.replaceAll(' ', '')
+                                            .replaceAll('\n', '')
+                                            .replace(/__name:"AStructure_\w{8}";/g, '')
+                                            .replace(/dataSources.([^.]+).entities.([^;]+)/g, function ($1, $2, $3) { return ($3 + "(" + $2 + ")"); })];
+                                }
+                                else if (typeStr.startsWith('{') && typeStr.endsWith('}')) {
+                                    /**
+                                     *  {
+                                            text: nasl.core.String;
+                                            value: nasl.core.String;
+                                        }
+                                     */
+                                    return [2 /*return*/, typeStr.replaceAll(' ', '')
+                                            .replaceAll('\n', '')
+                                            .replaceAll('nasl.core.', '')];
+                                }
+                                str = '';
+                                // 取出T的值
+                                typeStr = formatTsUtils_1.getPlatformType(typeStr);
+                                // 如果要全量的内容
+                                if (allType) {
+                                    return [2 /*return*/, typeStr];
+                                }
+                                // 取出剩下的剩下的类型的最后一项
+                                if (/\<([^()]+)\>/g.exec(typeStr)) {
+                                    str = typeStr;
+                                }
+                                else if (typeStr.includes('.')) {
+                                    strs = typeStr.split('.');
+                                    type = strs[strs.length - 1];
+                                    str = type;
+                                }
+                                else {
+                                    str = typeStr;
+                                }
+                                str = str === 'any' || str === 'unknown' || str === 'never' ? '' : str;
+                                return [2 /*return*/, str];
+                            }
+                        }
+                        return [2 /*return*/, ''];
+                }
+            });
+        });
+    };
+    /**
+     * ts的 quickInfo方法，查询指定位置的详情
+     * @param args 文件信息数组
+     * @returns 查询到的
+     */
+    NaslServer.prototype._getTypeQuickinfo = function (args) {
+        return this.messager.requestCommand('quickInfo', args);
+    };
+    NaslServer.prototype._getQuickInfoFull = function (args) {
+        return this.messager.requestCommand('quickInfoFull', args);
+    };
+    /**
+     * 获取nasl节点的 指定位置的详情
+     * 而且可以返回正确类型
+     * @param args 文件信息数组
+     * @returns 查询到的
+     */
+    NaslServer.prototype.getNaslNodeQuickInfoFull = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._getQuickInfoFull(args)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    NaslServer.prototype._getTypeFull = function (args) {
+        return this.messager.requestCommand('typeFull', args);
+    };
+    NaslServer.prototype._getTypeBatch = function (args) {
+        return this.messager.requestCommand('typeBatch', args);
+    };
+    NaslServer.prototype.getNaslNodeTypeFull = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._getTypeFull(args)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.getNaslNodeTypeBatch = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._getTypeBatch(args)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /**
+     * 获取已经选中的内容的 下一级的内容
+     * @param node 已经选中的内容
+     * @param noFilterList 不过滤的key 的数据
+     * @returns 可以选择的数据数组
+     */
+    NaslServer.prototype.getSelectNextCompletion = function (node, noFilterList) {
+        var _a = this.getCurrentSource(node), currentSource = _a.currentSource, fileNode = _a.fileNode;
+        // console.log(currentSource, fileNode);
+        if (currentSource && fileNode) {
+            return this._getSelectNextCompletion({
+                file: fileNode.getEmbeddedFilePath(),
+                range: {
+                    line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                    offset: translator_1.lsp2tspNumber(currentSource.range.start.character)
+                },
+                noFilterList: noFilterList
+            });
+        }
+        else {
+            console.log('没找到节点', currentSource, fileNode);
+        }
+    };
+    NaslServer.prototype._getSelectNextCompletion = function (args) {
+        return this.messager.requestCommand('getSelectNextCompletion', args);
+    };
+    /**
+     * 获取诊断信息
+     * @param fileNames 多个文件名
+     * @returns 诊断结果
+     */
+    NaslServer.prototype.getDiagnosticRecords = function (fileNames) {
+        return __awaiter(this, void 0, Promise, function () {
+            var records, diagnosticRecords;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.messager.requestCommand('getDiagnosticRecords', fileNames)];
+                    case 1:
+                        records = (_a.sent());
+                        return [4 /*yield*/, this._resolveDiagnosticRecords(records)];
+                    case 2:
+                        diagnosticRecords = _a.sent();
+                        return [2 /*return*/, diagnosticRecords];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.getDiagnosticRecordsAndPushAll = function (fileNames) {
+        return __awaiter(this, void 0, void 0, function () {
+            var records;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getDiagnosticRecords(fileNames)];
+                    case 1:
+                        records = _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 处理诊断结果
+     * @param records 结果
+     * @returns 过滤或者转换后的诊断结果
+     */
+    NaslServer.prototype._resolveDiagnosticRecords = function (records) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!records.length) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.IncrementalAnnotationJSON(records)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        records.forEach(function (record) {
+                            var _a, _b;
+                            var node = record.node;
+                            if (!node)
+                                return;
+                            // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
+                            var oldRecord = _this.diagnosticManager.getRecord(record.id);
+                            oldRecord === null || oldRecord === void 0 ? void 0 : oldRecord.semanticDiagnostics.forEach(function (item) {
+                                if (item.node) {
+                                    item.node.tsErrorDetail = undefined;
+                                    // 如果logic中有报错就把标识置为true
+                                    if (item.node.logic) {
+                                        item.node.logic.haveError = false;
+                                    }
+                                }
+                            });
+                            // 清空一些状态
+                            oldRecord === null || oldRecord === void 0 ? void 0 : oldRecord.suggestionDiagnostics.forEach(function (item) {
+                                if (item.node) {
+                                    item.node.tsErrorDetail = undefined;
+                                    if (item.node && item.node instanceof concepts_1.Logic) {
+                                        item.node.isSmpty = false;
+                                    }
+                                }
+                            });
+                            // 语义诊断
+                            if (isChangeInterface) {
+                                _this.existStructureFix(record.semanticDiagnostics, node, _this);
+                            }
+                            // 单独处理 oql 语义错误提示
+                            if (record.node instanceof concepts_1.Logic) {
+                                record === null || record === void 0 ? void 0 : record.syntaxDiagnostics.forEach(function (item) {
+                                    var minRange = _this._findMinRange(item, record.node);
+                                    if (minRange.node instanceof concepts_1.OqlQueryComponent) {
+                                        if (item.text === 'Invalid character.') {
+                                            record.semanticDiagnostics.push(item);
+                                        }
+                                    }
+                                });
+                            }
+                            record.semanticDiagnostics = record.semanticDiagnostics
+                                .map(function (diag) { return _this._resolveDiagnostic(diag, node, record); })
+                                .filter(function (diag) { return !!diag; });
+                            (_a = record.semanticDiagnostics).push.apply(_a, _this._attachDiagnostics(node));
+                            // 建议诊断
+                            // 实体下的建议不用展示，因为都是平台自己写的逻辑
+                            // 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.`));
+                            // }
+                            record.suggestionDiagnostics = record.suggestionDiagnostics
+                                .filter(function (item) { return ["'__LogicEmpty' is declared but its value is never read.", "'__destinationEmpty__' is declared but its value is never read."].includes(item.text); })
+                                .map(function (diag) { return _this._resolveDiagnostic(diag, node, record); })
+                                .filter(function (diag) { return !!diag; });
+                            (_b = record.suggestionDiagnostics).push.apply(_b, _this._attachSuggestionDiagnostics(node));
+                        });
+                        return [2 /*return*/, records];
+                }
+            });
+        });
+    };
+    /**
+     * 额外的建议诊断
+     * @param fileNode 文件级别的节点
+     * @returns 诊断结果
+     */
+    NaslServer.prototype._attachSuggestionDiagnostics = function (fileNode) {
+        var _this = this;
+        var diagnostics = [];
+        if (fileNode instanceof concepts_1.Logic || fileNode instanceof concepts_1.View) {
+            // 判断逻辑是否已经删除
+            if (fileNode instanceof concepts_1.Logic && fileNode.parentNode instanceof concepts_1.App && !fileNode.parentNode.logics.includes(fileNode))
+                return diagnostics;
+            // 判断页面是否已经删除
+            var removed = false;
+            var curNode = fileNode;
+            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
+            while (curNode instanceof concepts_1.View && !removed) {
+                if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
+                    || curNode.parentNode instanceof concepts_1.App && !curNode.parentNode.views.includes(curNode)) {
+                    removed = true;
+                }
+                curNode = curNode.parentNode;
+            }
+            if (removed)
+                return diagnostics;
+            fileNode === null || fileNode === void 0 ? void 0 : fileNode.sourceMap.forEach(function (value, node) { return __awaiter(_this, void 0, void 0, function () {
+                var _a, cases_1, expression_1, typeAnnotationMap_1, maxTypeAnnotationInfo_1, maxTypeAnnotation_1, sortedTypeKey, _b, typeAnnotation, cases_2;
+                var _this = this;
+                return __generator(this, function (_c) {
+                    if (node instanceof concepts_1.Match) {
+                        _a = node || {}, cases_1 = _a.cases, expression_1 = _a.expression;
+                        typeAnnotationMap_1 = {};
+                        maxTypeAnnotationInfo_1 = {
+                            typeAnnotation: null,
+                            count: 0
+                        };
+                        if (Array.isArray(cases_1)) {
+                            cases_1.forEach(function (caseItem, index) { return __awaiter(_this, void 0, void 0, function () {
+                                var isDisabled, enumerableItems, currTypeAnnotation, _a, typeKind, typeNamespace, typeName, typeArguments, nameArr, typeNode, enums, children, map_1, enumerableKeys, typeAnnotation, sortedTypeKey, typeAnnotationInfo, count;
+                                var _b, _c;
+                                return __generator(this, function (_d) {
+                                    isDisabled = false;
+                                    // 是最后一项
+                                    if (index === cases_1.length - 1) {
+                                        enumerableItems = [];
+                                        currTypeAnnotation = expression_1 === null || expression_1 === void 0 ? void 0 : expression_1.__TypeAnnotation;
+                                        _a = currTypeAnnotation || {}, typeKind = _a.typeKind, typeNamespace = _a.typeNamespace, typeName = _a.typeName, typeArguments = _a.typeArguments;
+                                        if (typeKind === 'union' && Array.isArray(typeArguments)) {
+                                            enumerableItems = typeArguments.map(function (typeArg) {
+                                                var typeArgJson = typeArg;
+                                                if (typeArg instanceof concepts_1.TypeAnnotation) {
+                                                    typeArgJson = typeArg.toJSON();
+                                                }
+                                                return new concepts_1.TypeAnnotation(typeArgJson);
+                                            });
+                                        }
+                                        else if (typeKind === 'reference') {
+                                            nameArr = [typeName];
+                                            if (typeNamespace) {
+                                                nameArr.unshift(typeNamespace);
+                                            }
+                                            typeNode = ((_c = (_b = node.app) === null || _b === void 0 ? void 0 : _b.findNodeByCompleteName) === null || _c === void 0 ? void 0 : _c.call(_b, nameArr.join('.'))) || {};
+                                            if (typeNode.concept === 'Enum') {
+                                                enums = getMemberIdentifier_1.formatEnums([typeNode]);
+                                                children = ((enums === null || enums === void 0 ? void 0 : enums[0]) || {}).children;
+                                                if (Array.isArray(children)) {
+                                                    enumerableItems = children.map(function (child) { return child === null || child === void 0 ? void 0 : child.expression; });
+                                                }
+                                            }
+                                        }
+                                        else if (typeKind === 'primitive' && typeNamespace === 'nasl.core' && typeName === 'Boolean') {
+                                            enumerableItems = [
+                                                new concepts_1.BooleanLiteral({
+                                                    value: 'true'
+                                                }),
+                                                new concepts_1.BooleanLiteral({
+                                                    value: 'false'
+                                                }),
+                                            ];
+                                        }
+                                        if (Array.isArray(enumerableItems) && enumerableItems.length) {
+                                            map_1 = {};
+                                            cases_1.forEach(function (caseItem) {
+                                                var patterns = (caseItem || {}).patterns;
+                                                if (Array.isArray(patterns)) {
+                                                    patterns.forEach(function (pattern) {
+                                                        if (pattern instanceof concepts_1.TypeAnnotation) {
+                                                            var patternTypeKey = pattern.typeKey;
+                                                            map_1[patternTypeKey] = true;
+                                                        }
+                                                        else if (pattern instanceof concepts_1.MemberExpression || pattern instanceof concepts_1.BooleanLiteral) {
+                                                            var patternValue = pattern.getValue();
+                                                            map_1[patternValue] = true;
+                                                        }
+                                                    });
+                                                }
+                                            });
+                                            enumerableKeys = Object.keys(map_1);
+                                            if (enumerableKeys.length === enumerableItems.length) {
+                                                isDisabled = true;
+                                            }
+                                        }
+                                    }
+                                    if (!isDisabled) {
+                                        typeAnnotation = caseItem.__TypeAnnotation;
+                                        // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                                        if (typeAnnotation) {
+                                            sortedTypeKey = typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.sortedTypeKey;
+                                            if (!typeAnnotationMap_1[sortedTypeKey]) {
+                                                typeAnnotationMap_1[sortedTypeKey] = {
+                                                    typeAnnotation: typeAnnotation,
+                                                    cases: [],
+                                                    count: 0
+                                                };
+                                            }
+                                            typeAnnotationInfo = typeAnnotationMap_1[sortedTypeKey];
+                                            typeAnnotationInfo.cases.push(caseItem);
+                                            typeAnnotationInfo.count++;
+                                            count = typeAnnotationInfo.count;
+                                            if (maxTypeAnnotationInfo_1.count < count) {
+                                                maxTypeAnnotationInfo_1 = {
+                                                    typeAnnotation: typeAnnotation,
+                                                    count: count
+                                                };
+                                            }
+                                            return [2 /*return*/, typeAnnotation];
+                                        }
+                                    }
+                                    return [2 /*return*/];
+                                });
+                            }); });
+                        }
+                        maxTypeAnnotation_1 = maxTypeAnnotationInfo_1.typeAnnotation;
+                        for (sortedTypeKey in typeAnnotationMap_1) {
+                            _b = typeAnnotationMap_1[sortedTypeKey], typeAnnotation = _b.typeAnnotation, cases_2 = _b.cases;
+                            if ((maxTypeAnnotation_1 === null || maxTypeAnnotation_1 === void 0 ? void 0 : maxTypeAnnotation_1.sortedTypeKey) !== (typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.sortedTypeKey)) {
+                                if (Array.isArray(cases_2)) {
+                                    cases_2.forEach(function (caseItem) {
+                                        var body = (caseItem || {}).body;
+                                        var diagnostic = {
+                                            node: caseItem,
+                                            severity: 'warning',
+                                            message: '分支类型不一致'
+                                        };
+                                        if (Array.isArray(body) && body.length) {
+                                            var lastExpression = body[body.length - 1];
+                                            diagnostic.node = lastExpression;
+                                            diagnostic.message = (lastExpression === null || lastExpression === void 0 ? void 0 : lastExpression.toUI()) + "\u671F\u671B\u7684\u7C7B\u578B\u662F" + (maxTypeAnnotation_1 === null || maxTypeAnnotation_1 === void 0 ? void 0 : maxTypeAnnotation_1.headTitle);
+                                            lastExpression.tsErrorDetail = diagnostic;
+                                            diagnostics.push(diagnostic);
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    return [2 /*return*/];
+                });
+            }); });
+        }
+        return diagnostics;
+    };
+    /**
+     * 额外的诊断
+     * @param fileNode 文件级别的节点
+     * @returns 诊断结果
+     */
+    NaslServer.prototype._attachDiagnostics = function (fileNode) {
+        var _this = this;
+        var _a;
+        var diagnostics = [];
+        if (fileNode instanceof concepts_1.View) {
+            // 判断页面是否已经删除
+            var removed = false;
+            var curNode = fileNode;
+            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
+            while (curNode instanceof concepts_1.View && !removed) {
+                if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
+                    || curNode.parentNode instanceof concepts_1.App && !curNode.parentNode.views.includes(curNode)) {
+                    removed = true;
+                }
+                curNode = curNode.parentNode;
+            }
+            if (removed)
+                return diagnostics;
+            fileNode.traverseChildren(function (node) {
+                if (node instanceof concepts_1.ViewElement && node.view === fileNode) {
+                    if (node.tag) {
+                        node.bindAttrs.forEach(function (bindAttr) {
+                            if ((bindAttr.model || bindAttr.sync) && bindAttr.expression) {
+                                var bindExpression = bindAttr.expression;
+                                var diagnostic = void 0;
+                                if (bindExpression.concept !== 'Identifier' && bindExpression.concept !== 'MemberExpression') {
+                                    diagnostic = {
+                                        node: bindAttr,
+                                        severity: 'error',
+                                        message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。'
+                                    };
+                                }
+                                else {
+                                    if (bindExpression.isEnum()) {
+                                        diagnostic = {
+                                            node: bindAttr,
+                                            severity: 'error',
+                                            message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。'
+                                        };
+                                    }
+                                }
+                                if (diagnostic) {
+                                    bindAttr.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                }
+                            }
+                        });
+                    }
+                }
+                else if ((node instanceof concepts_1.Variable || node instanceof concepts_1.Return) && node.view === fileNode) {
+                    if (!node.typeAnnotation && !node.__TypeAnnotation) {
+                        var nodeTypeName_1 = node.concept === 'Return' ? '输出参数' : '局部变量';
+                        var msg_1;
+                        fileNode.traverseChildren(function (nodeIn) {
+                            var _a, _b, _c, _d, _e, _f, _g, _h;
+                            if (nodeIn && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && ((_a = nodeIn.left) === null || _a === void 0 ? void 0 : _a.name)))) {
+                                // 子页面内部逻辑过滤
+                                if (nodeIn.view !== fileNode)
+                                    return;
+                                // 跟变量无关的赋值过滤
+                                var jsCode_1 = nodeIn.toJS();
+                                if (!jsCode_1.includes(node.name + " = "))
+                                    return;
+                                // 逻辑内局部变量、输出参数、输入参数过滤
+                                if (((_b = nodeIn.logic) === null || _b === void 0 ? void 0 : _b.variables.find(function (lVar) { return jsCode_1.includes(lVar.name + " = "); })) || ((_c = nodeIn.logic) === null || _c === void 0 ? void 0 : _c.returns.find(function (lRet) { return jsCode_1.includes(lRet.name + " = "); }))
+                                    || ((_d = nodeIn.logic) === null || _d === void 0 ? void 0 : _d.params.find(function (lPar) { return jsCode_1.includes(lPar.name + " = "); }))
+                                    || ((_e = nodeIn.logic) === null || _e === void 0 ? void 0 : _e.virtualParams.find(function (vParam) { return jsCode_1.includes(vParam.name + " = "); })))
+                                    return;
+                                if (node instanceof concepts_1.Variable
+                                    && node.parentNode instanceof concepts_1.View
+                                    && (((_f = nodeIn.logic) === null || _f === void 0 ? void 0 : _f.params.find(function (param) { return jsCode_1.includes(param.name); })) || ((_g = nodeIn.logic) === null || _g === void 0 ? void 0 : _g.virtualParams.find(function (vParam) { return jsCode_1.includes(vParam.name); }))
+                                        || ((_h = nodeIn.logic) === null || _h === void 0 ? void 0 : _h.variables.find(function (variable) { return jsCode_1.includes(variable.name); })))) {
+                                    // 直接赋值 logic 内局部变量、输入参数直接提示系统无法推断类型
+                                    if (!nodeIn.tsErrorDetail) {
+                                        var diagnostic_2 = {
+                                            node: nodeIn,
+                                            severity: 'error',
+                                            message: "\u9875\u9762" + nodeTypeName_1 + " " + node.name + " \u8D4B\u503C\u9875\u9762\u903B\u8F91\u5185\u5C40\u90E8\u53D8\u91CF\u6216\u8F93\u5165\u53C2\u6570\u65F6\uFF0C\u7CFB\u7EDF\u65E0\u6CD5\u63A8\u5BFC\u7C7B\u578B\u3002"
+                                        };
+                                        nodeIn.tsErrorDetail = diagnostic_2;
+                                        diagnostics.push(diagnostic_2);
+                                    }
+                                    msg_1 = '系统无法推断类型。';
+                                }
+                                else {
+                                    if (!nodeIn.tsErrorDetail) {
+                                        var diagnostic_3 = {
+                                            node: nodeIn,
+                                            severity: 'error',
+                                            message: nodeIn.label + "\u5DE6\u8FB9 " + node.name + " \u672A\u8BBE\u7F6E\u7C7B\u578B\uFF0C\u53F3\u8FB9\u5FC5\u987B\u4E3A\u6709\u8FD4\u56DE\u503C\u7684\u5185\u5BB9\u3002"
+                                        };
+                                        nodeIn.tsErrorDetail = diagnostic_3;
+                                        diagnostics.push(diagnostic_3);
+                                    }
+                                    msg_1 = '必须赋值有返回值的内容。';
+                                }
+                            }
+                        });
+                        if (!msg_1)
+                            msg_1 = '未设置类型或未赋值，直接赋值系统会自动推断类型。';
+                        var diagnostic = {
+                            node: node,
+                            severity: 'error',
+                            message: nodeTypeName_1 + " " + node.name + " " + msg_1
+                        };
+                        node.tsErrorDetail = diagnostic;
+                        diagnostics.push(diagnostic);
+                    }
+                }
+                else {
+                    _this.checkNodeError(node, diagnostics);
+                }
+            });
+        }
+        if (fileNode instanceof concepts_1.DataSource) {
+            var dataSourceGroup = (_a = fileNode.rootNode.configuration) === null || _a === void 0 ? void 0 : _a.getGroup('dataSource');
+            if (dataSourceGroup) {
+                var property_1 = dataSourceGroup.getProperty(fileNode.name);
+                if (property_1 && property_1.values) {
+                    property_1.values.forEach(function (propertyValue) {
+                        if (!propertyValue.value && fileNode.name !== 'defaultDS') {
+                            var diagnostic = {
+                                node: fileNode,
+                                severity: 'error',
+                                message: "\u6570\u636E\u6E90\u914D\u7F6E\uFF1A\u6570\u636E\u6E90" + property_1.name + (propertyValue.env === 'dev' ? '开发环境' : '生产环境') + "\u672A\u914D\u7F6E\u6570\u636E\u4FE1\u606F",
+                                // 保留原来的内容方便查询一些问题
+                                originalDiagnostic: {
+                                    fileName: '',
+                                    start: null,
+                                    end: null,
+                                    category: 'error',
+                                    text: "Data Source is not config"
+                                }
+                            };
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
+            }
+        }
+        if (fileNode instanceof concepts_1.Logic) {
+            // 判断逻辑是否已经删除
+            if (fileNode.parentNode instanceof concepts_1.App && !fileNode.parentNode.logics.includes(fileNode))
+                return diagnostics;
+            fileNode === null || fileNode === void 0 ? void 0 : fileNode.sourceMap.forEach(function (value, node) { return __awaiter(_this, void 0, void 0, function () {
+                var diagnostic, nodeTypeName, used_1, msg, diagnostic;
+                return __generator(this, function (_a) {
+                    // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
+                    if ((node instanceof concepts_1.OqlQueryComponent || node instanceof concepts_1.SqlQueryComponent) && node.getTypeBanError()) {
+                        diagnostic = {
+                            node: node,
+                            severity: 'error',
+                            message: 'SQL查询：返回类型内部,不支持复杂类型。'
+                        };
+                        node.tsErrorDetail = diagnostic;
+                        diagnostics.push(diagnostic);
+                    }
+                    if (node instanceof concepts_1.Return || node instanceof concepts_1.Variable) {
+                        if (!node.typeAnnotation && !node.__TypeAnnotation) {
+                            nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+                            used_1 = false;
+                            fileNode === null || fileNode === void 0 ? void 0 : fileNode.sourceMap.forEach(function (valueIn, nodeIn) {
+                                var _a;
+                                if (!used_1 && nodeIn
+                                    && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && ((_a = nodeIn.left) === null || _a === void 0 ? void 0 : _a.name)))
+                                    && nodeIn.toJS().includes(node.name + " = ")) {
+                                    used_1 = true;
+                                    if (!nodeIn.tsErrorDetail) {
+                                        var diagnostic_4 = {
+                                            node: nodeIn,
+                                            severity: 'error',
+                                            message: nodeIn.label + "\u5DE6\u8FB9 " + node.name + " \u672A\u8BBE\u7F6E\u7C7B\u578B\uFF0C\u53F3\u8FB9\u5FC5\u987B\u4E3A\u6709\u8FD4\u56DE\u503C\u7684\u5185\u5BB9\u3002"
+                                        };
+                                        nodeIn.tsErrorDetail = diagnostic_4;
+                                        diagnostics.push(diagnostic_4);
+                                    }
+                                }
+                            });
+                            msg = used_1 ? '必须赋值有返回值的内容。' : '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
+                            diagnostic = {
+                                node: node,
+                                severity: 'error',
+                                message: nodeTypeName + " " + node.name + " " + msg
+                            };
+                            node.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        }
+                        else {
+                            node.tsErrorDetail = undefined;
+                        }
+                    }
+                    this.checkNodeError(node, diagnostics);
+                    return [2 /*return*/];
+                });
+            }); });
+        }
+        return diagnostics;
+    };
+    NaslServer.prototype.checkNodeError = function (node, diagnostics) {
+        var _a, _b, _c, _d, _e;
+        if (!node)
+            return;
+        // 如果节点是match的看看节点里是不是有重复的
+        if (node instanceof concepts_1.Match) {
+            var typeMap_1 = {};
+            if ((_a = node.expression) === null || _a === void 0 ? void 0 : _a.__TypeAnnotation) {
+                var _f = node.expression.__TypeAnnotation, typeName = _f.typeName, typeNamespace = _f.typeNamespace;
+                if (typeName === 'Union' || typeName === 'Boolean' || (typeNamespace === null || typeNamespace === void 0 ? void 0 : typeNamespace.endsWith('enums'))) {
+                    node.cases.forEach(function (item) {
+                        if (Array.isArray(item.patterns)) {
+                            item.patterns.forEach(function (pattern) {
+                                var _a, _b;
+                                if (pattern instanceof concepts_1.TypeAnnotation) {
+                                    if (typeMap_1[pattern.sortedTypeKey]) {
+                                        typeMap_1[pattern.sortedTypeKey].push(pattern);
+                                    }
+                                    else {
+                                        typeMap_1[pattern.sortedTypeKey] = [pattern];
+                                    }
+                                }
+                                else if (pattern instanceof concepts_1.MemberExpression) {
+                                    if (pattern.completeName && ((_b = (_a = pattern.object) === null || _a === void 0 ? void 0 : _a.namespace) === null || _b === void 0 ? void 0 : _b.endsWith('enums'))) {
+                                        var onlyKey = pattern.completeName;
+                                        if (typeMap_1[onlyKey]) {
+                                            typeMap_1[onlyKey].push(pattern);
+                                        }
+                                        else {
+                                            typeMap_1[onlyKey] = [pattern];
+                                        }
+                                    }
+                                }
+                                else if (pattern instanceof concepts_1.BooleanLiteral) {
+                                    var onlyKey = pattern.concept + pattern.value;
+                                    if (typeMap_1[onlyKey]) {
+                                        typeMap_1[onlyKey].push(pattern);
+                                    }
+                                    else {
+                                        typeMap_1[onlyKey] = [pattern];
+                                    }
+                                }
+                            });
+                        }
+                    });
+                }
+            }
+            Object.keys(typeMap_1).forEach(function (item) {
+                if (typeMap_1[item].length > 1) {
+                    typeMap_1[item].forEach(function (nodeItem) {
+                        var diagnostic = {
+                            node: nodeItem,
+                            severity: 'error',
+                            message: '匹配：重复添加类型',
+                            titleTip: '重复添加此项'
+                        };
+                        nodeItem.tsErrorDetail = diagnostic;
+                        diagnostics.push(diagnostic);
+                    });
+                }
+            });
+        }
+        // 如果节点是match的patterns 里的
+        if ((node === null || node === void 0 ? void 0 : node.parentKey) === 'patterns' && node.parentNode instanceof concepts_1.MatchCase) {
+            var matchNode = node.getAncestor('Match');
+            var matchExpressionType = (_c = (_b = matchNode) === null || _b === void 0 ? void 0 : _b.expression) === null || _c === void 0 ? void 0 : _c.__TypeAnnotation;
+            // 判断union类型是不是重复
+            // 先使用ts原始的报错，这个先注释掉
+            if (node instanceof concepts_1.TypeAnnotation && (matchExpressionType === null || matchExpressionType === void 0 ? void 0 : matchExpressionType.typeKind) === 'union') {
+                var haveType = matchExpressionType === null || matchExpressionType === void 0 ? void 0 : matchExpressionType.typeArguments.find(function (item) { return item.sortedTypeKey === node.sortedTypeKey; });
+                if (!haveType) {
+                    var diagnostic = {
+                        node: node,
+                        severity: 'error',
+                        message: '匹配：选择类型不存在',
+                        titleTip: '该类型已被删除'
+                    };
+                    node.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                }
+            }
+            if (node.tsErrorDetail) {
+                if ((_d = matchExpressionType === null || matchExpressionType === void 0 ? void 0 : matchExpressionType.typeNamespace) === null || _d === void 0 ? void 0 : _d.includes('enums')) {
+                    node.tsErrorDetail.titleTip = '该枚举值已被删除';
+                }
+                else if (!node.tsErrorDetail.titleTip) {
+                    node.tsErrorDetail.titleTip = '该值已被删除';
+                }
+            }
+        }
+        // 如果forEach 中的each的内容是union类型就要提示报错
+        if ((node === null || node === void 0 ? void 0 : node.parentKey) === 'each' && ((_e = node === null || node === void 0 ? void 0 : node.__TypeAnnotation) === null || _e === void 0 ? void 0 : _e.typeKind) === 'union') {
+            var diagnostic = {
+                node: node,
+                severity: 'error',
+                message: 'ForEach：参数类型不一致！传入类型：联合类型。接受类型：List类型。'
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
+    };
+    /* 接口导入查找 */
+    NaslServer.prototype.existStructureFix = function (semanticDiagnostics, node, that) {
+        var _this = this;
+        var module;
+        semanticDiagnostics.map(function (diag) {
+            var _a, _b, _c, _d;
+            var minRange = _this._findMinRange(diag, node);
+            if ((_a = diag.text) === null || _a === void 0 ? void 0 : _a.includes('has no exported member named')) {
+                if (minRange.node instanceof concepts_1.Logic) {
+                    return null;
+                }
+                var typeAnnotation = minRange.node instanceof concepts_1.TypeAnnotation ? minRange.node.upperNode.typeAnnotation : minRange.node.typeAnnotation;
+                var regNamespace = /<(\S*)>/;
+                var typeKey = (typeAnnotation.typeKey.match(regNamespace) && typeAnnotation.typeKey.match(regNamespace)[1]) || typeAnnotation.typeKey;
+                var typeKeyArr = typeKey.split('.');
+                if (typeKeyArr[0] === 'apis') {
+                    var structureName_1 = typeKeyArr[3];
+                    var moduleName_1 = typeKeyArr[1];
+                    var app = typeAnnotation.upperNode.app;
+                    if (!app) {
+                        return null;
+                    }
+                    module = (_b = app.interfaceDependencies) === null || _b === void 0 ? void 0 : _b.find(function (item) { return item.name === moduleName_1; });
+                    var existStructure = (_c = module === null || module === void 0 ? void 0 : module.structures) === null || _c === void 0 ? void 0 : _c.find(function (item) { return item.name.toUpperCase() === structureName_1.toUpperCase(); });
+                    if (!existStructure) {
+                        var realName_1 = structureName_1.replace(/\d*$/, function (m) { return String(''); });
+                        existStructure = (_d = module === null || module === void 0 ? void 0 : module.structures) === null || _d === void 0 ? void 0 : _d.find(function (item) { return item.name.toUpperCase() === realName_1.toUpperCase(); });
+                    }
+                    if (existStructure) {
+                        var editTypeAnnotation = JSON.parse(JSON.stringify(typeAnnotation).replace(new RegExp(structureName_1, 'g'), existStructure.name));
+                        actionArr.push({ target: typeAnnotation.parentNode, typeannotation: editTypeAnnotation });
+                    }
+                }
+                return null;
+            }
+            else {
+                return diag;
+            }
+        });
+        if (actionArr.length) {
+            if (timer)
+                return;
+            timer = window.setTimeout(function () {
+                var app = actionArr[0].target.app;
+                app.emit('collect:start', {
+                    actionMsg: '设置导入接口数据类型错误'
+                });
+                module.isAdd && module.setIsAdd(false);
+                actionArr.forEach(function (item) {
+                    item.target.setDataType(concepts_1.TypeAnnotation.from(item.typeannotation));
+                });
+                app.emit('collect:end');
+                actionArr = [];
+                isChangeInterface = false;
+                clearTimeout(timer);
+                timer = null;
+            }, 2000);
+        }
+    };
+    /**
+     * 单个问题的诊断处理
+     * @param diagnostic 诊断问题
+     * @param fileNode 页面节点
+     * @returns 处理后的结果
+     */
+    NaslServer.prototype._resolveDiagnostic = function (diagnostic, fileNode, record) {
+        // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
+        if (fileNode.module)
+            return;
+        var minRange = this._findMinRange(diagnostic, fileNode);
+        var tsErrorDetail = {
+            severity: diagnostic.category === 'error' ? 'error' : 'warning',
+            message: translator_2.translateDiagnosticMessage(diagnostic.text),
+            // 保留原来的内容方便查询一些问题
+            originalDiagnostic: diagnostic
+        };
+        var result;
+        if (minRange) {
+            // 节点的error要置为true
+            result = translator_2.naslNodeTranslateMessage(minRange, tsErrorDetail);
+        }
+        else {
+            // 没找到节点， 先把问题暴露出来
+            result = tsErrorDetail;
+        }
+        if (result)
+            result.id = record.filePath + (result ? JSON.stringify({ start: result.originalDiagnostic.start, end: result.originalDiagnostic.end }) : '');
+        return result;
+    };
+    /**
+     * 通过节点诊断反过来查找节点
+     * @param diagnostic 诊断信息
+     * @param fileNode 文件级别节点
+     * @returns 找到的节点
+     */
+    NaslServer.prototype._findMinRange = function (diagnostic, fileNode) {
+        var minRange;
+        var sourceMap = fileNode.sourceMap;
+        for (var _i = 0, _a = sourceMap.entries(); _i < _a.length; _i++) {
+            var _b = _a[_i], node = _b[0], item = _b[1];
+            /**
+             * 当前内容的开始行 <= 诊断开始的行 &&
+             * 当前内容的结束行 >= 诊断结束的行
+             */
+            if (translator_1.lsp2tspNumber(item.range.start.line) <= diagnostic.start.line && translator_1.lsp2tspNumber(item.range.end.line) >= diagnostic.end.line) {
+                // 如果找到某一行
+                if (translator_1.lsp2tspNumber(item.range.start.line) === diagnostic.start.line && translator_1.lsp2tspNumber(item.range.end.line) === diagnostic.end.line) {
+                    // 在行的范围但是又不在列的范围，不用给默认值，给了反而不对，
+                    // 需要在列的范围内
+                    if (translator_1.lsp2tspNumber(item.range.start.character) <= diagnostic.start.offset && translator_1.lsp2tspNumber(item.range.end.character) >= diagnostic.end.offset) {
+                        // 比列更靠近 ，满足条件且长度更短
+                        // 如果先走到下面有一个默认值了就像在if for里面有个表达式
+                        // if for的内容也是包括当前的所以会重新赋值
+                        if (!minRange || item.code.length < minRange.item.code.length) {
+                            minRange = { item: item, node: node };
+                        }
+                    }
+                }
+                else {
+                    // 没有节点 或者 行差比较小比已有的小就可以
+                    // 一般出现在一大块上，多半是if for 等等没有参数
+                    if (!minRange || item.range.end.line - item.range.start.line < minRange.item.range.end.line - minRange.item.range.start.line) {
+                        minRange = { node: node, item: item };
+                    }
+                }
+            }
+        }
+        if (!minRange) {
+            if (fileNode instanceof concepts_1.View) {
+                return { node: fileNode, item: sourceMap.get(fileNode) };
+            }
+            console.log(minRange, '需要特殊看下，为什么没找到内容-------------');
+        }
+        return minRange;
+    };
+    /**
+     * 查看当前节点是不是有引用
+     * @param node 节点
+     * @returns 查找到的数组
+     */
+    NaslServer.prototype._isHaveRef = function (node) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, currentSource, fileNode, refsList, newRefs, lists, moduleName_2, item, fileNode_1, newRefs, logicNode, currentSource_1, parentRefs, viewNode, currentSource_2, code, viewIndex, viewRefs, filterViewRefs, code, prefix, prefixIndex, methodsNameIndex, methods, methodRefs_1;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.getCurrentSource(node), currentSource = _a.currentSource, fileNode = _a.fileNode;
+                        refsList = [];
+                        if (!currentSource) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.references({
+                                file: fileNode.getEmbeddedFilePath(),
+                                line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                                offset: translator_1.lsp2tspNumber(currentSource.range.start.character)
+                            })];
+                    case 1:
+                        newRefs = _b.sent();
+                        refsList = __spreadArrays(newRefs.refs);
+                        return [3 /*break*/, 4];
+                    case 2:
+                        if (!(node instanceof concepts_1.Module)) return [3 /*break*/, 4];
+                        lists = node.logics || node.structures || node.enums;
+                        moduleName_2 = fileNode.getEmbeddedFilePath();
+                        if (!lists.length) return [3 /*break*/, 4];
+                        item = lists[0];
+                        fileNode_1 = this.getCurrentSource(item).fileNode;
+                        if (!fileNode_1) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.references({
+                                file: fileNode_1.getEmbeddedFilePath(),
+                                line: 1,
+                                offset: 22
+                            })];
+                    case 3:
+                        newRefs = _b.sent();
+                        refsList = newRefs.refs.filter(function (item) { return !item.file.startsWith(moduleName_2); });
+                        // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
+                        refsList.unshift(newRefs.refs[0]);
+                        _b.label = 4;
+                    case 4:
+                        // 如果是DataSource就需要在单独，查一边来修改名字
+                        if (node instanceof concepts_1.DataSource) {
+                            // 过滤一把不需要改的信息
+                            refsList = refsList.filter(function (item) {
+                                var dataSourceFile = fileNode.getEmbeddedFilePath();
+                                var entityFilePrefix = dataSourceFile.replace('.ts', '');
+                                /**
+                                 * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
+                                 * 所以全部过滤掉了,
+                                 * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了11个函数之外的引用
+                                 * 所以底部内容是11个函数,所以这里就 用entity的行数 减去11个函数的行数,然后其余的在进行处理
+                                 * 进行过滤
+                                 */
+                                // 不要数据源下面的实体里的引用 ,保留原始的节点内容
+                                var flag = false;
+                                if (item.file.includes(entityFilePrefix)) {
+                                    var entity = _this.file2NodeMap.get(item.file);
+                                    var currentSource_3 = _this.getCurrentSource(entity).currentSource;
+                                    // 42 11个函数的总行数
+                                    if (item.end.line < currentSource_3.range.end.line - 42 && item.start.line > 1) {
+                                        flag = true;
+                                    }
+                                }
+                                // 属于实体而且需要修改和查到  ||  不是实体前缀的 || 他本身
+                                return flag || !item.file.includes(entityFilePrefix) || dataSourceFile === item.file;
+                            });
+                        }
+                        // 如果是entity就需要在单独，查一边来修改名字
+                        if (node instanceof concepts_1.Entity) {
+                            // 过滤一把不需要改的信息
+                            refsList = refsList.filter(function (item) { return fileNode.getEmbeddedFilePath() !== item.file || item.isDefinition === true; });
+                            // 不再当前文件里
+                            // 或者在当前列表但是位置小于entity的结束位置
+                        }
+                        if (node instanceof concepts_1.Return) {
+                            // 过滤一下最后出去的值
+                            refsList = refsList.filter(function (item) { return !item.lineText.includes('return '); });
+                        }
+                        if (!(node instanceof concepts_1.Param && node.parentNode instanceof concepts_1.Logic && node.parentKey !== 'virtualParams')) return [3 /*break*/, 6];
+                        logicNode = node.parentNode;
+                        currentSource_1 = this.getCurrentSource(logicNode).currentSource;
+                        return [4 /*yield*/, this.references({
+                                file: fileNode.getEmbeddedFilePath(),
+                                line: translator_1.lsp2tspNumber(currentSource_1.range.start.line),
+                                offset: translator_1.lsp2tspNumber(currentSource_1.range.start.character)
+                            })];
+                    case 5:
+                        parentRefs = _b.sent();
+                        refsList = __spreadArrays(refsList, parentRefs.refs);
+                        _b.label = 6;
+                    case 6:
+                        if (!(node instanceof concepts_1.Param && (node.parentNode instanceof concepts_1.View || node.parentNode instanceof concepts_1.Process))) return [3 /*break*/, 8];
+                        viewNode = node.parentNode;
+                        currentSource_2 = this.getCurrentSource(viewNode).currentSource;
+                        code = currentSource_2.code;
+                        viewIndex = code.indexOf(' {');
+                        return [4 /*yield*/, this.references({
+                                file: fileNode.getEmbeddedFilePath(),
+                                line: translator_1.lsp2tspNumber(currentSource_2.range.start.line),
+                                offset: translator_1.lsp2tspNumber(currentSource_2.range.start.character + viewIndex)
+                            })];
+                    case 7:
+                        viewRefs = _b.sent();
+                        filterViewRefs = [];
+                        if (node.parentNode instanceof concepts_1.View) {
+                            filterViewRefs = viewRefs.refs.filter(function (item) { return item.lineText.includes('.$destination('); });
+                        }
+                        else {
+                            // 如果是参数修改, 就需要把Process的引用查找出来
+                            filterViewRefs = viewRefs.refs.filter(function (item) { return item.lineText.includes('.launch('); });
+                        }
+                        refsList = __spreadArrays(refsList, filterViewRefs);
+                        _b.label = 8;
+                    case 8:
+                        if (!(node instanceof concepts_1.ViewElement)) return [3 /*break*/, 10];
+                        if (!currentSource) return [3 /*break*/, 10];
+                        code = currentSource.code;
+                        prefix = '__elements.';
+                        prefixIndex = code.indexOf(prefix) !== -1 ? code.indexOf(prefix) : 0;
+                        methodsNameIndex = prefixIndex + prefix.length;
+                        return [4 /*yield*/, this.references({
+                                file: fileNode.getEmbeddedFilePath(),
+                                line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                                offset: translator_1.lsp2tspNumber(currentSource.range.start.character + methodsNameIndex)
+                            })];
+                    case 9:
+                        methods = _b.sent();
+                        methodRefs_1 = [];
+                        methods.refs.forEach(function (item) {
+                            // 定义里的格式，在删除的时候留下来占位
+                            // 重命名的时候会过滤
+                            // 这里只过滤 __elements.button = new nasl.ui.Button<any>这种格式
+                            // 处理声明组件名可能重复的问题， 查找引用不提示
+                            var find = methodRefs_1.find(function (findItem) { return item.lineText === findItem.lineText && item.lineText.includes(': nasl.ui.'); });
+                            if (!find) {
+                                methodRefs_1.push(item);
+                            }
+                        });
+                        refsList = __spreadArrays(methodRefs_1);
+                        _b.label = 10;
+                    case 10: 
+                    // console.log(refsList, 'refsList');
+                    return [2 /*return*/, refsList];
+                }
+            });
+        });
+    };
+    /**
+     * 查找引用，并且做一些 修改前的准备工作，
+     * 有引用有的话，就返回集合
+     * @param node 当前重命名的节点
+     * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+     * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+     * @returns 找到的引用
+     */
+    NaslServer.prototype._renamePrepare = function (node, refsList, newValue) {
+        var _this = this;
+        var oldName = node === null || node === void 0 ? void 0 : node.name;
+        var result = refsList
+            .map(function (record) {
+            var fileNode = _this.file2NodeMap.get(record.file);
+            if (!fileNode)
+                return null;
+            var minRange = _this._findMinRange(record, fileNode);
+            if (minRange) {
+                // 节点上ts临时变量标识，如果有这个就不rename
+                if (minRange.node.noTsReName) {
+                    return null;
+                }
+                // 如果节点是TypeAnnotation类型,
+                // 很复杂，可能是多级嵌套结构
+                // 不一定只修改typeName
+                if (minRange.node instanceof concepts_1.TypeAnnotation) {
+                    // console.log(record);
+                    // 如果是fake的逻辑，内部的重命名都不需要修改
+                    // if ((minRange.node?.parentNode as any).logic && (minRange.node?.parentNode as any).logic?.fake) {
+                    //     return null;
+                    // }
+                    minRange.setTypeMethods = 'setTypeName';
+                }
+                // 如果节点是logic修改引发calllogic修改
+                if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Logic) {
+                    minRange.setTypeMethods = 'setCalleeName';
+                }
+                if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.ViewElement) {
+                    minRange.setTypeMethods = 'setCalleeNamespace';
+                    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)) {
+                    // 匹配到的内容，当前这一行的内容；
+                    // 因为要用下面的点位信息
+                    /**
+                     * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
+                     * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
+                     * 但是505 要改名为 666 ，要存的是666
+                     * 'app.views.Student.views.404.views.666.views.update'
+                     * 1.取到转后的
+                     * 2.在匹配到的内容中取转后的namespace的位置
+                     * 3.然后把namespace中的 $替换成 ''
+                     *
+                     */
+                    var tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                    // 先看下标位置
+                    var lineText = record.lineText;
+                    var index = lineText.indexOf(tsCalleeNamespace);
+                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                    var start = record.start.offset - index - 1;
+                    var end = record.end.offset - index - 1;
+                    // 新的完整的value
+                    var newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                    newTsNameSpace = newTsNameSpace.replace(/.\$/g, '.');
+                    minRange.setTypeMethods = 'setCalleeNamespace';
+                    minRange.newValue = newTsNameSpace;
+                }
+                // 如果参数修改影响了 callLogic
+                if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
+                    return null;
+                    // 逻辑第几个位置发生修改，对应的calllogic对应位置的内容要进行修改
+                    // minRange.setTypeMethods = 'setArgumentName';
+                    // const nodeArguments = minRange.node.arguments;
+                    // minRange.newValue = [...nodeArguments];
+                    // const LogicNode = node.parentNode;
+                    // const paramIndex = (LogicNode as Logic).params.findIndex((param) => param === node);
+                    // console.log(node, nodeArguments);
+                    // if (paramIndex !== -1) {
+                    //     minRange.setTypeMethods = 'setArgumentName';
+                    //     minRange.newValue = {
+                    //         argument: nodeArguments[paramIndex],
+                    //         newKeyword: newValue,
+                    //     };
+                    // } else {
+                    //     return null;
+                    // }
+                }
+                // 如果节点是Identifier表达式
+                if (minRange.node instanceof concepts_1.Identifier) {
+                    // 匹配到的内容，当前这一行的内容；
+                    // 因为要用下面的点位信息
+                    var name = minRange.node.name;
+                    // 如果name不改，那就是要改命名空间
+                    if (newValue === name) {
+                        var namespace = minRange.node.namespace;
+                        // 先看下标位置
+                        var lineText = record.lineText;
+                        var index = lineText.indexOf(namespace);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        var start = record.start.offset - index - 1;
+                        var end = record.end.offset - index - 1;
+                        // 新的完整的value
+                        var newTextValue = namespace.substring(0, start) + newValue + namespace.substring(end, namespace.length);
+                        minRange.setTypeMethods = 'setNamespace';
+                        minRange.newValue = newTextValue;
+                    }
+                }
+                // 如果是枚举修改，枚举的值刚好在Identifier 中选了 就修改值
+                if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Enum) {
+                    minRange.newValue = newValue;
+                    minRange.setTypeMethods = 'setName';
+                }
+                // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
+                if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Logic) {
+                    minRange.newValue = newValue;
+                    minRange.setTypeMethods = 'setName';
+                }
+                // 如果节点是MemberExpression表达式
+                if (minRange.node instanceof concepts_1.MemberExpression) {
+                    // 枚举key的特殊性，因为它不是原来的key+value形式的
+                    // 是加了中括号啥的，所以直接赋值新值
+                    if (node instanceof concepts_1.EnumItem) {
+                        var newTextValue = node.parentNode.name + '.' + newValue;
+                        minRange.newValue = newTextValue;
+                    }
+                    else {
+                        // 匹配到的内容，当前这一行的内容；
+                        // 因为要用下面的点位信息
+                        var a = record.lineText;
+                        // 之前的内容
+                        var oldValue = minRange.node.getValue();
+                        var index = a.indexOf(oldValue);
+                        var start = record.start.offset - index - 1;
+                        var end = record.end.offset - index - 1;
+                        var newTextValue = oldValue.substring(0, start) + newValue + oldValue.substring(end, oldValue.length);
+                        // MemberExpression可能改的是多层中的某一个
+                        // 倒序， 对比看是哪里发生了修改
+                        // 比较特殊就把新匹配到的值返回内部自己看要改那个地方的值
+                        minRange.newValue = newTextValue;
+                    }
+                }
+                if (node instanceof concepts_1.Entity) {
+                    // 如果是修改实体，引发节点依赖实体发生改变的
+                    if (minRange.node instanceof concepts_1.EntityProperty) {
+                        minRange.setTypeMethods = 'setRelationEntity';
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryFieldExpression || minRange.node instanceof concepts_1.QueryGroupByExpression) {
+                        minRange.setTypeMethods = 'setEntityAsName';
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) {
+                        minRange.setTypeMethods = 'setEntityName';
+                    }
+                    else if (minRange.node instanceof concepts_1.BindAttribute && minRange.node.name === 'url') {
+                        // 如果是查找到 上传地址的链接引用
+                        var newName = newValue.replace(/[A-Z]/g, function (item) { return '-' + item.toLowerCase(); });
+                        newName = newName[0] === '-' ? newName.slice(1) : newName;
+                        var newTextValue = node.parentNode.name === 'defaultDS' ? "/api/" + newName + "/import" : "/api/" + node.parentNode.name + "/" + newName + "/import";
+                        minRange.setTypeMethods = 'setUrlValue';
+                        minRange.newValue = newTextValue;
+                    }
+                }
+                // 如果是修改实体属性，要同步实体属性
+                if (minRange.node instanceof concepts_1.EntityProperty && node instanceof concepts_1.EntityProperty && record.lineText.includes('@nasl.annotation.EntityRelation')) {
+                    minRange.setTypeMethods = 'setRelationProperty';
+                }
+                // 如果要修改索引的
+                if (minRange.node instanceof concepts_1.EntityIndex) {
+                    var newPropertyNameList = __spreadArrays(minRange.node.propertyNames);
+                    var findIndex = newPropertyNameList.findIndex(function (item) { return item === oldName; });
+                    if (findIndex !== -1) {
+                        // 修改数组的值
+                        newPropertyNameList.splice(findIndex, 1, newValue);
+                        minRange.setTypeMethods = 'setPropertyNameList';
+                        minRange.newValue = newPropertyNameList;
+                    }
+                }
+                // 如果是跳转逻辑的修改
+                // 跳转逻辑本身页面 都需要带 View前缀
+                if (node instanceof concepts_1.View && minRange.node instanceof concepts_1.Destination) {
+                    /**
+                     * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
+                     * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
+                     * 但是505 要改名为 666 ，要存的是666
+                     * 'app.views.Student.views.404.views.666.views.update'
+                     * 1.取到转后的
+                     * 2.在匹配到的内容中取转后的namespace的位置
+                     * 3.然后把namespace中的 $替换成 ''
+                     *
+                     */
+                    var tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                    var tsName = minRange.node.tsName;
+                    var oldValue = tsCalleeNamespace + '.' + tsName;
+                    // 先看下标位置
+                    var lineText = record.lineText;
+                    var index = lineText.indexOf(oldValue);
+                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                    var start = record.start.offset - index - 1;
+                    var end = record.end.offset - index - 1;
+                    if (start > tsCalleeNamespace.length) {
+                        minRange.setTypeMethods = 'setViewName';
+                        minRange.newValue = newValue;
+                    }
+                    else {
+                        // 新的完整的value
+                        var newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                        minRange.setTypeMethods = 'setViewNamespace';
+                        newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                        minRange.newValue = newTsNameSpace;
+                    }
+                }
+                // 如果是事件修改
+                // 如果是view也需要加前缀
+                // logic 和 views名称修改 可能会触发bindEvent修改
+                if (minRange.node instanceof concepts_1.BindEvent) {
+                    // 页面逻辑直接赋值就可以, 因为是相对路径
+                    if (node instanceof concepts_1.ViewElement) {
+                        minRange.setTypeMethods = 'setCalleeNamespace';
+                        minRange.newValue = 'elements.' + newValue + '.logics';
+                    }
+                    else {
+                        /**
+                         * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
+                         * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
+                         * 但是505 要改名为 666 ，要存的是666
+                         * 'app.views.Student.views.404.views.666.views.update'
+                         * 1.取到转后的
+                         * 2.在匹配到的内容中取转后的namespace的位置
+                         * 3.然后把namespace中的 $替换成 ''
+                         */
+                        var tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                        var oldValue = tsCalleeNamespace;
+                        // 先看下标位置
+                        var lineText = record.lineText;
+                        var index = lineText.indexOf(oldValue);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        var start = record.start.offset - index - 1;
+                        var end = record.end.offset - index - 1;
+                        // 新的完整的value
+                        if (start > tsCalleeNamespace.length) {
+                            minRange.setTypeMethods = 'setCalleeName';
+                            minRange.newValue = newValue;
+                        }
+                        else {
+                            // 新的完整的value
+                            var newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                            minRange.setTypeMethods = 'setCalleeNamespace';
+                            newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                            minRange.newValue = newTsNameSpace;
+                        }
+                    }
+                }
+                if (minRange.node instanceof concepts_1.Destination && node instanceof concepts_1.Param) {
+                    // 因为view是key value 绑定所以需要重新赋值
+                    if (node.parentNode instanceof concepts_1.View) {
+                        var nodeArguments = minRange.node.arguments;
+                        var findArgument = nodeArguments.find(function (item) { return node.name === item.keyword; });
+                        if (findArgument) {
+                            minRange.setTypeMethods = 'setArgumentsKeyWord';
+                            minRange.newValue = {
+                                findArgument: findArgument,
+                                newKeyword: newValue
+                            };
+                        }
+                    }
+                    else {
+                        // 如果是修改param查找到Destination就不操作
+                        return null;
+                    }
+                }
+                if (minRange.node instanceof concepts_1.Interface && node instanceof concepts_1.Logic) {
+                    minRange.setTypeMethods = 'setOriginLogicName';
+                }
+                // 如果是role改名,就需要查到变更后的数组
+                if ((minRange.node instanceof concepts_1.View || minRange.node instanceof concepts_1.ViewElement) && node instanceof concepts_1.Role) {
+                    // oldName旧的节点存的值
+                    // newValue用户输入值
+                    // node.bindRoles 存的
+                    minRange.setTypeMethods = 'setBindRoles';
+                    var str = minRange.node.bindRoles.toString().replace(oldName, newValue);
+                    var newBindRoles = str.split(',');
+                    minRange.newValue = newBindRoles;
+                }
+                // 修改枚举值找到了EntityProperty就说明给了默认值
+                if (node instanceof concepts_1.EnumItem) {
+                    if (minRange.node instanceof concepts_1.EntityProperty || minRange.node instanceof concepts_1.StructureProperty) {
+                        minRange.setTypeMethods = 'setDefaultValue';
+                    }
+                    if (minRange.node instanceof concepts_1.Param || minRange.node instanceof concepts_1.Variable || minRange.node instanceof concepts_1.Return) {
+                        minRange.setTypeMethods = 'setDefaultValue';
+                    }
+                }
+                // 如果修改的是dataSource属性
+                if (node instanceof concepts_1.DataSource) {
+                    var setTypeNamespace = function (typeNamespace, record) {
+                        // 先看下标位置
+                        var lineText = record.lineText;
+                        var index = lineText.indexOf(typeNamespace);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        var start = record.start.offset - index - 1;
+                        var end = record.end.offset - index - 1;
+                        // 新的完整的value
+                        var newTextValue = typeNamespace.substring(0, start) + newValue + typeNamespace.substring(end, typeNamespace.length);
+                        minRange.newValue = newTextValue;
+                        return newTextValue;
+                    };
+                    if (minRange.node instanceof concepts_1.TypeAnnotation) {
+                        minRange.setTypeMethods = 'setTypeNamespace';
+                        var newValue_1 = setTypeNamespace(minRange.node.typeNamespace, record);
+                        minRange.newValue = newValue_1;
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) {
+                        minRange.setTypeMethods = 'setEntityNamespace';
+                        var newValue_2 = setTypeNamespace(minRange.node.entityNamespace, record);
+                        minRange.newValue = newValue_2;
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryFieldExpression) {
+                        return null;
+                    }
+                    else if (minRange.node instanceof concepts_1.CallLogic) {
+                        minRange.setTypeMethods = 'setCalleeNamespace';
+                        var newValue_3 = setTypeNamespace(minRange.node.calleeNamespace, record);
+                        minRange.newValue = newValue_3;
+                    }
+                    else if (minRange.node instanceof concepts_1.EntityProperty) {
+                        minRange.setTypeMethods = 'setRelationNamespace';
+                        var newValue_4 = setTypeNamespace(minRange.node.relationNamespace, record);
+                        minRange.newValue = newValue_4;
+                    }
+                    else if (minRange.node instanceof concepts_1.SqlQueryComponent || minRange.node instanceof concepts_1.OqlQueryComponent) {
+                        minRange.setTypeMethods = 'renameDataSource';
+                    }
+                }
+                if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.EntityProperty) {
+                    minRange.setTypeMethods = 'setPropertyName';
+                }
+                if (minRange.node instanceof concepts_1.QueryGroupByExpression && node instanceof concepts_1.EntityProperty) {
+                    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)) {
+                    return null;
+                }
+                if (minRange.node instanceof concepts_1.Destination && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
+                    return null;
+                }
+                if (minRange.node instanceof concepts_1.Assignee && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
+                    return null;
+                }
+                // 枚举修改枚举名，比较特殊
+                if (minRange.node instanceof concepts_1.EnumItem && node instanceof concepts_1.Enum) {
+                    // 什么都不做，用来跳过修改
+                    return null;
+                }
+                // params修改 查找bindevent不需要修改
+                if (minRange.node instanceof concepts_1.BindEvent && node instanceof concepts_1.Param) {
+                    return null;
+                }
+                /**
+                 * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
+                 * 流程改名不触发Logic改名
+                 * 如果是修改param查找到logic就不操作
+                 * 除非想在内部修改别的内容所以暂时屏蔽掉
+                 */
+                if (minRange.node instanceof concepts_1.Logic && node !== minRange.node) {
+                    return null;
+                }
+                if (node instanceof concepts_1.Param && minRange.node instanceof concepts_1.Interface) {
+                    return null;
+                }
+                // 如果是被影响的是页面
+                if (minRange.node instanceof concepts_1.View) {
+                    if (node instanceof concepts_1.View) {
+                        // 如果是子页面修改
+                        // 父页面引起子页面改名，就可以不改了，自动同步
+                        if (minRange.node !== node) {
+                            return null;
+                        }
+                    }
+                    else if (!(node instanceof concepts_1.Role)) {
+                        /**
+                         * 无论是逻辑还是实体中的key，修改都不应该触发
+                         * 理论上除了组件自己改名可以触发
+                         * 下面这里 不属于Role是因为上面代码里有， 不符合 规范 的role改名存在所以先保留
+                         */
+                        return null;
+                    }
+                }
+                // 如果是被影响的是页面元素
+                if (minRange.node instanceof concepts_1.ViewElement) {
+                    if (node instanceof concepts_1.ViewElement) {
+                        if (minRange.node !== node) {
+                            return null;
+                        }
+                    }
+                    else if (!(node instanceof concepts_1.Role)) {
+                        /**
+                         * 无论是逻辑还是实体中的key，修改都不应该触发
+                         * 理论上除了组件自己改名可以触发
+                         * 下面这里 不属于Role是因为上面代码里有， 不符合 规范 的role改名存在所以先保留
+                         */
+                        return null;
+                    }
+                }
+            }
+            else {
+                console.log('没找到节点需要排查', record, fileNode.sourceMap);
+            }
+            return minRange;
+        })
+            // 过滤掉不需要操作的
+            .filter(function (item) { return !!item; });
+        return result;
+    };
+    // 增加参数的副作用，用于更新logic和view
+    NaslServer.prototype._addParamsEffect = function (refsList, node) {
+        var _this = this;
+        var parantNode = node === null || node === void 0 ? void 0 : node.parentNode;
+        refsList.forEach(function (record) {
+            var fileNode = _this.file2NodeMap.get(record.file);
+            if (!fileNode)
+                return null;
+            var minRange = _this._findMinRange(record, fileNode);
+            if (minRange) {
+                // 如果找到节点是callLogic就去更新
+                if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
+                    minRange.node.setCalleeArgName(parantNode);
+                }
+                // 如果节点参数增加页面也要更新
+                if (minRange.node instanceof concepts_1.Destination && node instanceof concepts_1.Param) {
+                    minRange.node.setViewArgument(parantNode);
+                }
+            }
+        });
+    };
+    NaslServer.prototype._addParamsPrepare = function (node, refsList, needAdd) {
+        if (needAdd) {
+            var App_1 = node === null || node === void 0 ? void 0 : node.rootNode;
+            var parantNode = node === null || node === void 0 ? void 0 : node.parentNode;
+            // 收集修改
+            App_1.emit('collect:start', {
+                actionMsg: '增加逻辑参数'
+            });
+            var index = node.getIndexOfParent();
+            node.create({
+                index: index,
+                parentNode: parantNode,
+                parentKey: node.parentKey
+            });
+            this._addParamsEffect(refsList, node);
+            // 结束修改 ，批量操作
+            App_1.emit('collect:end');
+            return node;
+        }
+        this._addParamsEffect(refsList, node);
+        return node;
+    };
+    // 查找引用
+    NaslServer.prototype.findReferences = function (node) {
+        return __awaiter(this, void 0, void 0, function () {
+            var refsList, result, resMap, nodeMap;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._isHaveRef(node)];
+                    case 1:
+                        refsList = _a.sent();
+                        // 如果查找引用查到自己里面的引用不展示
+                        refsList = refsList.filter(function (item) {
+                            // 自己引用自己的过滤掉
+                            // 删除的时候过滤一把组件删除提示
+                            // 展示组件自己屏蔽掉
+                            return !item.isDefinition && !item.lineText.includes(' = new nasl.ui.');
+                        });
+                        result = new Map();
+                        resMap = new Map();
+                        nodeMap = new Map();
+                        try {
+                            refsList.forEach(function (record) {
+                                var fileNode = _this.file2NodeMap.get(record.file);
+                                if (!fileNode)
+                                    return;
+                                var minRange = _this._findMinRange(record, fileNode);
+                                // 过滤一把不需要改的信息
+                                if (minRange) {
+                                    // 拼装树
+                                    _this._getTreeMap(minRange, fileNode, resMap, nodeMap);
+                                }
+                            });
+                            if (resMap.size > 0) {
+                                result = this.handleTreeMap(resMap);
+                            }
+                        }
+                        catch (err) {
+                            console.log(err);
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    // 获取节点的上层渲染
+    NaslServer.prototype._getTreeMap = function (minRange, fileNode, resMap, nodeMap) {
+        var minRangeNode = minRange.node;
+        var currentNode = minRangeNode;
+        var parantNode = currentNode;
+        // 顺序队列
+        var queue = [];
+        // 先插入自己,如果没有在往上找,
+        // 一直到file节点的父级
+        while (!(parantNode instanceof concepts_1.App)) {
+            // 找到上一级 在map对象中构造出他的子集
+            currentNode = parantNode;
+            parantNode = parantNode.parentNode;
+            // 如果第一次就塞入子集和父节点，以后就只用父节点了
+            // 因为部分节点没有name，先过滤掉
+            // if (currentNode.name) {
+            // }
+            // 排除一些不放入集合的节点
+            var isNeedPush = true;
+            // 如果不是ViewElement 或者 Assignment ， 或者如果是的话， 排除l-root
+            if (currentNode instanceof concepts_1.ViewElement && currentNode.tag === 'l-root')
+                isNeedPush = false;
+            else if (currentNode instanceof concepts_1.Argument)
+                isNeedPush = false;
+            else if (currentNode instanceof concepts_1.Assignment)
+                isNeedPush = false;
+            else if (currentNode instanceof concepts_1.TypeAnnotation)
+                isNeedPush = false;
+            else if (currentNode instanceof concepts_1.CallQueryComponent)
+                isNeedPush = false;
+            else if (currentNode instanceof concepts_1.QueryFromExpression)
+                isNeedPush = false;
+            else if (currentNode instanceof concepts_1.TypeAnnotation)
+                isNeedPush = false;
+            // 需要放到数组中
+            if (isNeedPush) {
+                // 名称
+                // 赋值图标
+                var icon = '';
+                if (currentNode instanceof concepts_1.ViewElement)
+                    icon = 'element';
+                else if (currentNode instanceof concepts_1.BindAttribute)
+                    icon = 'attr';
+                else if (currentNode instanceof concepts_1.Destination)
+                    icon = 'logicNode';
+                else if (currentNode instanceof concepts_1.CallLogic) {
+                    icon = 'interface';
+                }
+                // 相同节点使用一个引用
+                if (nodeMap.get(currentNode)) {
+                    queue.unshift(nodeMap.get(currentNode));
+                }
+                else {
+                    var quoteNode = { node: currentNode, expanded: true, icon: icon };
+                    nodeMap.set(currentNode, quoteNode);
+                    queue.unshift(quoteNode);
+                }
+            }
+        }
+        // 一个logic 或者 view可能会有多个顺序队列
+        if (resMap.get(currentNode)) {
+            // 是否展示两个内容全等，但是两个queue的node可能不一样，但是只需要展示一个
+            resMap.get(currentNode).push(queue);
+        }
+        else {
+            resMap.set(currentNode, [queue]);
+        }
+    };
+    NaslServer.prototype.handleTreeMap = function (resMap) {
+        var _this = this;
+        var treeNodeMap = new Map();
+        resMap.forEach(function (value, fileNode) {
+            // 循环处理tree的queue
+            var treeObj = _this.handleTreeQueue(value);
+            treeNodeMap.set(fileNode, treeObj);
+        });
+        return treeNodeMap;
+    };
+    /**
+     * 处理tree的队列，把相同节点进行合并
+     * 这里把当前二维数组进行一个整合
+     * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
+     * @returns 最后要使用到的节点和对应的子集
+     */
+    NaslServer.prototype.handleTreeQueue = function (queueLists) {
+        var map = new Map();
+        var root = null;
+        if (!queueLists.length)
+            return;
+        for (var _i = 0, queueLists_1 = queueLists; _i < queueLists_1.length; _i++) {
+            var queueList = queueLists_1[_i];
+            var preNode = null;
+            var _loop_1 = function (queueItem) {
+                if (!map.get(queueItem)) {
+                    map.set(queueItem, []);
+                }
+                if (preNode) {
+                    var find = map.get(preNode).find(function (item) { return item === queueItem; });
+                    if (!find) {
+                        map.get(preNode).push(queueItem);
+                    }
+                }
+                else {
+                    root = queueItem;
+                }
+                preNode = queueItem;
+            };
+            for (var _a = 0, queueList_1 = queueList; _a < queueList_1.length; _a++) {
+                var queueItem = queueList_1[_a];
+                _loop_1(queueItem);
+            }
+        }
+        var children = this._recursionCreateResult(root, map);
+        return children;
+    };
+    /**
+     * 递归调用输出结果
+     * @param root 一个根节点
+     * @param map 当前所有节点的map对象
+     * @returns 当前节点，最后输出所有节点
+     */
+    NaslServer.prototype._recursionCreateResult = function (root, map) {
+        var _this = this;
+        var children = (map.get(root) || []).map(function (item) { return _this._recursionCreateResult(item, map); });
+        if (children && children.length) {
+            root.children = children;
+        }
+        return root;
+    };
+    /**
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
+    NaslServer.prototype.getCurrentSource = function (node) {
+        if (node instanceof concepts_1.App || node instanceof concepts_1.Theme)
+            return { fileNode: null };
+        var sourceMap = node.sourceMap;
+        var fileNode = node;
+        // 如果没有sourceMap,就继续向上找 ,或者到module结束
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是view就不要向上查找了
+        while (!sourceMap
+            && fileNode
+            && !(fileNode.parentNode instanceof concepts_1.App)
+            && !(fileNode.parentNode instanceof concepts_1.Module)
+            && !(fileNode.parentNode instanceof concepts_1.DataSource)
+            && !(fileNode instanceof concepts_1.View)) {
+            fileNode = fileNode.parentNode;
+            sourceMap = fileNode === null || fileNode === void 0 ? void 0 : fileNode.sourceMap;
+        }
+        var currentSource = sourceMap && sourceMap.get(node);
+        if (currentSource) {
+            // 这里处理一些加了注解或者需要定制位置的节点的取值
+            this.handlingCurrentSourceException(currentSource, node);
+            return { currentSource: currentSource, fileNode: fileNode };
+        }
+        return { fileNode: fileNode };
+    };
+    NaslServer.prototype.handlingCurrentSourceException = function (currentSource, node) {
+        // 如果有前面的一些注解，元素在最后一行输出的值就给最后一行
+        if (node instanceof concepts_1.EntityProperty) {
+            if (currentSource.range.start.line !== currentSource.range.end.line) {
+                currentSource.range.start = __assign(__assign({}, currentSource.range.start), { line: currentSource.range.end.line });
+            }
+        }
+    };
+    // 获取element方法的可选值
+    NaslServer.prototype.getFieldKeySelectCompletion = function (node, fieldKey) {
+        var _a = this.getCurrentSource(node), currentSource = _a.currentSource, fileNode = _a.fileNode;
+        if (currentSource && fileNode) {
+            return this._getFieldKeySelectCompletion({
+                file: fileNode.getEmbeddedFilePath(),
+                range: {
+                    line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                    offset: translator_1.lsp2tspNumber(currentSource.range.start.character)
+                },
+                getFieldKey: fieldKey
+            });
+        }
+        else {
+            console.log('没找到节点', currentSource, fileNode);
+        }
+    };
+    NaslServer.prototype._getFieldKeySelectCompletion = function (args) {
+        return this.messager.requestCommand('getFieldKeySelectCompletion', args);
+    };
+    /**
+     * 获取模块下多个CallInterface 被依赖的页面节点
+     * 查找callInterface 被依赖的页面级别的节点，要让他们重新生成一次代码，因为多个Interface重新导入，需要查找到引用的额内容
+     * 对应引用地方，需要重新生成，因为是生成方控制是不是必填的，
+     * @param oldInterfaceModule 发生修改的module，查他下面的Interface被引用的地方
+     * @returns 查找到的有引用这个内容的页面级别节点
+     */
+    NaslServer.prototype.findModulesCallInterfaceFileRef = function (oldInterfaceModule) {
+        return __awaiter(this, void 0, void 0, function () {
+            var oldInterfaces, fileNodes, i, item, refsList;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        oldInterfaces = oldInterfaceModule.interfaces;
+                        fileNodes = new Set();
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < oldInterfaces.length)) return [3 /*break*/, 4];
+                        item = oldInterfaces[i];
+                        return [4 /*yield*/, this._isHaveRef(item)];
+                    case 2:
+                        refsList = _a.sent();
+                        refsList.forEach(function (record) {
+                            if (record.isDefinition)
+                                return;
+                            var fileNode = _this.file2NodeMap.get(record.file);
+                            if (fileNode) {
+                                fileNodes.add(fileNode);
+                            }
+                        });
+                        _a.label = 3;
+                    case 3:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, __spreadArrays(fileNodes)];
+                }
+            });
+        });
+    };
+    /**
+     * 查找calllogic 被依赖的页面级别的节点，要让他们重新生成一次代码，因为logic，参数必填非必填发生修改，
+     * 对应引用地方，需要重新生成，因为是生成方控制是不是必填的，
+     * @param logic 发生修改的logic
+     * @returns 查找到的有引用这个内容的页面级别节点
+     */
+    NaslServer.prototype.findCallLogicFileRef = function (logic) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileNodes, refsList;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fileNodes = new Set();
+                        return [4 /*yield*/, this._isHaveRef(logic)];
+                    case 1:
+                        refsList = _a.sent();
+                        refsList.forEach(function (record) {
+                            if (record.isDefinition)
+                                return;
+                            var fileNode = _this.file2NodeMap.get(record.file);
+                            if (fileNode) {
+                                fileNodes.add(fileNode);
+                            }
+                        });
+                        return [2 /*return*/, __spreadArrays(fileNodes)];
+                }
+            });
+        });
+    };
+    /**获取当前节点的已知类型
+     * @param node 当前要获取类型的节点
+     * @returns 不需要去查就可以返回类型的节点
+     */
+    NaslServer.prototype.getCurrentNodeKnownTypeAnnotation = function (node) {
+        var _a;
+        if (node.concept === 'StringLiteral' || node.concept === 'BooleanLiteral' || node.concept === 'NullLiteral') {
+            var type = 'String';
+            switch (node.concept) {
+                case 'NullLiteral':
+                    type = 'Null';
+                    break;
+                case 'BooleanLiteral':
+                    type = 'Boolean';
+                    break;
+            }
+            return concepts_1.TypeAnnotation.createPrimitive(type);
+        }
+        // 这些原有类型的 比较的 返回值肯定就是布尔值，就不去调用ls
+        if (node instanceof concepts_1.BinaryExpression && (['==', '!=', '>', '<', '>=', '<='].includes(node.operator))) {
+            return concepts_1.TypeAnnotation.createPrimitive('Boolean');
+        }
+        // Convert和new都是自身携带类型的，就不进行修改
+        if (node instanceof concepts_1.CallFunction && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'Convert' || node.calleeName === 'New')) {
+            if (node.typeArguments.length) {
+                return node.typeArguments[0];
+            }
+        }
+        // Convert和new都是自身携带类型的，就不进行修改
+        if (node instanceof concepts_1.CallLogic && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'jsonDeserialize')) {
+            if (node.typeArguments.length) {
+                return node.typeArguments[0];
+            }
+        }
+        // 特殊处理param有类型错误的
+        if (node instanceof concepts_1.Param) {
+            // index在nasl foreach上有脏数据
+            if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
+                return concepts_1.TypeAnnotation.createPrimitive('Integer');
+            }
+        }
+        if (node instanceof concepts_1.CallQueryComponent || node instanceof concepts_1.SqlQueryComponent || node instanceof concepts_1.OqlQueryComponent) {
+            return node.typeAnnotation;
+        }
+        // 老数据可能typeKind 的primitive缺失
+        if (node instanceof concepts_1.NumericLiteral && node.typeAnnotation) {
+            return concepts_1.TypeAnnotation.from(__assign(__assign({}, (_a = node.typeAnnotation) === null || _a === void 0 ? void 0 : _a.toJSON()), { typeKind: 'primitive' }));
+        }
+    };
+    /**
+     * 获取传入节点的TypeAnnotation
+     * @param nodes {filePath: string, node: BaseNode, item: SourceMapItem}
+     * @returns Map<BaseNode, TypeAnnotation | { typeAnnotation: TypeAnnotation, option: any }>
+     * 普通的TypeAnnotation，额外的可能携带 option
+     * 这里会处理callloigc callinterface 和 callfuntion 的 argment的参数一起携带回去，
+     * 也就是说如果 只传入了这个也会一起返回argment的节点，所以返回map最好去get结果
+     */
+    NaslServer.prototype.getQuickInfoNodesTypeMap = function (nodes, lotFlag) {
+        return __awaiter(this, void 0, void 0, function () {
+            var args, getFromOthers, types, newQuickInfoNodes, resultMap;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        args = [];
+                        getFromOthers = new Map();
+                        types = new Map();
+                        newQuickInfoNodes = [];
+                        nodes.forEach(function (itemDetail) {
+                            var _a, _b, _c;
+                            var node = itemDetail.node, filePath = itemDetail.filePath, item = itemDetail.item;
+                            // 先按照顺序占位
+                            types.set(node, null);
+                            // 获取已知节点类型的类型
+                            var nodeTypeAnnotation = _this.getCurrentNodeKnownTypeAnnotation(node);
+                            if (nodeTypeAnnotation) {
+                                types.set(node, nodeTypeAnnotation);
+                                node.__TypeAnnotation = nodeTypeAnnotation;
+                                return;
+                            }
+                            // 要通过自己或者依赖关系拿的，二次遍历
+                            if ([
+                                'Argument',
+                                'Assignment',
+                                'MatchCase',
+                            ].includes(node.concept)) {
+                                getFromOthers.set(node, null);
+                            }
+                            if ([
+                                'Return',
+                                'Variable',
+                            ].includes(node.concept) && node.typeAnnotation) {
+                                node.__TypeAnnotation = node.typeAnnotation;
+                                return;
+                            }
+                            if (![
+                                'Identifier',
+                                'UnaryExpression',
+                                'BinaryExpression',
+                                'CallLogic',
+                                'CallFunction',
+                                'CallInterface',
+                                'MemberExpression',
+                                'Return',
+                                'Variable',
+                                'Match',
+                            ].includes(node.concept))
+                                return;
+                            // 要去ls那边获取的
+                            newQuickInfoNodes.push(itemDetail);
+                            var fileDetail = {
+                                file: filePath,
+                                line: translator_1.lsp2tspNumber(item.range.start.line),
+                                offset: translator_1.lsp2tspNumber(item.range.start.character)
+                            };
+                            if (node.concept === 'BinaryExpression'
+                                || node.concept === 'CallLogic'
+                                || node.concept === 'CallFunction'
+                                || node.concept === 'CallInterface') {
+                                // 如果没有括号 ，括号就在外面，就 -1
+                                // 有括号就找到括号的位置 然后 -1
+                                var indexOf = 0;
+                                if (item.code.indexOf('(') === -1) {
+                                    indexOf = -1;
+                                }
+                                else {
+                                    // 如果有泛型先往前找一找
+                                    if (item.code.includes('<')) {
+                                        indexOf = item.code.indexOf('<');
+                                    }
+                                    else {
+                                        indexOf = item.code.indexOf('(');
+                                    }
+                                    var subStr = item.code.substring(0, indexOf);
+                                    var codeArr = subStr === null || subStr === void 0 ? void 0 : subStr.split('.');
+                                    var lastLen = (_a = codeArr === null || codeArr === void 0 ? void 0 : codeArr[codeArr.length - 1]) === null || _a === void 0 ? void 0 : _a.length;
+                                    indexOf = subStr.length - lastLen;
+                                }
+                                fileDetail.offset = fileDetail.offset + indexOf;
+                            }
+                            else if (node.concept === 'MemberExpression' || node.concept === 'Identifier') {
+                                if (item.code.includes('.')) {
+                                    var codeArr = (_b = item.code) === null || _b === void 0 ? void 0 : _b.split('.');
+                                    var lastLen = (_c = codeArr === null || codeArr === void 0 ? void 0 : codeArr[codeArr.length - 1]) === null || _c === void 0 ? void 0 : _c.length;
+                                    // MemberExpression取最后一位当做类型
+                                    var indexOf = item.code.length - lastLen;
+                                    fileDetail.offset = fileDetail.offset + indexOf;
+                                }
+                            }
+                            else if (node.concept === 'Match') {
+                                // 去查return 后面的返回值，变成函数调用
+                                fileDetail.line = item.range.end.line - 1;
+                                var indexOf = item.code.indexOf('return __MatchExpressionFuntion');
+                                var newCode = item.code.substring(0, indexOf);
+                                newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+                                fileDetail.offset = newCode.length + 'return '.length;
+                            }
+                            args.push(fileDetail);
+                        });
+                        return [4 /*yield*/, this.getNaslNodeTypeFull(args)];
+                    case 1:
+                        resultMap = (_a.sent()).response;
+                        // console.log(resultMap);
+                        // const result = (await this.getNaslNodeQuickInfoFull(args)).response;
+                        // console.log(result);
+                        args.forEach(function (arg, index) {
+                            var _a, _b, _c, _d, _e;
+                            var file = arg.file, line = arg.line, offset = arg.offset;
+                            var item = (_c = (_b = (_a = resultMap) === null || _a === void 0 ? void 0 : _a[file]) === null || _b === void 0 ? void 0 : _b[line]) === null || _c === void 0 ? void 0 : _c[offset];
+                            //const displayString1 = resule1[index]?.displayString;
+                            // console.log('位置：', file, line, offset);
+                            // console.log('原始：', displayString);
+                            // console.log('方案2：', item?.[0]?.nodeType);
+                            var nodeTypeAnnotation = formatTsUtils_1.type2TypeAnnotation((_d = item === null || item === void 0 ? void 0 : item[0]) === null || _d === void 0 ? void 0 : _d.nodeType);
+                            // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
+                            types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
+                            newQuickInfoNodes[index].node.__TypeAnnotation = nodeTypeAnnotation;
+                            newQuickInfoNodes[index].node.__nodeType = (_e = item === null || item === void 0 ? void 0 : item[0]) === null || _e === void 0 ? void 0 : _e.nodeType;
+                            // console.log('方案1：', displayString1);
+                        });
+                        getFromOthers.forEach(function (type, node) {
+                            var _a;
+                            if (node instanceof concepts_1.Assignment) {
+                                if (!types.get(node.left)) {
+                                    types.set(node.left, types.get(node.right));
+                                    node.left.__TypeAnnotation = types.get(node.right);
+                                }
+                            }
+                            else if (node instanceof concepts_1.Argument) {
+                                // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
+                                var argType = _this.getArgumentTypeAnnotation(node, newQuickInfoNodes, types);
+                                types.set(node, argType);
+                                node.__TypeAnnotation = argType.typeAnnotation;
+                            }
+                            else if (node instanceof concepts_1.MatchCase) {
+                                // matchCase的类型
+                                // 直接从最后一项的返回值取，有就有没有就没有
+                                if ((_a = node.body) === null || _a === void 0 ? void 0 : _a.length) {
+                                    var last = node.body[node.body.length - 1];
+                                    if (last.__TypeAnnotation) {
+                                        types.set(node, last.__TypeAnnotation);
+                                        node.__TypeAnnotation = last.__TypeAnnotation;
+                                    }
+                                }
+                            }
+                        });
+                        // 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);
+                        //     }
+                        // });
+                        console.timeEnd('批量请求');
+                        return [2 /*return*/, types];
+                }
+            });
+        });
+    };
+    // 全量标注
+    NaslServer.prototype.getNaslAnnotatedJSON = function (app, releaseFlag) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nodes, typesMap, json;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // 全量标注
+                        console.time('全量标注');
+                        nodes = [];
+                        this.file2NodeMap.forEach(function (fileNode, filePath) {
+                            // 先不排除view，传递给后端的时候，去除views下的标注
+                            if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
+                                fileNode.sourceMap.forEach(function (item, node) {
+                                    nodes.push({
+                                        filePath: filePath,
+                                        node: node,
+                                        item: item
+                                    });
+                                });
+                            }
+                        });
+                        return [4 /*yield*/, this.getQuickInfoNodesTypeMap(nodes, true)];
+                    case 1:
+                        typesMap = _a.sent();
+                        // console.log(typesMap, 'typesMap')
+                        console.timeEnd('全量标注');
+                        json = app.toJSON();
+                        if (releaseFlag) {
+                            // 全量标注后对json进行一些修改，为了服务端翻译处理
+                            this.annitationToJson(typesMap, json);
+                        }
+                        return [2 /*return*/, json];
+                }
+            });
+        });
+    };
+    // 加载全量nasl节点标注
+    NaslServer.prototype.createdNaslAnnotatedJSON = function (app) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nodes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // 全量标注
+                        console.time('全量标注');
+                        nodes = [];
+                        this.file2NodeMap.forEach(function (fileNode, filePath) {
+                            // 先不排除view，传递给后端的时候，去除views下的标注
+                            if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
+                                fileNode.sourceMap.forEach(function (item, node) {
+                                    nodes.push({
+                                        filePath: filePath,
+                                        node: node,
+                                        item: item
+                                    });
+                                });
+                            }
+                        });
+                        return [4 /*yield*/, this.getQuickInfoNodesTypeMap(nodes, true)];
+                    case 1:
+                        _a.sent();
+                        console.timeEnd('全量标注');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // 增量标注
+    NaslServer.prototype.IncrementalAnnotationJSON = function (records) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nodes;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        nodes = [];
+                        records.forEach(function (record) {
+                            var fileNode = _this.file2NodeMap.get(record.filePath);
+                            if (!fileNode)
+                                return;
+                            record.id = fileNode.id;
+                            record.node = fileNode;
+                            if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
+                                fileNode.sourceMap.forEach(function (item, nodeItem) {
+                                    nodes.push({
+                                        filePath: record.filePath,
+                                        node: nodeItem,
+                                        item: item
+                                    });
+                                });
+                            }
+                        });
+                        return [4 /*yield*/, this.getQuickInfoNodesTypeMap(nodes)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.annitationToJson = function (typesMap, json) {
+        typesMap.forEach(function (value, node) {
+            var _a, _b, _c, _d;
+            // 如果节点本身有类型就不去在塞一遍了
+            // 有值而且没有类型再去设置
+            // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
+            if (value && (!node.typeAnnotation || node instanceof concepts_1.Identifier || node instanceof concepts_1.MemberExpression)) {
+                var jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                if (jsonNode) {
+                    if (node instanceof concepts_1.Argument) {
+                        jsonNode.defaultValue = value.option.defaultValue;
+                        jsonNode.typeAnnotation = (_b = (_a = value) === null || _a === void 0 ? void 0 : _a.typeAnnotation) === null || _b === void 0 ? void 0 : _b.toJSON();
+                    }
+                    else {
+                        jsonNode.typeAnnotation = (_c = value) === null || _c === void 0 ? void 0 : _c.toJSON();
+                    }
+                }
+            }
+            // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
+            if (node instanceof concepts_1.CallQueryComponent && node.ideVersion !== '2.11') {
+                var jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                jsonNode.typeAnnotation = {
+                    concept: 'TypeAnnotation',
+                    typeKind: 'anonymousStructure',
+                    typeNamespace: null,
+                    typeName: null,
+                    typeArguments: [],
+                    inferred: false,
+                    ruleMap: null,
+                    properties: [{
+                            concept: 'StructureProperty',
+                            name: 'list',
+                            label: null,
+                            description: null,
+                            typeAnnotation: {
+                                concept: 'TypeAnnotation',
+                                typeKind: 'generic',
+                                typeNamespace: 'nasl.collection',
+                                typeName: 'List',
+                                typeArguments: [jsonNode.typeAnnotation],
+                                inferred: null
+                            },
+                            required: null,
+                            defaultValue: null
+                        }, {
+                            concept: 'StructureProperty',
+                            name: 'total',
+                            label: null,
+                            description: null,
+                            typeAnnotation: {
+                                concept: 'TypeAnnotation',
+                                typeKind: 'primitive',
+                                typeNamespace: 'nasl.core',
+                                typeName: 'Integer',
+                                typeArguments: null,
+                                inferred: null
+                            },
+                            required: null,
+                            defaultValue: null
+                        }]
+                };
+            }
+            // 特殊处理param有类型错误的
+            if (node instanceof concepts_1.Param) {
+                // index在nasl foreach上有脏数据
+                if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
+                    var jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Integer').toJSON();
+                }
+            }
+            if (node instanceof concepts_1.Match) {
+                var matchExpression_1 = node.expression;
+                if (((_d = matchExpression_1 === null || matchExpression_1 === void 0 ? void 0 : matchExpression_1.__TypeAnnotation) === null || _d === void 0 ? void 0 : _d.typeKind) === 'union' && (matchExpression_1 instanceof concepts_1.Identifier || matchExpression_1 instanceof concepts_1.MemberExpression)) {
+                    var _e = matchExpression_1 === null || matchExpression_1 === void 0 ? void 0 : matchExpression_1.getCurrentSource(), currentSource_4 = _e.currentSource, fileNode = _e.fileNode;
+                    fileNode.sourceMap.forEach(function (item, itemNode) {
+                        if (itemNode.concept === matchExpression_1.concept && item.code === currentSource_4.code) {
+                            var jsonNode = jsoner.queryNodeByPath(json, itemNode.getNodePath(false));
+                            jsonNode.typeAnnotation = matchExpression_1.__TypeAnnotation;
+                        }
+                    });
+                }
+            }
+            // 特殊处理param有类型错误的
+            if (node instanceof concepts_1.Param && value) {
+                // index在nasl foreach上有脏数据
+                if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
+                    var jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                    jsonNode.typeAnnotation = value.toJSON();
+                }
+            }
+        });
+    };
+    /**
+     * 获取getArgument的参数位的类型
+     * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
+     * 获取logic的默认值和原来Arg的类型和默认值对应
+     */
+    NaslServer.prototype.getArgumentTypeAnnotation = function (node, QuickInfoNodes, types) {
+        var _a, _b, _c;
+        // 直接复用内部expression的type类型
+        if (node.parentNode instanceof concepts_1.CallLogic && node.parentNode.calleeNamespace.includes('entities') && node.parentNode.calleeNamespace.includes('logics') && node.parentNode.calleeName === 'delete') {
+            var nodeType = (_a = node.parentNode) === null || _a === void 0 ? void 0 : _a.__nodeType;
+            if (nodeType && Array.isArray(nodeType.fnParams)) {
+                var index_1 = node.parentNode.arguments.indexOf(node);
+                var type = (_b = nodeType.fnParams[index_1]) === null || _b === void 0 ? void 0 : _b.typeInfo;
+                var nodeTypeAnnotation = formatTsUtils_1.type2TypeAnnotation(type);
+                if (nodeTypeAnnotation) {
+                    return {
+                        typeAnnotation: nodeTypeAnnotation,
+                        option: {}
+                    };
+                }
+            }
+        }
+        // 获取返回值结果里找到父级的callLogic || CallInterface的类型填充进去Argument
+        var App = node.app;
+        var parent = (node.parentNode);
+        // 如果nasl包下的 ，很多声明都含有T啥的先用自己内部的
+        if (!parent.calleeNamespace || parent.calleeNamespace.startsWith('nasl')) {
+            if (types.get(node.expression)) {
+                return {
+                    typeAnnotation: types.get(node.expression),
+                    option: {}
+                };
+            }
+        }
+        // 用户自己声明的用用户的
+        var callObj = App.findNodeByCompleteName(parent.calleeNamespace + '.' + parent.calleeName);
+        var index = parent.arguments.indexOf(node);
+        var param = ((_c = callObj === null || callObj === void 0 ? void 0 : callObj.params) === null || _c === void 0 ? void 0 : _c[index]) || {};
+        // 取出参数的类型
+        // 设置类型
+        return {
+            typeAnnotation: param.typeAnnotation,
+            // 设置默认值
+            option: { defaultValue: param.defaultValue }
+        };
+    };
+    NaslServer.prototype.getCurrentTypeAnnotation = function (node) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (node.__TypeAnnotation) {
+                    return [2 /*return*/, node.__TypeAnnotation];
+                }
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var myTimer = setTimeout(function () {
+                            console.log(node, '没有获取到类型');
+                            clearTimeout(myTimer);
+                            clearInterval(mySetInterval);
+                            resolve(node.__TypeAnnotation);
+                        }, 600);
+                        var mySetInterval = setInterval(function () {
+                            if (node.__TypeAnnotation) {
+                                resolve(node.__TypeAnnotation);
+                                clearInterval(mySetInterval);
+                                clearTimeout(myTimer);
+                            }
+                        }, 50);
+                    })];
+            });
+        });
+    };
+    // 获取节点标注，去动态查
+    NaslServer.prototype.getBaseNodesTypeMap = function (nodes) {
+        return __awaiter(this, void 0, void 0, function () {
+            var args, typesMap;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        args = nodes.map(function (item) {
+                            var _a = item.getCurrentSource(), currentSource = _a.currentSource, fileNode = _a.fileNode;
+                            return {
+                                filePath: fileNode.getEmbeddedFilePath(),
+                                node: item,
+                                item: currentSource
+                            };
+                        });
+                        return [4 /*yield*/, this.getQuickInfoNodesTypeMap(args)];
+                    case 1:
+                        typesMap = _a.sent();
+                        return [2 /*return*/, typesMap];
+                }
+            });
+        });
+    };
+    NaslServer.prototype._getTypeStrFull = function (args) {
+        return this.messager.requestCommand('typeStrFull', args);
+    };
+    NaslServer.prototype.getNaslNodeTypeStrFull = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._getTypeStrFull(args)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /**
+     * 处理删除节点
+     * @param fileNode 当前删除节点的文件级别节点
+     * @param targetNode 当前操作的节点
+     * @param result toTs生成的内容
+     */
+    NaslServer.prototype.handleDelete = function (fileNode, targetNode, result) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var filePath, outputFiles, newRefs;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        filePath = fileNode.getEmbeddedFilePath();
+                        outputFiles = [];
+                        return [4 /*yield*/, this.references({
+                                file: result.filePath,
+                                line: (_a = EmbeddedTSFileLineMap[fileNode.concept]) !== null && _a !== void 0 ? _a : 2,
+                                offset: (_b = EmbeddedTSFileOffsetMap[fileNode.concept]) !== null && _b !== void 0 ? _b : 6
+                            })];
+                    case 1:
+                        newRefs = _c.sent();
+                        // 如果是要删除的内容，就是当前的file节点，要关闭当前文件，就把内容置为空
+                        if (fileNode === targetNode) {
+                            outputFiles = [{ file: filePath, fileContent: '' }];
+                        }
+                        else {
+                            // 如果是要删除logic一个小内容，要覆盖全部内容
+                            // 其余要删除的都是把原来的file节点的内容全部覆盖一把
+                            outputFiles = [{ file: result.filePath, fileContent: result.code }];
+                        }
+                        // 更新文件之后
+                        return [4 /*yield*/, this.updateFiles({ outputFiles: outputFiles })];
+                    case 2:
+                        // 更新文件之后
+                        _c.sent();
+                        newRefs.refs.forEach(function (ref) { return filesToCheck.add(ref.file); });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 除去rename场景下的更新
+     * @param fileNode 文件级别的节点
+     * @param targetNode 触发修改的节点
+     * @param result 生成代码的code 和位置信息
+     */
+    NaslServer.prototype.handleChange = function (fileNode, targetNode, result, action) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var outputFiles, newRefs, confirmParms;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.file2NodeMap.set(result.filePath, fileNode);
+                        outputFiles = [{ file: result.filePath, fileContent: result.code }];
+                        // 创建和更新都用update，内部会做判断
+                        return [4 /*yield*/, this.updateFiles({ outputFiles: outputFiles })];
+                    case 1:
+                        // 创建和更新都用update，内部会做判断
+                        _c.sent();
+                        return [4 /*yield*/, this.references({
+                                file: result.filePath,
+                                line: (_a = EmbeddedTSFileLineMap[fileNode.concept]) !== null && _a !== void 0 ? _a : 2,
+                                offset: (_b = EmbeddedTSFileOffsetMap[fileNode.concept]) !== null && _b !== void 0 ? _b : 6
+                            })];
+                    case 2:
+                        newRefs = _c.sent();
+                        newRefs.refs.forEach(function (ref) { return filesToCheck.add(ref.file); });
+                        // 唤起建立连接弹框
+                        // 文件级别的建立连接采取提醒
+                        if (action === 'create' && targetNode.__init) {
+                            // 清除临时状态, 完成本次创建
+                            delete targetNode.__init;
+                            if (fileNode === targetNode && filesToCheck.size > 1) {
+                                confirmParms = {
+                                    actionType: 'createEstablishConnection',
+                                    node: fileNode,
+                                    icon: 'success'
+                                };
+                                common_1.invokeCommand('tsConfirm.open', confirmParms, function () { });
+                            }
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+ * 重命名的更新
+ * @param fileNode 文件级别的节点
+ * @param targetNode 触发修改的节点
+ * @param result 生成代码的code 和位置信息
+ * @param isRename 是不是修改名字
+ * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
+ */
+    NaslServer.prototype.handleRename = function (fileNode, targetNode, result, oldFilePath) {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function () {
+            var outputFiles, oldRefs, newRefs, newRefFileList_1, newRefs2, _g, currentSource, fileNode_2, oldRefs, newRefs2;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        outputFiles = [{ file: result.filePath, fileContent: result.code }];
+                        if (!(fileNode === targetNode)) return [3 /*break*/, 4];
+                        this.file2NodeMap["delete"](oldFilePath);
+                        this.file2NodeMap.set(result.filePath, fileNode);
+                        // 修改名字新的添加进去，旧的置为空
+                        outputFiles.unshift({ file: oldFilePath, fileContent: '' });
+                        return [4 /*yield*/, this.references({
+                                file: oldFilePath,
+                                line: (_a = EmbeddedTSFileLineMap[fileNode.concept]) !== null && _a !== void 0 ? _a : 2,
+                                offset: (_b = EmbeddedTSFileOffsetMap[fileNode.concept]) !== null && _b !== void 0 ? _b : 6
+                            })];
+                    case 1:
+                        oldRefs = _h.sent();
+                        oldRefs.refs.forEach(function (ref) { return filesToCheck.add(ref.file); });
+                        filesToCheck["delete"](oldFilePath);
+                        // 更新文件之后
+                        return [4 /*yield*/, this.updateFiles({ outputFiles: outputFiles })];
+                    case 2:
+                        // 更新文件之后
+                        _h.sent();
+                        return [4 /*yield*/, this.references({
+                                file: result.filePath,
+                                line: (_c = EmbeddedTSFileLineMap[fileNode.concept]) !== null && _c !== void 0 ? _c : 2,
+                                offset: (_d = EmbeddedTSFileOffsetMap[fileNode.concept]) !== null && _d !== void 0 ? _d : 6
+                            })];
+                    case 3:
+                        newRefs = _h.sent();
+                        newRefFileList_1 = new Set();
+                        newRefs.refs.forEach(function (ref) {
+                            filesToCheck.add(ref.file);
+                            newRefFileList_1.add(ref.file);
+                        });
+                        return [3 /*break*/, 11];
+                    case 4:
+                        if (!(targetNode instanceof concepts_1.ViewElement)) return [3 /*break*/, 7];
+                        /**
+                         * 因为页面组件比较特殊
+                         * 修改之后只用查页面本身就好了
+                         */
+                        // 更新文件之后
+                        return [4 /*yield*/, this.updateFiles({ outputFiles: outputFiles })];
+                    case 5:
+                        /**
+                         * 因为页面组件比较特殊
+                         * 修改之后只用查页面本身就好了
+                         */
+                        // 更新文件之后
+                        _h.sent();
+                        return [4 /*yield*/, this.references({
+                                file: fileNode.getEmbeddedFilePath(),
+                                line: (_e = EmbeddedTSFileLineMap[fileNode.concept]) !== null && _e !== void 0 ? _e : 2,
+                                offset: (_f = EmbeddedTSFileOffsetMap[fileNode.concept]) !== null && _f !== void 0 ? _f : 6
+                            })];
+                    case 6:
+                        newRefs2 = _h.sent();
+                        newRefs2.refs.forEach(function (ref) { return filesToCheck.add(ref.file); });
+                        return [3 /*break*/, 11];
+                    case 7:
+                        _g = this.getCurrentSource(targetNode), currentSource = _g.currentSource, fileNode_2 = _g.fileNode;
+                        if (!currentSource) return [3 /*break*/, 11];
+                        return [4 /*yield*/, this.references({
+                                file: fileNode_2.getEmbeddedFilePath(),
+                                line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                                offset: translator_1.lsp2tspNumber(currentSource.range.start.character)
+                            })];
+                    case 8:
+                        oldRefs = _h.sent();
+                        oldRefs.refs.forEach(function (ref) { return filesToCheck.add(ref.file); });
+                        // 更新文件之后
+                        return [4 /*yield*/, this.updateFiles({ outputFiles: outputFiles })];
+                    case 9:
+                        // 更新文件之后
+                        _h.sent();
+                        return [4 /*yield*/, this.references({
+                                file: fileNode_2.getEmbeddedFilePath(),
+                                line: translator_1.lsp2tspNumber(currentSource.range.start.line),
+                                offset: translator_1.lsp2tspNumber(currentSource.range.start.character)
+                            })];
+                    case 10:
+                        newRefs2 = _h.sent();
+                        newRefs2.refs.forEach(function (ref) { return filesToCheck.add(ref.file); });
+                        _h.label = 11;
+                    case 11: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 处理一些节点操作，子节点需要更新并且check的场景
+     * 因为删除，新增父页面，或者重命名会一起
+     * 删除或者新增view而且他有子集 就要执行同样的操作
+     * @param action 当前操作类型
+     * @param fileNode 文件节点
+     * @param targetNode 操作节点  这里要两个相等才会走家去面对哦逻辑
+     * @param oldpath 触发内容的oldpath
+     */
+    NaslServer.prototype.incidentalAction = function (action, fileNode, targetNode, oldpath) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var fileNodeChildren, i, fileNodeItem, result, parentPath, currentOldPath, module_1, results, i, result, node;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode)) return [3 /*break*/, 19];
+                        if (!(fileNode instanceof concepts_1.View && ((_a = fileNode.children) === null || _a === void 0 ? void 0 : _a.length))) return [3 /*break*/, 11];
+                        fileNodeChildren = fileNode.children;
+                        i = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(i < fileNodeChildren.length)) return [3 /*break*/, 11];
+                        fileNodeItem = fileNodeChildren[i];
+                        result = fileNodeItem.toEmbeddedTSFile();
+                        fileNodeItem.sourceMap = result.sourceMap;
+                        if (!(action === 'create')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.handleChange(fileNodeItem, fileNodeItem, result, action)];
+                    case 2:
+                        _b.sent();
+                        return [4 /*yield*/, this.incidentalAction(action, fileNodeItem, fileNodeItem)];
+                    case 3:
+                        _b.sent();
+                        return [3 /*break*/, 10];
+                    case 4:
+                        if (!(action === 'delete')) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.handleDelete(fileNodeItem, fileNodeItem, result)];
+                    case 5:
+                        _b.sent();
+                        return [4 /*yield*/, this.incidentalAction(action, fileNodeItem, fileNodeItem)];
+                    case 6:
+                        _b.sent();
+                        return [3 /*break*/, 10];
+                    case 7:
+                        if (!(action === 'update' && oldpath)) return [3 /*break*/, 10];
+                        parentPath = oldpath.replace('.ts', '/');
+                        currentOldPath = parentPath + fileNodeItem.name + '.ts';
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        return [4 /*yield*/, this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath)];
+                    case 8:
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        _b.sent();
+                        return [4 /*yield*/, this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath)];
+                    case 9:
+                        _b.sent();
+                        _b.label = 10;
+                    case 10:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 11:
+                        if (!(fileNode instanceof concepts_1.Module)) return [3 /*break*/, 18];
+                        if (fileNode.type === 'interface' && fileNode.isAdd && action === 'create') {
+                            isChangeInterface = true;
+                        }
+                        module_1 = targetNode;
+                        results = [];
+                        this.contentToFile(module_1, results);
+                        i = 0;
+                        _b.label = 12;
+                    case 12:
+                        if (!(i < results.length)) return [3 /*break*/, 17];
+                        result = results[i];
+                        node = this.file2NodeMap.get(result.filePath);
+                        if (!(action === 'create')) return [3 /*break*/, 14];
+                        return [4 /*yield*/, this.handleChange(node, node, result, action)];
+                    case 13:
+                        _b.sent();
+                        return [3 /*break*/, 16];
+                    case 14: return [4 /*yield*/, this.handleDelete(node, node, result)];
+                    case 15:
+                        _b.sent();
+                        _b.label = 16;
+                    case 16:
+                        i++;
+                        return [3 /*break*/, 12];
+                    case 17:
+                        // 删除模块通知更新列表
+                        if (action === 'delete') {
+                            try {
+                                // 如果已经
+                                common_1.invokeCommand('module.delete', true);
+                            }
+                            catch (err) {
+                                console.log('module.delete', '组件销毁了,不用唤起了');
+                            }
+                        }
+                        _b.label = 18;
+                    case 18:
+                        /**
+                     * DataSource只会重命名时候，需要把子集全部重新生成一下
+                     */
+                        if (fileNode instanceof concepts_1.DataSource) {
+                            fileNode.entities.forEach(function (entity) { return __awaiter(_this, void 0, void 0, function () {
+                                var result, parentPath, currentOldPath, err_2;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            result = entity.toEmbeddedTSFile();
+                                            parentPath = oldpath.replace('.ts', '/');
+                                            currentOldPath = parentPath + '/entities/' + entity.name + '.ts';
+                                            // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                                            return [4 /*yield*/, this.handleRename(entity, entity, result, currentOldPath)];
+                                        case 1:
+                                            // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                                            _a.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            err_2 = _a.sent();
+                                            console.log(err_2);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                        }
+                        _b.label = 19;
+                    case 19: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.receiveHandleChange = function ($event) {
+        return __awaiter(this, void 0, void 0, function () {
+            var action, targetNode, fileNode, result, oldpath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        singleFileChangeIng = true;
+                        action = $event.action;
+                        targetNode = $event.target;
+                        fileNode = this.getCurrentSource(targetNode).fileNode;
+                        if (!(!fileNode || fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration)) return [3 /*break*/, 3];
+                        if (!(fileNode instanceof concepts_1.Module)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.incidentalAction(action, fileNode, targetNode)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                    case 3:
+                        result = fileNode.toEmbeddedTSFile();
+                        // 当前操作的节点
+                        // 如果当前没有生成tsFile
+                        if (!result) {
+                            return [2 /*return*/];
+                        }
+                        // 修改触发修改文件
+                        this._debugInFileStorage(targetNode, [
+                            {
+                                file: result.filePath,
+                                fileContent: result.code
+                            },
+                        ]);
+                        fileNode.sourceMap = result.sourceMap;
+                        if (!(action === 'update' || action === 'create')) return [3 /*break*/, 9];
+                        if (!(($event === null || $event === void 0 ? void 0 : $event.field) !== 'name')) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.handleChange(fileNode, targetNode, result, action)];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, this.incidentalAction(action, fileNode, targetNode)];
+                    case 5:
+                        _a.sent();
+                        return [3 /*break*/, 9];
+                    case 6:
+                        oldpath = fileNode.getEmbeddedFilePath($event.oldObject.name);
+                        return [4 /*yield*/, this.handleRename(fileNode, targetNode, result, oldpath)];
+                    case 7:
+                        _a.sent();
+                        return [4 /*yield*/, this.incidentalAction(action, fileNode, targetNode, oldpath)];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9:
+                        if (!(action === 'delete')) return [3 /*break*/, 12];
+                        return [4 /*yield*/, this.incidentalAction(action, fileNode, targetNode)];
+                    case 10:
+                        _a.sent();
+                        return [4 /*yield*/, this.handleDelete(fileNode, targetNode, result)];
+                    case 11:
+                        _a.sent();
+                        _a.label = 12;
+                    case 12: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    NaslServer.prototype.changeFileNext = function () {
+        var _this = this;
+        if (!singleFileChangeIng) {
+            var item = this.changeStackList.shift();
+            this.receiveHandleChange(item)["catch"](function (err) {
+                console.log(err, 'receiveHandleChangeErr');
+            })["finally"](function () { return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            // 每一个文件与change接触就把状态置为false，让下一个进入
+                            singleFileChangeIng = false;
+                            if (!this.changeStackList.length) return [3 /*break*/, 1];
+                            this.changeFileNext();
+                            return [3 /*break*/, 3];
+                        case 1: 
+                        // console.log(Array.from(filesToCheck));
+                        return [4 /*yield*/, this.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck))];
+                        case 2:
+                            // console.log(Array.from(filesToCheck));
+                            _a.sent();
+                            filesToCheck.clear();
+                            _a.label = 3;
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); });
+        }
+    };
+    return NaslServer;
+}());
+exports.NaslServer = NaslServer;