@lcap/nasl 3.6.0-alpha.7 → 3.6.0-alpha.8

package/out/server/naslServer.js

@@ -0,0 +1,4735 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var NaslServer_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NaslServer = exports.getDisplayString2Type = void 0;
+/// #if process.env.BUILD_TARGET === 'node'
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const worker_threads_1 = require("worker_threads");
+const decimal_js_1 = require("decimal.js");
+const config_1 = require("../config");
+const sentry_1 = require("../sentry");
+const Messager_1 = __importDefault(require("../common/Messager"));
+const getMemberIdentifier_1 = require("./getMemberIdentifier");
+const concepts_1 = require("../concepts");
+const utils = __importStar(require("../utils"));
+const jsoner = __importStar(require("../service/storage/jsoner"));
+const createUiTs_1 = __importStar(require("./createUiTs"));
+const storage_1 = __importDefault(require("../service/storage"));
+const translator_1 = require("../translator");
+const translator_2 = require("./translator");
+const common_1 = require("../common");
+const diagnostic_1 = require("../manager/diagnostic");
+const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
+const formatTsUtils_1 = require("./formatTsUtils");
+const naslStdlibMap_1 = __importDefault(require("./naslStdlibMap"));
+const EventEmitter_1 = require("../common/EventEmitter");
+const utils_1 = require("../utils");
+const decorators_1 = require("../decorators");
+const utils_2 = require("../automate/engine/utils");
+const EmbeddedTSFileLineMap = {
+    Entity: 3,
+};
+const EmbeddedTSFileOffsetMap = {
+    Variable: 12,
+    FrontendVariable: 12,
+    // Backend:12,
+    BackendVariable: 12,
+    ConfigProperty: 12,
+};
+const SentryMessager = (0, sentry_1.sentryMonitorTSWorkerMessager)(Messager_1.default);
+let isChangeInterface = false; // 判断是否导入接口
+let actionArr = []; //用于导入接口收集更改的节点
+let timer = null; //超时器用于收集导入接口相关
+// naslStdlib文件缓存；作为全局变量给多实例用复用
+const __naslStdlibFileCacheMap = new Map();
+/**
+ * 业务组件先特殊处理一下
+ * 获取业务组件的位置信息
+ */
+function getBusinessComponentPos(fileNode) {
+    if (fileNode.concept === 'BusinessComponent') {
+        const sourceMap = fileNode?.sourceMap?.get(fileNode);
+        if (sourceMap) {
+            const { start } = sourceMap;
+            return {
+                ...start,
+            };
+        }
+    }
+}
+// 联合类型切割取出类型
+function getDisplayString2Type(displayString) {
+    const targetString = displayString.match(/value:\s(\S+)\)/)?.[1];
+    let targetType = null;
+    if (targetString?.startsWith('nasl.core.')) {
+        targetType = targetString.slice(10);
+    }
+    // 取出匹配的内容
+    const reg = /<([^()]+)>/g;
+    // 解决extends 导致类型缺失的问题
+    displayString = displayString?.replace('T extends ', '') || '';
+    const types = reg.exec(displayString);
+    // 取出提示的类型，组成是数组
+    const typeList = (types?.[1].split(' | ') ?? []).map((item) => {
+        if (/<([^()]+)>/g.exec(item)) {
+            return item;
+        }
+        if (item.includes(' ')) {
+            const strs = item.split(' ');
+            const type = strs[strs.length - 1];
+            return type;
+        }
+        if (item.includes('.')) {
+            const strs = item.split('.');
+            const type = strs[strs.length - 1];
+            return type;
+        }
+        return item;
+    });
+    if (targetType) {
+        return typeList.filter((item) => item !== targetType);
+    }
+    return typeList;
+}
+exports.getDisplayString2Type = getDisplayString2Type;
+function isCoreDateTimeType(n) {
+    return n?.expression?.__TypeAnnotation?.typeName === 'DateTime' &&
+        n?.expression?.__TypeAnnotation?.typeNamespace === 'nasl.core';
+}
+function isFunctionWithFixedTimeZoneParam(calleeName) {
+    const fns = ['CurrDateTime', 'CurrDate', 'CurrTime', 'FormatDateTime'];
+    return fns.includes(calleeName);
+}
+const timeZoneArgumentIndexMap = new Map([
+    ['ToString', 1],
+    ['CurrDateTime', 0],
+    ['CurrDate', 0],
+    ['CurrTime', 0],
+    ['FormatDateTime', 2],
+    ['jsonSerialize', 1],
+    ['GetDateCount', 2],
+    ['GetSpecificDaysOfWeek', 3]
+]);
+const allComponent = {};
+let NaslServer = NaslServer_1 = class NaslServer {
+    constructor() {
+        /** naslStdlib文件缓存 */
+        this.naslStdlibFileCacheMap = __naslStdlibFileCacheMap;
+        /**
+         * 按道理 fileSourceMap: new Map<string, SourceMap>() 比较合理，
+         * 但是要多维护一层 vertex 增删 -> file 增删的关系问题，
+         * 先用挂在点上面，简单的方法实现，后期再考虑解耦
+         */
+        this.file2NodeMap = new Map();
+        /** TS 翻译的源码 */
+        this.tsFiles = new Map();
+        /// #if process.env.NODE_ENV === 'development'
+        /**
+         * 调试时是否储存 ts 文件
+         */
+        this.openDebugEmbedded = true;
+        /// #endif
+        this.elementsLogic = {};
+        // 需要执行修改的文件
+        this.changeStackList = [];
+        // 包含组件逻辑调用的逻辑map
+        this.logicSetWithComponentLogic = new Set();
+        /// #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
+            /* !!!如果改动这里需要看下关联的对应文件：webpack/ts-worker/loader.js */
+            this.worker = new worker_threads_1.Worker('/ts-worker.js');
+        /// #endif
+        // 要Check的文件
+        this.filesToCheck = new Set();
+        // 单个文件正在change，不允许同时两个文件一起change
+        this.singleFileChangeIng = false;
+        this.diagnosticManager = new diagnostic_1.DiagnosticManager();
+        this.messager = new SentryMessager({
+            protocol: 'ts-worker',
+            sender: 'ide',
+            context: this,
+            timeout: 120000,
+            getReceiver: () => this.worker,
+            getSender: () => this.worker,
+            handleMessage: async ({ data }) => {
+                if (data && data.event === 'publishDiagnostics') {
+                    const records = await this._resolveDiagnosticRecords(data.records);
+                    await this.diagnosticManager.pushAll(records);
+                    try {
+                        // 结束诊断和标注
+                        (0, common_1.invokeCommand)('naslServer:endWork');
+                        (0, common_1.invokeCommand)('naslServer:nodeChange');
+                        this.embeddedTSEmitter.emit('naslServer:endWork');
+                        this.embeddedTSEmitter.emit('naslServer:nodeChange');
+                    }
+                    catch (e) {
+                        console.log('no "naslServer:nodeChange" event received');
+                    }
+                }
+            },
+        });
+        // 监听所有改变操作
+        this.embeddedTSEmitter = new EventEmitter_1.EventEmitter();
+        this.embeddedTSEmitter.on('change', ({ value: eventValue }) => {
+            eventValue.forEach((item) => {
+                /**
+                 * 多个行为进行合并
+                 * 合并规则是
+                 * 1.[a,b,c,c] 在cc的时候，在已有一个c，又来一个c的时候，file级别的节点
+                 *   就可以前面的内容去掉，只保留最后一个, 但是如果前面那个有携带file
+                 * 2.[a,b,c,b,c] 在bc已存在，又来了bc 这就都要保留，因为可能顺序有相关性，不能去掉
+                 * 理论上只处理同时几个操作 合并，
+                 * 3.有field的也直接保留
+                 */
+                try {
+                    const changeEvent = item.originEvent;
+                    const changeNode = changeEvent.target;
+                    const { fileNode } = this.getCurrentSource(changeNode);
+                    // 这个方法是 5.0 加入标准库的，但是这里 ts 版本是 4.x，ci 会挂，所以需要忽略
+                    // @ts-ignore
+                    const findLastIndex = this.changeStackList.findLastIndex((changeStackItem) => {
+                        const { target } = changeStackItem;
+                        const { fileNode: targetFileNode } = this.getCurrentSource(target);
+                        return targetFileNode === fileNode;
+                    });
+                    // 如果当前找到了节点，而且节点在数组的最后一项，说明此次可以合并
+                    if (findLastIndex !== -1 && findLastIndex === this.changeStackList.length - 1) {
+                        // 最后一项有field就直接保留，新的也不塞，直接return
+                        if (this.changeStackList[findLastIndex]?.field) {
+                            // 如果当前列表里有，这个文件节点，最后一个是field的话，直接return掉，不用塞这个update了
+                            return;
+                        }
+                        // 如果最后一项是普通的update的话，就可以去掉，后面那个会在塞过来
+                        this.changeStackList.pop();
+                    }
+                    this.changeStackList.push(item.originEvent);
+                }
+                catch (err) {
+                    console.log(err);
+                    this.changeStackList.push(item.originEvent);
+                }
+            });
+            // 如果有长度开始执行状态机
+            if (this.changeStackList.length) {
+                this.changeFileNext();
+            }
+        });
+    }
+    start() {
+        return this.messager.requestCommand('start');
+    }
+    terminate() {
+        this.worker.terminate();
+    }
+    async createUiTs(components, optinos) {
+        const { tsCode, baseComponnets } = optinos;
+        // console.log('baseComponnets', baseComponnets);
+        Object.assign(allComponent, components);
+        const { code, elementsLogic } = await (0, createUiTs_1.default)(allComponent);
+        await this.addFile({
+            file: 'nasl.ui.definition.ts',
+            // eslint-disable-next-line import/no-webpack-loader-syntax, global-require, import/extensions
+            fileContent: require('!!raw-loader!../../sandbox/stdlib/nasl.ui.definition.ts').default,
+        }, { cache: true });
+        // 放入生產的uits文件
+        await this.addFile({
+            file: 'nasl.ui.extra.ts',
+            fileContent: code,
+        }, { cache: true });
+        // 添加基础组件的方法到elementsLogic
+        Object.assign(elementsLogic, (0, createUiTs_1.createEleLogins)(baseComponnets));
+        // 基础组件
+        await this.addFile({
+            file: 'nasl.ui.component.ts',
+            fileContent: tsCode,
+        }, { cache: true });
+        Object.keys(naslStdlibMap_1.default).forEach(async (libFileName) => {
+            await this.addFile({
+                file: `/${libFileName}`,
+                fileContent: naslStdlibMap_1.default[libFileName],
+            }, { cache: true });
+        });
+        this.elementsLogic = elementsLogic;
+        // 全部文件加载完毕开始初始化
+        await this.getDiagnosticRecordsAndPushAll();
+    }
+    *contentToFile(module) {
+        if (!module) {
+            return [];
+        }
+        const self = this;
+        const results = [];
+        const getTsFile = function* getTsFile(node, name, pre) {
+            const isContinue = pre ? (input) => input instanceof pre : () => true;
+            try {
+                if (!isContinue(node)) {
+                    return;
+                }
+                const result = yield* node.toEmbeddedTSFile();
+                results.push(result);
+                node.sourceMap = result.sourceMap;
+                self.file2NodeMap.set(result.filePath, node);
+            }
+            catch (err) {
+                if (process.env.NODE_ENV === 'development') {
+                    console.warn(node.nodePath ? node.nodePath : name, '代码转换失败', err);
+                }
+            }
+        };
+        const getTsFiles = function* getTsFiles(nodes, name, pre) {
+            for (const node of nodes ?? []) {
+                yield* getTsFile(node, name, pre);
+            }
+        };
+        const concat = (arr, key) => {
+            return arr.reduce((ans, item) => ans.concat(item[key]), []);
+        };
+        const view2TSFile = function* view2TSFile(views) {
+            if (!views || views.length === 0) {
+                return;
+            }
+            for (const view of views) {
+                yield* getTsFile(view, 'view');
+                if (view.children) {
+                    yield* view2TSFile(view.children);
+                }
+            }
+        };
+        // 禁用的依赖库不生成代码 区分 undefined 和 false
+        if (module instanceof concepts_1.Module && module.type === 'extension' && module.enable === false) {
+            return [];
+        }
+        const { structures = [], metadataTypes = [], frontendTypes = [], interfaces = [], enums = [], logics = [], authLogics = [], authLogicsForCallInterface = [], processes = [], dataSources = [], triggerLaunchers = [], connections = [], roles = [], overriddenLogics = [], backend, configuration, } = module;
+        const { namespaces = [], } = module;
+        const { frontends = [] } = module;
+        yield* getTsFiles(structures, 'structure');
+        yield* getTsFiles(metadataTypes, 'metadataType');
+        if (module instanceof concepts_1.App) {
+            yield* getTsFiles(overriddenLogics, 'overriddenLogic', concepts_1.OverriddenLogic);
+            yield* getTsFiles(backend?.variables ?? [], 'backend_variable');
+            for (const frontendType of frontendTypes) {
+                yield* getTsFile(frontendType, 'frontendType');
+                for (const dep of frontendType.componentDependencies) {
+                    results.push(...(yield* self.contentToFile(dep)));
+                }
+                for (const frontend of frontendType.frontends) {
+                    yield* getTsFile(frontend, 'frontend');
+                    yield* getTsFiles(frontend.variables, 'frontend_variable');
+                    yield* getTsFiles(concat(frontend.bindEvents, 'logics'), 'frontend_bindEvent_logic');
+                    if (!config_1.config.closeViews) {
+                        yield* view2TSFile(frontend.views);
+                    }
+                }
+                // 业务组件
+                yield* getTsFiles(frontendType.businessComponents, 'businessComponents');
+            }
+        }
+        else {
+            // 依赖库
+            yield* getTsFiles(concat(frontends, 'logics'), 'frontend_logic');
+        }
+        yield* getTsFiles(dataSources, 'dataSource');
+        yield* getTsFiles(concat(dataSources, 'entities'), 'dataSource_entity');
+        yield* getTsFiles(interfaces, 'interface');
+        yield* getTsFiles(enums, 'enum');
+        yield* getTsFiles(logics, 'logic');
+        yield* getTsFiles(authLogics, 'authLogic', concepts_1.Logic);
+        yield* getTsFiles(authLogicsForCallInterface, 'authLogicForCallInterface', concepts_1.Logic);
+        yield* getTsFiles(processes, 'process');
+        if (module instanceof concepts_1.Connector) {
+            yield* getTsFiles(triggerLaunchers, 'triggerLauncher');
+            yield* getTsFiles(authLogicsForCallInterface, 'authLogicForCallInterface');
+            yield* getTsFiles(concat(namespaces, 'logics'), 'namespaces_logic');
+        }
+        if (module instanceof concepts_1.App) {
+            yield* getTsFiles(roles, 'role');
+            yield* getTsFiles(connections, 'connection');
+            yield* getTsFiles(triggerLaunchers, 'triggerLauncher');
+        }
+        for (const group of configuration?.groups ?? []) {
+            if (group.name === 'custom') {
+                yield* getTsFiles(group?.properties ?? [], 'configuration_group_property');
+            }
+        }
+        return results;
+    }
+    async openApp(app) {
+        console.time('生成 TS 文件');
+        const self = this;
+        const results = await utils.timeSlicingWithGenerator(getAllTsFiles());
+        const files = results.map((result) => ({
+            file: result.filePath,
+            fileContent: result.code,
+        }));
+        await this.writeFiles(files);
+        this._debugInFileStorage(app, files);
+        // 修改名称回调
+        (0, common_1.registerCommand)('tsRename.change', (value, callback, toast) => {
+            callback(value, toast);
+        });
+        // 删除回调
+        (0, common_1.registerCommand)('tsDelete.change', (callback) => {
+            callback();
+        });
+        console.timeEnd('生成 TS 文件');
+        function* getAllTsFiles() {
+            const files = yield* self.contentToFile(app);
+            const otherModules = [
+                ...app.integration?.connectors ?? [],
+                ...app.dependencies ?? [],
+                ...app.interfaceDependencies ?? [],
+            ];
+            for (const item of otherModules) {
+                files.push(...yield* self.contentToFile(item));
+            }
+            return files;
+        }
+    }
+    async refreshApp(app) {
+        // 清除所有问题
+        this.diagnosticManager.clear();
+        // 刷新要清除文件列表
+        this.file2NodeMap.clear();
+        await this.deleteDirectoryFiles({ directoryName: '/embedded' });
+        // 清楚check count的数量
+        await this.messager.requestCommand('_clearTimeout');
+        // 重新加载app下内容
+        await this.openApp(app);
+        // 重新check一遍所有内容
+        await this.getDiagnosticRecordsAndPushAll();
+        // check内容后，会自动走增量类型标注完善全部类型
+    }
+    /**
+     * 初始化之前添加文件
+     */
+    addFile(file, { cache = false } = {}) {
+        cache && this.cacheFile(file);
+        return this.messager.requestCommand('addFile', file);
+    }
+    // 缓存添加过的文件
+    cacheFile(options) {
+        __naslStdlibFileCacheMap.set(options.file, options);
+    }
+    /**
+     * 只新增文件
+     * @param {*} files
+     */
+    writeFiles(files) {
+        files.forEach(({ file, fileContent }) => this.tsFiles.set(file, fileContent));
+        return this.messager.requestCommand('writeFiles', files);
+    }
+    /**
+     * 新增、修改
+     * 删除文件 文件用修改内容为空模拟，防止报错
+     * @param {*} args
+     */
+    updateFiles(args) {
+        args.outputFiles.forEach(({ file, fileContent }) => this.tsFiles.set(file, fileContent));
+        return this.messager.requestCommand('updateFiles', args);
+    }
+    /**
+     * 清除一个目录下的所有文件
+     */
+    deleteDirectoryFiles(args) {
+        Array.from(this.tsFiles.keys())
+            .filter((key) => key.startsWith(args.directoryName))
+            .forEach((key) => this.tsFiles.delete(key));
+        return this.messager.requestCommand('deleteDirectoryFiles', args);
+    }
+    async _debugInFileStorage(node, openFiles) {
+        let app = node;
+        if (node.concept !== 'App') {
+            app = node.rootNode || node.app;
+        }
+        /// #if process.env.NODE_ENV === 'development'
+        // 首次尝试请求
+        await storage_1.default.post(`/api/App/debugEmbedded?id=${app.id}`, openFiles[0]).catch(() => (this.openDebugEmbedded = false));
+        if (this.openDebugEmbedded && globalThis.window) {
+            // For TS build
+            try {
+                let canDebug = true;
+                await storage_1.default.post(`/api/App/debugEmbedded?id=${app.id}`, openFiles[0]).catch(() => (canDebug = false));
+                if (canDebug) {
+                    await Promise.all(openFiles.map(async (file) => {
+                        const res = await storage_1.default.post(`/api/App/debugEmbedded?id=${app.id}`, file);
+                        return res.data;
+                    }));
+                }
+            }
+            catch (e) {
+                // ..
+            }
+        }
+        /// #endif
+        /// #if process.env.BUILD_TARGET === 'node'
+        if (globalThis.process) {
+            // For TS build
+            try {
+                await Promise.all(openFiles.map(async (file) => fs.outputFile(path.join(__dirname, '../debug/apps', app.id, file.file), file.fileContent)));
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        /// #endif
+    }
+    open() {
+        return this.messager.requestCommand('open');
+    }
+    updateOpen(args) {
+        return this.messager.requestCommand('updateOpen', args);
+    }
+    fileReferences(filePath) {
+        return this.messager.requestCommand('fileReferences', filePath);
+    }
+    async references(args) {
+        return (await this.messager.requestCommand('references', args))?.response;
+    }
+    getValueSelectCompletion(node, value, noFilterList) {
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        // console.log(currentSource, fileNode);
+        if (currentSource && fileNode) {
+            return this._getValueSelectCompletion({
+                file: fileNode.getEmbeddedFilePath(),
+                range: {
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character),
+                },
+                value,
+                noFilterList,
+            });
+        }
+        console.log('没找到节点', node, currentSource, fileNode);
+    }
+    _getValueSelectCompletion(args) {
+        return this.messager.requestCommand('getValueSelectCompletion', args);
+    }
+    /**
+     * 获取 Convert 的可选类型
+     * @param node 传入当前已经选择的变量
+     * @returns 可以选择的类型数组
+     */
+    async getConvertTypeInfo(node) {
+        if (node && node instanceof concepts_1.BaseNode) {
+            const callFunction = node.parentNode.parentNode;
+            /**
+             * currentSource callFunction 的节点，要去到当前节点的位置
+             * nasl.util.Convert(xxx),所以取到的位置要 + `nasl.util.C` 的长度
+             * fileNode
+             */
+            const { currentSource, fileNode } = this.getCurrentSource(callFunction);
+            if (!currentSource) {
+                return [];
+            }
+            try {
+                const quickInfo = await this._getTypeQuickinfo({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character) + `nasl.util.C`.length,
+                });
+                if (quickInfo.responseRequired) {
+                    const displayString = quickInfo?.response?.displayString || '';
+                    const typeList = getDisplayString2Type(displayString);
+                    const res = [];
+                    typeList.forEach((type) => {
+                        const typeAnnotation = coreTypeList_1.primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
+                        if (typeAnnotation) {
+                            res.push(typeAnnotation);
+                        }
+                        else if (type === 'unknown' || type === 'never') {
+                            return null;
+                        }
+                    });
+                    if (!res.length) {
+                        return [];
+                    }
+                    return [{ title: '基础类型', children: res }];
+                }
+            }
+            catch (err) {
+                console.log(err);
+                // 如果有异常就先放开全部可选，兜底逻辑
+                return [];
+            }
+        }
+        else {
+            // 字符串 和 inter
+            return [{ title: '基础类型', children: [coreTypeList_1.primitiveTypeList[4]] }];
+        }
+    }
+    /**
+     * 获取表格的dataschema类型
+     * @param node 当前表格节点
+     * @param allType 是不是需要全部类型 默认不要
+     * @returns 全部类型的str 或者 最后一个.后的内容
+     */
+    async getDataSchemaType(node, allType = false) {
+        if (!(node instanceof concepts_1.ViewElement))
+            return;
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        if (!currentSource) {
+            return;
+        }
+        const quickInfo = await this._getTypeQuickinfo({
+            file: fileNode.getEmbeddedFilePath(),
+            line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+            offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character) + `new nasl.ui.`.length,
+        });
+        if (quickInfo.responseRequired) {
+            const displayString = quickInfo?.response?.displayString || '';
+            const flag = displayString.includes('<') && displayString.includes('>');
+            const types = /<([^()]+)>/g.exec(displayString);
+            let typeStr = types && types[1];
+            // 从 {entity1:Entity1(defaultDS);},unknown,unknown,unknown 取出{entity1:Entity1(defaultDS);}
+            typeStr = typeStr?.split(',')[0];
+            if (flag) {
+                // 自定义结构的展示
+                if (typeStr.includes('__name: "AStructure_')) {
+                    return typeStr
+                        .replaceAll(' ', '')
+                        .replaceAll('\n', '')
+                        .replace(/__name:"AStructure_\w{8}";/g, '')
+                        .replace(/dataSources.([^.]+).entities.([^;]+)/g, ($1, $2, $3) => `${$3}(${$2})`);
+                }
+                if (typeStr.startsWith('{') && typeStr.endsWith('}')) {
+                    /**
+                               *  {
+                                      text: nasl.core.String;
+                                      value: nasl.core.String;
+                                  }
+                               */
+                    return typeStr.replaceAll(' ', '').replaceAll('\n', '').replaceAll('nasl.core.', '');
+                }
+                let str = '';
+                // 取出T的值
+                typeStr = (0, formatTsUtils_1.getPlatformType)(typeStr);
+                // 如果要全量的内容
+                if (allType) {
+                    return typeStr;
+                }
+                // 取出剩下的剩下的类型的最后一项
+                if (/<([^()]+)>/g.exec(typeStr)) {
+                    str = typeStr;
+                }
+                else if (typeStr.includes('.')) {
+                    const strs = typeStr.split('.');
+                    const type = strs[strs.length - 1];
+                    str = type;
+                }
+                else {
+                    str = typeStr;
+                }
+                str = str === 'any' || str === 'unknown' || str === 'never' ? '' : str;
+                return str;
+            }
+        }
+        return '';
+    }
+    async getDataSchemaStructureOrTypeAnnotation(node) {
+        if (!(node instanceof concepts_1.ViewElement))
+            return;
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        if (!currentSource) {
+            return;
+        }
+        const quickInfo = await this._getTypeQuickinfo({
+            file: fileNode.getEmbeddedFilePath(),
+            line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+            offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character) + `new nasl.ui.`.length,
+        });
+        if (quickInfo.responseRequired) {
+            const displayString = quickInfo?.response?.displayString || '';
+            const flag = displayString.includes('<') && displayString.includes('>');
+            if (!flag)
+                return;
+            const types = /<([^()]+)>/g.exec(displayString);
+            const typeStr = types && types[1];
+            const app = node.getAncestor('App');
+            if (typeStr.includes('__name: "AStructure_')) {
+                const properties = [];
+                typeStr.replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
+                    if (name === '__name')
+                        return;
+                    typeKey = `app.${typeKey}`;
+                    const keys = typeKey.split('.');
+                    const typeName = keys.pop();
+                    const typeNamespace = keys.join('.');
+                    properties.push(concepts_1.StructureProperty.from({
+                        name,
+                        typeAnnotation: concepts_1.TypeAnnotation.from({
+                            typeKind: 'reference',
+                            typeName,
+                            typeNamespace,
+                        }),
+                    }));
+                    return '';
+                });
+                return concepts_1.TypeAnnotation.createTypeAnonymousStructure(properties);
+            }
+            if (typeStr.startsWith('structures'))
+                return app.findNodeByCompleteName(`app.${typeStr}`);
+        }
+    }
+    /**
+     * ts的 quickInfo方法，查询指定位置的详情
+     * @param args 文件信息数组
+     * @returns 查询到的
+     */
+    _getTypeQuickinfo(args) {
+        return this.messager.requestCommand('quickInfo', args);
+    }
+    _getQuickInfoFull(args) {
+        return this.messager.requestCommand('quickInfoFull', args);
+    }
+    /**
+     * 获取nasl节点的 指定位置的详情
+     * 而且可以返回正确类型
+     * @param args 文件信息数组
+     * @returns 查询到的
+     */
+    async getNaslNodeQuickInfoFull(args) {
+        const result = await this._getQuickInfoFull(args);
+        return result;
+    }
+    _getTypeFull(args) {
+        return this.messager.requestCommand('typeFull', args);
+    }
+    _getTypeBatch(args) {
+        return this.messager.requestCommand('typeBatch', args);
+    }
+    async getNaslNodeTypeFull(args) {
+        const result = await this._getTypeFull(args);
+        return result;
+    }
+    async getNaslNodeTypeBatch(args) {
+        const result = await this._getTypeBatch(args);
+        return result;
+    }
+    /**
+     * 获取已经选中的内容的 下一级的内容
+     * @param node 已经选中的内容
+     * @param noFilterList 不过滤的key 的数据
+     * @returns 可以选择的数据数组
+     */
+    getSelectNextCompletion(node, noFilterList) {
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        // console.log(currentSource, fileNode);
+        if (currentSource && fileNode) {
+            return this._getSelectNextCompletion({
+                file: fileNode.getEmbeddedFilePath(),
+                range: {
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character),
+                },
+                noFilterList,
+            });
+        }
+        console.log('没找到节点', currentSource, fileNode);
+    }
+    _getSelectNextCompletion(args) {
+        return this.messager.requestCommand('getSelectNextCompletion', args);
+    }
+    getDiagnosticRecordsAndPushAll(fileNames) {
+        (0, common_1.invokeCommand)('naslServer:startWork');
+        return this.messager.requestCommand('getDiagnosticRecords', fileNames);
+    }
+    /**
+     * 节点异常是只能挂载单个，如果已经了就不赋值了
+     */
+    baseNodeAssignmentTsError(node, tsErrorDetail) {
+        if (node.tsErrorDetail)
+            return;
+        node.tsErrorDetail = tsErrorDetail;
+    }
+    *_resolveDiagnosticRecordsWithGenerator(records) {
+        // 热更新类型标注
+        if (records.length) {
+            yield* this._incrementalAnnotationJSONWithGenerator(records);
+        }
+        const self = this;
+        console.time('处理诊断数据');
+        yield* utils.wrapForEachToGenerator(records, function* resolveRecord(record) {
+            if (!record || !record.node) {
+                return;
+            }
+            const { node } = record;
+            // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
+            const oldRecord = self.diagnosticManager.getRecord?.(record.id);
+            // 处理旧数据
+            if (oldRecord) {
+                yield* utils.wrapForEachToGenerator(oldRecord.semanticDiagnostics, (item) => {
+                    if (item.node) {
+                        delete item.node.tsErrorDetail;
+                        // 如果logic中有报错就把标识置为true
+                        if (item.node?.logic?.haveError) {
+                            item.node.logic.haveError = false;
+                        }
+                    }
+                });
+                yield* utils.wrapForEachToGenerator(oldRecord.suggestionDiagnostics, (item) => {
+                    if (item.node) {
+                        delete item.node.tsErrorDetail;
+                        if (item.node && item.node instanceof concepts_1.Logic) {
+                            item.node.isSmpty = false;
+                        }
+                    }
+                });
+            }
+            // 语义诊断
+            if (isChangeInterface) {
+                yield* self.existStructureFix(record.semanticDiagnostics, record.node, self);
+            }
+            // 单独处理 oql 语义错误提示
+            if (record.node instanceof concepts_1.Logic) {
+                yield* utils.wrapForEachToGenerator(record?.syntaxDiagnostics, function* test(item) {
+                    const minRange = yield* self._findMinRangeWithGenerator(item, record.node);
+                    if (minRange?.node instanceof concepts_1.OqlQueryComponent) {
+                        if (item.text === 'Invalid character.') {
+                            record.semanticDiagnostics.push(item);
+                        }
+                    }
+                });
+            }
+            // 记录结构体数据
+            yield* utils.wrapForEachToGenerator(record.semanticDiagnostics, (diag) => {
+                (0, translator_2.checkAStructure_)(diag.text);
+            });
+            record.semanticDiagnostics = (yield* utils.wrapMapToGenerator(record.semanticDiagnostics, function* (diag) {
+                return yield* self._resolveDiagnosticWithGenerator(diag, record.node, record);
+            })).filter((diag) => !!diag);
+            record.semanticDiagnostics.push(...(yield* self._attachDiagnosticsWithGenerator(node)));
+            // 报错降级逻辑
+            record.semanticDiagnostics = (yield* utils.wrapMapToGenerator(record.semanticDiagnostics, (diagnostic) => {
+                // 错误降级如果属于草稿态的就降级
+                if (diagnostic?.node) {
+                    let currentNode = diagnostic.node;
+                    if (diagnostic.severity === 'warning') {
+                        record.suggestionDiagnostics.push(diagnostic);
+                        return null;
+                    }
+                    if (concepts_1.asserts.isStrictOqlQueryComponent(currentNode)) {
+                        // OQL别名错误降级为警告
+                        if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
+                            // 重置 图标和错误等级
+                            diagnostic.severity = 'warning';
+                            if (diagnostic.node?.tsErrorDetail) {
+                                // 重置组件节点上的错误信息
+                                diagnostic.node.tsErrorDetail.severity = 'warning';
+                            }
+                            record.suggestionDiagnostics.push(diagnostic);
+                            return null;
+                        }
+                    }
+                    while (currentNode && currentNode?.parentNode?.concept !== 'App') {
+                        if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
+                            // 草稿区降级
+                            // 重置 图标和错误等级
+                            diagnostic.severity = 'warning';
+                            if (diagnostic.node?.tsErrorDetail) {
+                                // 重置组件节点上的错误信息
+                                diagnostic.node.tsErrorDetail.severity = 'warning';
+                            }
+                            record.suggestionDiagnostics.push(diagnostic);
+                            return null;
+                        }
+                        currentNode = currentNode.parentNode;
+                    }
+                    // 没有降级的继续遍历，如果在logic中，logic本身需要有error状态
+                    // 如果logic中有报错就把标识置为true
+                    if (diagnostic.node?.logic) {
+                        diagnostic.node.logic.haveError = true;
+                    }
+                }
+                return diagnostic;
+            }))
+                .filter((diag) => !!diag);
+            // 处理后的警告异常提示信息
+            record.suggestionDiagnostics = (yield* utils.wrapMapToGenerator(record.suggestionDiagnostics, function* resolveSuggestionDiagnostic(diag) {
+                // 上面错误降级下来的
+                if (diag?.node) {
+                    return diag;
+                    // 一些已知警告的单独处理
+                }
+                if ([
+                    `'__LogicEmpty' is declared but its value is never read.`,
+                    `'__destinationEmpty__' is declared but its value is never read.`,
+                    `'__devConfigValueEmpty' is declared but its value is never read.`,
+                    `'__onlineConfigValueEmpty' is declared but its value is never read.`,
+                    `'__UpdateNoProperty__' is declared but its value is never read.`,
+                ].includes(diag.text)) {
+                    return yield* self._resolveDiagnosticWithGenerator(diag, record.node, record);
+                }
+                if (diag.text.includes(` is declared but its value is never read.`)) {
+                    // 局部变量和输入变量未使用的警告
+                    const fromModule = record.node.parentNode.concept === 'Module';
+                    const fromConnector = record.node.parentNode.concept === 'Connector';
+                    if ((concepts_1.asserts.isStrictView(record.node) || concepts_1.asserts.isStrictLogic(record.node)) && !(fromModule || fromConnector)) {
+                        /**
+                         * javalogic不用提示
+                         */
+                        if (concepts_1.asserts.isStrictLogic(record.node) && self._isJavalogic(record.node)) {
+                            return null;
+                        }
+                        concepts_1.asserts.assertFileNode(record.node);
+                        const minRange = yield* self._findMinRangeWithGenerator(diag, record.node);
+                        if (minRange) {
+                            /**
+                             * 如果节点是入参类型
+                             * 而且不是foreach中
+                             * 而且不是事件逻辑的入参
+                             */
+                            if (minRange.node instanceof concepts_1.Param &&
+                                minRange.node.parentNode.concept !== 'ForEachStatement' &&
+                                !minRange.node.getAncestor('BindEvent')) {
+                                const diagnostic = {
+                                    node: minRange.node,
+                                    severity: 'warning',
+                                    message: `未使用的输入参数${minRange.node.name}`,
+                                };
+                                return diagnostic;
+                            }
+                            if (minRange.node instanceof concepts_1.Variable) {
+                                const diagnostic = {
+                                    node: minRange.node,
+                                    severity: 'warning',
+                                    message: `未使用的变量${minRange.node.name}`,
+                                };
+                                return diagnostic;
+                            }
+                        }
+                    }
+                }
+                return null;
+            }))
+                .filter((diag) => !!diag);
+            record.suggestionDiagnostics.push(...yield* self._attachSuggestionDiagnosticsWithGenerator(node));
+        });
+        console.timeEnd('处理诊断数据');
+        return records;
+    }
+    /**
+     * 处理诊断结果
+     * @param records 结果
+     * @returns 过滤或者转换后的诊断结果
+     */
+    _resolveDiagnosticRecords(records) {
+        return utils.timeSlicingWithGenerator(this._resolveDiagnosticRecordsWithGenerator(records));
+    }
+    /**
+     * 判断是否是Javalogic
+     */
+    _isJavalogic(node) {
+        const body = node.body || [];
+        if (body && body.length && body[0].concept === 'JavaLogic') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 额外的建议诊断
+     * @param fileNode 文件级别的节点
+     * @returns 诊断结果
+     */
+    *_attachSuggestionDiagnosticsWithGenerator(fileNode) {
+        const diagnostics = [];
+        if (fileNode instanceof concepts_1.Logic || fileNode instanceof concepts_1.View) {
+            fileNode?.sourceMap.forEach((value, node) => {
+                // 表达式模式才需要校验返回值类型
+                if (node instanceof concepts_1.Match && node.isExpression) {
+                    const { cases, expression } = node || {};
+                    const typeAnnotationMap = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(cases)) {
+                        cases.forEach((caseItem, index) => {
+                            let isDisabled = false;
+                            // 是最后一项
+                            if (index === cases.length - 1) {
+                                let enumerableItems = [];
+                                const currTypeAnnotation = expression?.__TypeAnnotation;
+                                const { typeKind, typeNamespace, typeName, typeArguments } = currTypeAnnotation || {};
+                                if (typeKind === 'union' && Array.isArray(typeArguments)) {
+                                    enumerableItems = typeArguments.map((typeArg) => {
+                                        let typeArgJson = typeArg;
+                                        if (typeArg instanceof concepts_1.TypeAnnotation) {
+                                            typeArgJson = typeArg.toJSON();
+                                        }
+                                        return new concepts_1.TypeAnnotation(typeArgJson);
+                                    });
+                                }
+                                else if (typeKind === 'reference') {
+                                    const nameArr = [typeName];
+                                    if (typeNamespace) {
+                                        nameArr.unshift(typeNamespace);
+                                    }
+                                    const typeNode = node.app?.findNodeByCompleteName?.(nameArr.join('.')) || {};
+                                    if (typeNode.concept === 'Enum') {
+                                        const enums = (0, getMemberIdentifier_1.formatEnums)([typeNode]);
+                                        const { children } = enums?.[0] || {};
+                                        if (Array.isArray(children)) {
+                                            enumerableItems = children.map((child) => 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) {
+                                    const map = {};
+                                    cases.forEach((caseItem) => {
+                                        const { patterns } = caseItem || {};
+                                        if (Array.isArray(patterns)) {
+                                            patterns.forEach((pattern) => {
+                                                if (pattern instanceof concepts_1.TypeAnnotation) {
+                                                    const patternTypeKey = pattern.typeKey;
+                                                    map[patternTypeKey] = true;
+                                                }
+                                                else if (pattern instanceof concepts_1.MemberExpression || pattern instanceof concepts_1.BooleanLiteral) {
+                                                    const patternValue = pattern.getValue();
+                                                    map[patternValue] = true;
+                                                }
+                                            });
+                                        }
+                                    });
+                                    const enumerableKeys = Object.keys(map);
+                                    if (enumerableKeys.length === enumerableItems.length) {
+                                        isDisabled = true;
+                                    }
+                                }
+                            }
+                            if (!isDisabled) {
+                                const typeAnnotation = caseItem.__TypeAnnotation;
+                                // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                                if (typeAnnotation) {
+                                    const sortedTypeKey = typeAnnotation?.sortedTypeKey;
+                                    if (!typeAnnotationMap[sortedTypeKey]) {
+                                        typeAnnotationMap[sortedTypeKey] = {
+                                            typeAnnotation,
+                                            cases: [],
+                                            count: 0,
+                                        };
+                                    }
+                                    const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                    typeAnnotationInfo.cases.push(caseItem);
+                                    typeAnnotationInfo.count++;
+                                    const { count } = typeAnnotationInfo;
+                                    if (maxTypeAnnotationInfo.count < count) {
+                                        maxTypeAnnotationInfo = {
+                                            typeAnnotation,
+                                            count,
+                                        };
+                                    }
+                                    return typeAnnotation;
+                                }
+                            }
+                        });
+                    }
+                    const { typeAnnotation: maxTypeAnnotation } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, cases } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(cases)) {
+                                cases.forEach((caseItem) => {
+                                    const { body } = caseItem || {};
+                                    const diagnostic = {
+                                        node: caseItem,
+                                        severity: 'warning',
+                                        message: '分支类型不一致',
+                                    };
+                                    if (Array.isArray(body) && body.length) {
+                                        const lastExpression = body[body.length - 1];
+                                        diagnostic.node = lastExpression;
+                                        diagnostic.message = `匹配：该分支类型与多数类型不一致，将产生Union类型。当前类型：${typeAnnotation?.headTitle}，多数类型：${maxTypeAnnotation?.headTitle}`;
+                                        this.baseNodeAssignmentTsError(lastExpression, diagnostic);
+                                        diagnostics.push(diagnostic);
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (node instanceof concepts_1.NewList && !node.typeAnnotation) {
+                    // 匿名函数返回值有可能是newList，需要过滤。代码来源：AnonymousFunction.__ts
+                    const grandParent = node.parentNode?.parentNode?.parentNode;
+                    if (grandParent instanceof concepts_1.CallLogic &&
+                        /dataSources\.[^.]+\.entities\.[^.]+\.logics/.test(grandParent.calleeNamespace) &&
+                        ['update', 'updateBy', 'createOrUpdate', 'batchUpdate'].includes(grandParent.calleeName)) {
+                        return;
+                    }
+                    const { items } = node || {};
+                    const typeAnnotationMap = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(items)) {
+                        items.forEach((item) => {
+                            const typeAnnotation = item.__TypeAnnotation;
+                            // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                            if (typeAnnotation) {
+                                const { sortedTypeKey } = typeAnnotation;
+                                if (!typeAnnotationMap[sortedTypeKey]) {
+                                    typeAnnotationMap[sortedTypeKey] = {
+                                        typeAnnotation,
+                                        items: [],
+                                        count: 0,
+                                    };
+                                }
+                                const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                typeAnnotationInfo.items.push(item);
+                                typeAnnotationInfo.count++;
+                                const { count } = typeAnnotationInfo;
+                                if (maxTypeAnnotationInfo.count < count) {
+                                    maxTypeAnnotationInfo = {
+                                        typeAnnotation,
+                                        count,
+                                    };
+                                }
+                            }
+                        });
+                    }
+                    const { typeAnnotation: maxTypeAnnotation } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, items } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(items)) {
+                                items.forEach((item) => {
+                                    const diagnostic = {
+                                        node: item,
+                                        severity: 'warning',
+                                        message: `NewList期望的类型是${maxTypeAnnotation?.headTitle}`,
+                                    };
+                                    this.baseNodeAssignmentTsError(item, diagnostic);
+                                    diagnostics.push(diagnostic);
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (node instanceof concepts_1.NewMap && !node.typeAnnotation) {
+                    const { values } = node || {};
+                    const typeAnnotationMap = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(values)) {
+                        values.forEach((value) => {
+                            if (!value)
+                                return;
+                            const typeAnnotation = value.__TypeAnnotation;
+                            // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                            if (typeAnnotation) {
+                                const { sortedTypeKey } = typeAnnotation;
+                                if (!typeAnnotationMap[sortedTypeKey]) {
+                                    typeAnnotationMap[sortedTypeKey] = {
+                                        typeAnnotation,
+                                        values: [],
+                                        count: 0,
+                                    };
+                                }
+                                const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                typeAnnotationInfo.values.push(value);
+                                typeAnnotationInfo.count++;
+                                const { count } = typeAnnotationInfo;
+                                if (maxTypeAnnotationInfo.count < count) {
+                                    maxTypeAnnotationInfo = {
+                                        typeAnnotation,
+                                        count,
+                                    };
+                                }
+                            }
+                        });
+                    }
+                    const { typeAnnotation: maxTypeAnnotation } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, values } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(values)) {
+                                values.forEach((value) => {
+                                    const diagnostic = {
+                                        node: value,
+                                        severity: 'warning',
+                                        message: `NewMap中values值所期望的类型是${maxTypeAnnotation?.headTitle}`,
+                                    };
+                                    this.baseNodeAssignmentTsError(value, diagnostic);
+                                    diagnostics.push(diagnostic);
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (node.concept === 'JSBlock') {
+                    // 初始js代码块先屏蔽掉
+                    if (node.code === `location.href = '/';`) {
+                        return null;
+                    }
+                    if (node?.code?.includes('use JSBlock')) {
+                        return null;
+                    }
+                    const diagnostic = {
+                        node,
+                        severity: 'warning',
+                        message: '不建议使用js代码块',
+                    };
+                    diagnostics.push(diagnostic);
+                }
+                else if (node.concept === 'Unparsed') {
+                    const diagnostic = {
+                        node,
+                        severity: 'warning',
+                        message: '不建议使用自定义表达式',
+                    };
+                    diagnostics.push(diagnostic);
+                }
+                else if (node instanceof concepts_1.CallQueryComponent) {
+                    // 可视化查询中不允许有复杂的数据结构
+                    const contentVariables = [];
+                    utils.traverse(({ node }) => {
+                        if (node?.parentNode?.concept !== 'MemberExpression') {
+                            if (node?.concept === 'MemberExpression') {
+                                contentVariables.push(node);
+                            }
+                            else if (node?.concept === 'Identifier') {
+                                // 因为要是父级是MemberExpression， 就放入了父级，子级就不需要了
+                                contentVariables.push(node);
+                                // QueryFromExpression QueryJoinExpression
+                            }
+                            else if ((node?.concept === 'QueryFieldExpression' && !node.isDotStar) ||
+                                node?.concept === 'QueryGroupByExpression') {
+                                contentVariables.push(node);
+                            }
+                        }
+                    }, { node }, {
+                        mode: 'anyObject',
+                        excludedKeySet: new Set(['parentNode', '_events', 'globalDataMap', 'havingPlayground', 'wherePlayground']),
+                    });
+                    contentVariables?.forEach((variable) => {
+                        // 如果是复杂数据结构
+                        if (variable.__TypeAnnotation?.isComplexType()) {
+                            if (variable.__TypeAnnotation?.typeName === 'List' && variable.__TypeAnnotation?.typeArguments?.[0]?.typeKind === 'primitive') {
+                                return;
+                            }
+                            const diagnostic = {
+                                node,
+                                severity: 'warning',
+                                message: `数据查询中不可以使用复杂类型！当前类型：${variable.__TypeAnnotation?.typeChineseTitle}。`,
+                            };
+                            this.baseNodeAssignmentTsError(variable, diagnostic);
+                            diagnostics.push(diagnostic);
+                        }
+                        else if (variable.__TypeAnnotation?.hasSystemType(node.app)) {
+                            const diagnostic = {
+                                node,
+                                severity: 'warning',
+                                message: `数据查询中不可以使用或包含系统类型！当前类型：${variable.__TypeAnnotation?.typeChineseTitle}。`,
+                            };
+                            this.baseNodeAssignmentTsError(variable, diagnostic);
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
+            });
+        }
+        return diagnostics;
+    }
+    // 是否包含组件逻辑
+    hasComponentLogics(expression) {
+        let flag = false;
+        (0, utils_1.traverse)((current) => {
+            const { node } = current || {};
+            const { concept } = node || {};
+            if (concept === 'CallLogic') {
+                // 调用组件逻辑
+                if (node.isComponentLogic) {
+                    flag = true;
+                }
+                else if (node.isViewLogic) {
+                    // 调用页面逻辑
+                    const logicNode = node.view?.logics?.find?.((viewLogic) => viewLogic.name === node.calleeName);
+                    if (logicNode) {
+                        if (this.logicSetWithComponentLogic.has(logicNode.nodePath)) {
+                            flag = true;
+                        }
+                        else {
+                            const logicItem = logicNode.body?.find?.((logicItem) => this.hasComponentLogics(logicItem));
+                            if (logicItem) {
+                                flag = true;
+                                this.logicSetWithComponentLogic.add(logicNode.nodePath);
+                            }
+                        }
+                    }
+                }
+            }
+        }, {
+            node: expression,
+        }, {
+            mode: 'anyObject',
+            excludedKeySet: new Set([
+                'parentNode',
+                'sourceMap',
+                'storageJSON',
+                'tsErrorDetail',
+                'NaslAnnotatedJSON',
+                'calledFrom',
+                '_events',
+                '_collectingList',
+                '_historyList',
+            ]),
+        });
+        return flag;
+    }
+    /** 是否被 触发器依赖, 如果存在，返回第一个触发器对应的名称 */
+    isRefedByTriggerAndReturnFirstRef(fileNode) {
+        return this._isHaveRef(fileNode).then((refs) => {
+            const basePath = concepts_1.TriggerLauncher.getEmbeddedFileBasePath(fileNode.rootNode);
+            let flag = false;
+            let fRefName = '';
+            try {
+                for (const ref of refs) {
+                    const { file } = ref;
+                    if (file.startsWith(basePath)) {
+                        flag = true;
+                        // file: /embedded/tttta/triggerLaunchers/订阅配置_asd.ts
+                        fRefName = file.split(basePath)[1].split('.')[0];
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error, refs);
+            }
+            return {
+                isRefedByTrigger: flag,
+                fRefName,
+            };
+        });
+        // const refs = await this._isHaveRef(fileNode);
+        // const basePath = TriggerLauncher.getEmbeddedFileBasePath(fileNode.rootNode as App);
+        // let flag = false;
+        // let fRefName = '';
+        // try {
+        //   for (const ref of refs) {
+        //     const { file } = ref;
+        //     if (file.startsWith(basePath)) {
+        //       flag = true;
+        //       // file: /embedded/tttta/triggerLaunchers/订阅配置_asd.ts
+        //       fRefName = file.split(basePath)[1].split('.')[0];
+        //       break;
+        //     }
+        //   }
+        // } catch (error) {
+        //   console.error(error, refs);
+        // }
+        // return {
+        //   isRefedByTrigger: flag,
+        //   fRefName,
+        // };
+    }
+    /**
+     * 是否符合 触发器规则
+     * 规则：
+     * 1. 入参仅有一个，且必须为string类型
+     * 2. 不允许有返回值
+     */
+    isTriggerRule(fileNode) {
+        const { sourceMap } = fileNode;
+        let paramsLength = 0;
+        let returnLength = 0;
+        let flag = true;
+        sourceMap.forEach((_, k) => {
+            if (k instanceof concepts_1.Param) {
+                paramsLength++;
+                const typeAnnotation = k.typeAnnotation || k.__TypeAnnotation;
+                const { typeKind, typeName, typeNamespace } = typeAnnotation || {};
+                const isString = typeKind === 'primitive' && typeName === 'String' && typeNamespace === 'nasl.core';
+                if (!isString) {
+                    flag = false;
+                }
+            }
+            if (k instanceof concepts_1.Return) {
+                returnLength++;
+            }
+        });
+        return paramsLength === 1 && flag && returnLength === 0;
+    }
+    /**
+     * 额外的诊断
+     * @param fileNode 文件级别的节点
+     * @returns 诊断结果
+     */
+    *_attachDiagnosticsWithGenerator(fileNode) {
+        // 每次诊断前先清空这个Set
+        this.logicSetWithComponentLogic = new Set();
+        const self = this;
+        const diagnostics = [];
+        if (fileNode instanceof concepts_1.View || fileNode instanceof concepts_1.BusinessComponent) {
+            yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), function* attachView([node, value]) {
+                const likeComponent = node.getAncestor('View') || node.getAncestor('BusinessComponent');
+                if (node instanceof concepts_1.ViewElement && likeComponent === fileNode) {
+                    if (node.tag) {
+                        yield* utils.wrapForEachToGenerator(node.bindAttrs, (bindAttr) => {
+                            if ((bindAttr.model || bindAttr.sync) && bindAttr.expression) {
+                                const bindExpression = bindAttr.expression;
+                                let diagnostic;
+                                if (bindExpression.concept === 'MemberExpression') {
+                                    let current = bindExpression;
+                                    if (bindExpression.isEnum()) {
+                                        diagnostic = {
+                                            node: bindExpression,
+                                            severity: 'error',
+                                            message: '页面组件属性表达式：该表达式不支持获取组件输入内容，请改为可赋值的变量或属性。',
+                                        };
+                                    }
+                                    else {
+                                        while (current.object) {
+                                            if (current.object.concept !== 'MemberExpression' && current.object.concept !== 'Identifier') {
+                                                diagnostic = {
+                                                    node: bindExpression,
+                                                    severity: 'error',
+                                                    message: '页面组件属性表达式：该表达式不支持获取组件输入内容，请改为可赋值的变量或属性。',
+                                                };
+                                                break;
+                                            }
+                                            current = current.object;
+                                        }
+                                    }
+                                }
+                                else if (bindExpression.concept !== 'Identifier') {
+                                    diagnostic = {
+                                        node: bindExpression,
+                                        severity: 'error',
+                                        message: '页面组件属性表达式：该表达式不支持获取组件输入内容，请改为可赋值的变量或属性。',
+                                    };
+                                }
+                                if (diagnostic) {
+                                    bindExpression.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                }
+                            }
+                        });
+                    }
+                }
+                else if ((node instanceof concepts_1.Variable || node instanceof concepts_1.Return) && likeComponent === fileNode) {
+                    if (!node.typeAnnotation && !node.__TypeAnnotation) {
+                        const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+                        let msg;
+                        yield* fileNode.traverseChildrenGenerator((nodeIn) => {
+                            if (nodeIn && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))) {
+                                // 子页面内部逻辑过滤
+                                if ((nodeIn.view || nodeIn.getAncestor('BusinessComponent')) !== fileNode)
+                                    return;
+                                // 当局部变量、输出参数属于页面内逻辑时，需过滤同页面下不同逻辑下的同名变量
+                                if (node.logic && node.logic !== nodeIn.logic)
+                                    return;
+                                // 跟变量无关的赋值过滤
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                }
+                                catch (err) {
+                                    console.log(err);
+                                }
+                                if (!jsCode.startsWith(`${node.name} = `))
+                                    return;
+                                // 页面局部变量
+                                if (node instanceof concepts_1.Variable && node.parentNode instanceof concepts_1.View) {
+                                    // 跟页面局部变量无关的赋值过滤
+                                    if (!jsCode.startsWith(`this.${node.name} = `))
+                                        return;
+                                    // 直接赋值 logic 内局部变量、输入参数直接提示系统无法推断类型
+                                    if (nodeIn.logic?.params.find((param) => jsCode.startsWith(param.name)) ||
+                                        nodeIn.logic?.virtualParams.find((vParam) => jsCode.startsWith(vParam.name)) ||
+                                        nodeIn.logic?.variables.find((variable) => jsCode.startsWith(variable.name))) {
+                                        if (!nodeIn.tsErrorDetail) {
+                                            const diagnostic = {
+                                                node: nodeIn,
+                                                severity: 'error',
+                                                message: `页面${nodeTypeName} ${node.name} 赋值页面逻辑内局部变量或输入参数时，系统无法推导类型。`,
+                                            };
+                                            nodeIn.tsErrorDetail = diagnostic;
+                                            diagnostics.push(diagnostic);
+                                        }
+                                        msg = '系统无法推断类型。';
+                                    }
+                                }
+                                if (!nodeIn.tsErrorDetail) {
+                                    const diagnostic = {
+                                        node: nodeIn,
+                                        severity: 'error',
+                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                    };
+                                    nodeIn.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                }
+                                msg = '必须赋值有返回值的内容。';
+                            }
+                        });
+                        if (!msg)
+                            msg = '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
+                        const diagnostic = {
+                            node,
+                            severity: 'error',
+                            message: `${nodeTypeName} ${node.name} ${msg}`,
+                        };
+                        node.tsErrorDetail = diagnostic;
+                        diagnostics.push(diagnostic);
+                    }
+                    const fileSourceCode = self.getNodeCode(fileNode, value);
+                    if (fileSourceCode.includes('|') && fileSourceCode.includes('.metadataTypes.')) {
+                        const typeAnnotation = node.typeAnnotation.toJSON();
+                        yield* self._treeMetadataType2CoreType(typeAnnotation, node.rootNode);
+                        const isDuplicate = yield* self._isDuplicateCoreType(typeAnnotation);
+                        if (isDuplicate) {
+                            const diagnostic = {
+                                node,
+                                severity: 'error',
+                                message: `变量 ${node.name} 类型定义包含相同的数据类型`,
+                            };
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                }
+                else if (node instanceof concepts_1.BindAttribute || node instanceof concepts_1.BindDirective || node instanceof concepts_1.BindStyle) {
+                    if (Array.isArray(node.bindExpressions)) {
+                        const exp = node.bindExpressions.find((bindExpression) => self.hasComponentLogics(bindExpression));
+                        if (exp) {
+                            // const element: any = node.getAncestor('ViewElement');
+                            // const api = config.allNodesAPI[element?.tag];
+                            // const attr = api?.attrs?.find?.((attr) => {
+                            //    return attr.name === node.name;
+                            // });
+                            const map = {
+                                BindAttribute: '属性',
+                                BindDirective: '指令',
+                                BindStyle: '样式属性',
+                            };
+                            // “${attr?.title || node.title || node.name}”
+                            const diagnostic = {
+                                node,
+                                severity: 'error',
+                                message: `${map[node.concept]}表达式不能绑定组件逻辑`,
+                            };
+                            node.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                }
+                else if (node instanceof concepts_1.CallInterface) {
+                    const isAuthInterface = self.hasAuth(node);
+                    const interfaceName = node.calleewholeKey.slice(node.calleewholeKey.lastIndexOf('.') + 1);
+                    if (isAuthInterface) {
+                        const errorMsg = `${interfaceName} 接口有鉴权方式，不支持在前端调用`;
+                        const diagnostic = {
+                            node,
+                            severity: 'error',
+                            message: errorMsg,
+                        };
+                        diagnostics.push(diagnostic);
+                        node.tsErrorDetail = diagnostic;
+                    }
+                }
+                else if (node instanceof concepts_1.Identifier) {
+                    // 变量如果选到了页面，因为ts会找到兄弟的同名变量，所以需要新增报错，通过类型来判断加不加
+                    // https://projectmanage.netease-official.lcap.163yun.com/dashboard/BugDetail?id=2696136968961024
+                    if (node.name && node.__TypeAnnotation?.typeKind === 'reference' && node.__TypeAnnotation?.typeNamespace?.endsWith('views')) {
+                        const errorMsg = `找不到 ${node.name}。`;
+                        const diagnostic = {
+                            node,
+                            severity: 'error',
+                            message: errorMsg,
+                        };
+                        diagnostics.push(diagnostic);
+                        node.tsErrorDetail = diagnostic;
+                    }
+                }
+                else {
+                    self.checkNodeError(node, diagnostics);
+                }
+            });
+        }
+        else if (fileNode instanceof concepts_1.DataSource) {
+            const dataSourceGroup = fileNode.rootNode.configuration?.getGroup('dataSource');
+            if (dataSourceGroup) {
+                const property = dataSourceGroup.getProperty(fileNode.name);
+                if (property && property.values) {
+                    yield* utils.wrapForEachToGenerator(property.values, (propertyValue) => {
+                        if (!propertyValue.value && fileNode.name !== 'defaultDS') {
+                            const diagnostic = {
+                                node: fileNode,
+                                severity: 'error',
+                                message: `数据源配置：数据源${property.name}${propertyValue.env === 'dev' ? '开发环境' : '生产环境'}未配置数据信息`,
+                                // 保留原来的内容方便查询一些问题
+                                originalDiagnostic: {
+                                    fileName: '',
+                                    start: null,
+                                    end: null,
+                                    category: 'error',
+                                    text: `Data Source is not config`,
+                                },
+                            };
+                            diagnostics.push(diagnostic);
+                        }
+                        else if (propertyValue.value) {
+                            const dataSource = fileNode;
+                            // 数据源有连接错误
+                            let envText;
+                            if (propertyValue.env === 'dev') {
+                                if (dataSource.__devConnectError) {
+                                    envText = '开发';
+                                }
+                                else if (dataSource.__devConnectError === false) {
+                                    return;
+                                }
+                            }
+                            else if (propertyValue.env === 'online') {
+                                if (dataSource.__onlineConnectError) {
+                                    envText = '生产';
+                                }
+                                else if (dataSource.__onlineConnectError === false) {
+                                    return;
+                                }
+                            }
+                            // 手动插入报错
+                            if (envText) {
+                                const diagnostic = {
+                                    node: fileNode,
+                                    severity: 'warning',
+                                    message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
+                                    // 保留原来的内容方便查询一些问题
+                                    originalDiagnostic: {
+                                        fileName: '',
+                                        start: null,
+                                        end: null,
+                                        category: 'warning',
+                                        text: `DataSource connection error`,
+                                    },
+                                };
+                                return diagnostics.push(diagnostic);
+                            }
+                        }
+                    });
+                }
+            }
+        }
+        // 加上对实体属性存储类型的校验规则
+        else if (fileNode instanceof concepts_1.Entity) {
+            const entity = fileNode;
+            const dbType = entity.dataSource.dataSourceSqlType;
+            const { origin, properties } = entity || {};
+            if (dbType && !['excel', 'table'].includes(origin) && Array.isArray(properties) && properties.length) {
+                properties.forEach((property) => {
+                    if (property) {
+                        const { typeAnnotation, databaseTypeAnnotation, rules } = property;
+                        const { typeName } = typeAnnotation || {};
+                        const rulesMap = {};
+                        if (Array.isArray(rules)) {
+                            rules.forEach((rule) => {
+                                const match = rule?.match(/^([^()]+)\(([\d\-.]+)\)$/);
+                                if (match) {
+                                    const [, key, value] = match;
+                                    rulesMap[key] = value;
+                                }
+                            });
+                        }
+                        const diagnostic = {
+                            node: property,
+                            severity: 'error',
+                            message: '',
+                        };
+                        const dataBaseTyp = property.currentDataBaseType;
+                        typeAnnotation.tsErrorDetail = null;
+                        if (!dataBaseTyp && databaseTypeAnnotation) {
+                            const { typeName: databaseTypeName } = databaseTypeAnnotation;
+                            const errorMsg = `平台目前暂不支持${dbType}数据库的${databaseTypeName}存储类型`;
+                            diagnostic.message = errorMsg;
+                            const tsErrorDetail = {
+                                severity: 'error',
+                                errorPos: {
+                                    typeName: errorMsg,
+                                },
+                            };
+                            databaseTypeAnnotation.tsErrorDetail = tsErrorDetail;
+                        }
+                        else {
+                            const { options } = dataBaseTyp || {};
+                            if (options) {
+                                if (databaseTypeAnnotation) {
+                                    databaseTypeAnnotation.tsErrorDetail = null;
+                                    const databaseTypeAnnotationErrorDetail = {
+                                        severity: 'error',
+                                        errorPos: {},
+                                    };
+                                    for (const key in options) {
+                                        const option = options[key];
+                                        const { comment, require, min, max } = option || {};
+                                        const databaseTypeArg = databaseTypeAnnotation.arguments?.[key];
+                                        // 如果必填的值没有填，报错
+                                        if (require && !databaseTypeArg && key !== 'scale') {
+                                            diagnostic.message = `${comment}不能为空`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能为空`;
+                                        }
+                                        else if (min && +min > +databaseTypeArg) {
+                                            diagnostic.message = `${comment}不能小于最小值${min}`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能小于最小值${min}`;
+                                        }
+                                        else if (max && +max < +databaseTypeArg) {
+                                            diagnostic.message = `${comment}不能大于最大值${max}`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能大于最大值${max}`;
+                                        }
+                                        if (Object.keys(databaseTypeAnnotationErrorDetail.errorPos).length) {
+                                            databaseTypeAnnotation.tsErrorDetail = databaseTypeAnnotationErrorDetail;
+                                        }
+                                    }
+                                }
+                                const typeAnnotationErrorDetail = {
+                                    severity: 'warning',
+                                    errorPos: {},
+                                };
+                                const precisionOption = options?.precision;
+                                const { default: defaultVal } = precisionOption || {};
+                                const precision = databaseTypeAnnotation ? databaseTypeAnnotation.arguments?.precision : defaultVal;
+                                const ruleScale = typeAnnotation?.ruleMap?.scale;
+                                const scale = ruleScale !== undefined ? `${ruleScale}` : '';
+                                let ensureScale = true;
+                                switch (typeName) {
+                                    case 'String': {
+                                        const defaultVal = options.length?.default;
+                                        const length = databaseTypeAnnotation ? databaseTypeAnnotation.arguments?.length : defaultVal;
+                                        if (length) {
+                                            [
+                                                {
+                                                    key: 'minLength',
+                                                    text: '小',
+                                                },
+                                                {
+                                                    key: 'maxLength',
+                                                    text: '大',
+                                                },
+                                            ].forEach(({ key, text }) => {
+                                                const curLength = rulesMap[key];
+                                                if (+curLength > +length) {
+                                                    const errorMsg = `最${text}长度超出存储长度`;
+                                                    const diag = {
+                                                        node: property,
+                                                        severity: 'warning',
+                                                        message: errorMsg,
+                                                    };
+                                                    diagnostics.push(diag);
+                                                    typeAnnotationErrorDetail.errorPos[key] = errorMsg;
+                                                }
+                                            });
+                                        }
+                                        else if (rulesMap?.maxLength && +dataBaseTyp?.max && +rulesMap.maxLength > +dataBaseTyp.max) {
+                                            // 判断当前 最大长度 是不是比 数据库类型的最大长度 长，超过就报错
+                                            const errorMsg = `最大长度超出存储长度`;
+                                            const diag = {
+                                                node: property,
+                                                severity: 'warning',
+                                                message: errorMsg,
+                                            };
+                                            diagnostics.push(diag);
+                                            typeAnnotationErrorDetail.errorPos.maxLength = errorMsg;
+                                        }
+                                    }
+                                    case 'Long': {
+                                        const { min: ruleMin, max: ruleMax } = dataBaseTyp;
+                                        const minVal = rulesMap.min;
+                                        const maxVal = rulesMap.max;
+                                        // 最大最小值都要校验存储上下限
+                                        [
+                                            {
+                                                key: 'min',
+                                                name: '最小值',
+                                                value: minVal,
+                                            },
+                                            {
+                                                key: 'max',
+                                                name: '最大值',
+                                                value: maxVal,
+                                            },
+                                        ].forEach(({ key, name, value }) => {
+                                            if (ruleMin && value && new decimal_js_1.Decimal(ruleMin).greaterThan(new decimal_js_1.Decimal(value))) {
+                                                // 超出存储下限
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: `${name}超出存储下限${ruleMin}`,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = `${name}超出存储下限`;
+                                            }
+                                            if (ruleMax && value && new decimal_js_1.Decimal(ruleMax).lessThan(new decimal_js_1.Decimal(value))) {
+                                                // 超出存储上限
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: `${name}超出存储上限${ruleMax}`,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = `${name}超出存储上限`;
+                                            }
+                                        });
+                                        break;
+                                    }
+                                    case 'Decimal': {
+                                        if (precisionOption) {
+                                            if (+precision < +scale) {
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'error',
+                                                    message: '',
+                                                };
+                                                const errorMsg = `小数位数必须小于或等于精度${precision}`;
+                                                diag.message = errorMsg;
+                                                diagnostics.push(diag);
+                                                ensureScale = false;
+                                                typeAnnotationErrorDetail.errorPos.scale = errorMsg;
+                                            }
+                                        }
+                                        break;
+                                    }
+                                }
+                                const minVal = rulesMap.min;
+                                const maxVal = rulesMap.max;
+                                // 最 大/小 值不能 大/于 由精度和小数位数 确定的范围
+                                if (precisionOption && ensureScale) {
+                                    const memoryStr = '9'.repeat(+precision);
+                                    // 储存整数部分
+                                    const memoryIntAbsStr = memoryStr.slice(0, +precision - +(scale || '0')) || '0';
+                                    // 储存小数部分
+                                    const memoryScaleStr = memoryStr.slice(0, +(scale || '0'));
+                                    // 储存绝对值
+                                    const memoryAbsVal = memoryIntAbsStr + (memoryScaleStr ? `.${memoryScaleStr}` : '');
+                                    const decimalMemoryAbsVal = new decimal_js_1.Decimal(memoryAbsVal);
+                                    [
+                                        {
+                                            key: 'min',
+                                            text: '小',
+                                            val: minVal,
+                                        },
+                                        {
+                                            key: 'max',
+                                            text: '大',
+                                            val: maxVal,
+                                        },
+                                    ].forEach(({ key, text, val }) => {
+                                        if (val) {
+                                            const decimalVal = new decimal_js_1.Decimal(val);
+                                            // 是否是负数
+                                            const isNegative = decimalVal.isNegative();
+                                            // 填入的值的绝对值是否大于存储绝对值
+                                            if (decimalMemoryAbsVal.lessThan(decimalVal.abs())) {
+                                                const errorMsg = `最${text}值不得${isNegative ? '小' : '大'}于${isNegative ? '-' : ''}${memoryAbsVal}`;
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: errorMsg,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = errorMsg;
+                                            }
+                                        }
+                                    });
+                                }
+                                if (['Long', 'Decimal'].includes(typeName) && !typeAnnotationErrorDetail.errorPos.min) {
+                                    if (minVal && maxVal && new decimal_js_1.Decimal(maxVal).lessThan(minVal)) {
+                                        const errorMsg = '最小值不得大于最大值';
+                                        const diag = {
+                                            node: property,
+                                            severity: 'warning',
+                                            message: errorMsg,
+                                        };
+                                        diagnostics.push(diag);
+                                        typeAnnotationErrorDetail.errorPos.min = errorMsg;
+                                    }
+                                }
+                                if (Object.keys(typeAnnotationErrorDetail.errorPos).length) {
+                                    typeAnnotation.tsErrorDetail = typeAnnotationErrorDetail;
+                                }
+                            }
+                        }
+                        if (diagnostic.message) {
+                            property.__showAdvanced = true;
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                });
+            }
+        }
+        else if (fileNode instanceof concepts_1.Logic || fileNode instanceof concepts_1.OverriddenLogic) {
+            const { isRefedByTrigger, fRefName } = yield this.isRefedByTriggerAndReturnFirstRef(fileNode);
+            if (isRefedByTrigger && !this.isTriggerRule(fileNode)) {
+                const diagnostic = {
+                    node: fileNode,
+                    severity: 'error',
+                    message: `${fileNode.name} 已被Kafka消息订阅配置 ${fRefName} 引用：该逻辑入参只有一个入参，入参类型为string；且不允许存在返回值。否则会导致无法接收Kafka消息`,
+                };
+                diagnostics.push(diagnostic);
+            }
+            yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), function* wrapIterator([node, value]) {
+                if (node instanceof concepts_1.OqlQueryComponent) {
+                    // 自动推导情况
+                    const typeAnnotation = yield* (0, formatTsUtils_1.type2TypeAnnotation)(node.__nodeType);
+                    if (!node.typeAnnotation && typeAnnotation) {
+                        if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
+                            const { typeArguments } = typeAnnotation;
+                            if (typeArguments.length && typeArguments[0].isComplexType()) {
+                                const diagnostic = {
+                                    node,
+                                    severity: 'error',
+                                    message: `SQL查询：返回类型不支持单个复杂类型 ${typeArguments[0].headTitle}。`,
+                                };
+                                node.tsErrorDetail = diagnostic;
+                                diagnostics.push(diagnostic);
+                            }
+                        }
+                    }
+                }
+                else if (node instanceof concepts_1.Return || node instanceof concepts_1.Variable) {
+                    const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+                    if (!node.typeAnnotation && !node.__TypeAnnotation) {
+                        let used = false;
+                        fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
+                            if (!used && nodeIn && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))) {
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                }
+                                catch (err) {
+                                    console.log(err);
+                                }
+                                if (jsCode.startsWith(`${node.name} = `)) {
+                                    used = true;
+                                    if (!nodeIn.tsErrorDetail) {
+                                        const diagnostic = {
+                                            node: nodeIn,
+                                            severity: 'error',
+                                            message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                        };
+                                        nodeIn.tsErrorDetail = diagnostic;
+                                        diagnostics.push(diagnostic);
+                                    }
+                                }
+                            }
+                        });
+                        const msg = used ? '必须赋值有返回值的内容。' : '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
+                        const diagnostic = {
+                            node,
+                            severity: 'error',
+                            message: `${nodeTypeName} ${node.name} ${msg}`,
+                        };
+                        node.__aStructureError = diagnostic;
+                        diagnostics.push(diagnostic);
+                    }
+                    else {
+                        node.__aStructureError = null;
+                    }
+                    const fileSourceCode = self.getNodeCode(fileNode, value);
+                    if (fileSourceCode.includes('|') && fileSourceCode.includes('.metadataTypes.')) {
+                        const typeAnnotation = node.typeAnnotation.toJSON();
+                        yield* self._treeMetadataType2CoreType(typeAnnotation, node.rootNode);
+                        const isDuplicate = yield* self._isDuplicateCoreType(typeAnnotation);
+                        if (isDuplicate) {
+                            const diagnostic = {
+                                node,
+                                severity: 'error',
+                                message: `${nodeTypeName} ${node.name} 类型定义包含相同的数据类型`,
+                            };
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                }
+                else if (node instanceof concepts_1.Param) {
+                    const fileSourceCode = self.getNodeCode(fileNode, value);
+                    if (fileSourceCode.includes('|') && fileSourceCode.includes('.metadataTypes.')) {
+                        const typeAnnotation = node.typeAnnotation.toJSON();
+                        yield* self._treeMetadataType2CoreType(typeAnnotation, node.rootNode);
+                        const isDuplicate = yield* self._isDuplicateCoreType(typeAnnotation);
+                        if (isDuplicate) {
+                            const diagnostic = {
+                                node,
+                                severity: 'error',
+                                message: `输入参数 ${node.name} 类型定义包含相同的数据类型`,
+                            };
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                }
+                self.checkNodeError(node, diagnostics);
+            });
+        }
+        else if (fileNode instanceof concepts_1.Process) {
+            yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), ([node, value]) => {
+                this.checkNodeError(node, diagnostics);
+            });
+        }
+        else if (fileNode instanceof concepts_1.Connection) {
+            const connectorPropertyNames = NaslServer_1.getPropertyNames(fileNode);
+            const connectionPropertyNames = NaslServer_1.getPropertyNames(fileNode?.connector);
+            const diagnostic = {
+                node: fileNode,
+                severity: 'error',
+                message: `连接器 ${fileNode.name} 参数配置有更新`,
+                // 保留原来的内容方便查询一些问题
+                originalDiagnostic: {
+                    fileName: '',
+                    start: null,
+                    end: null,
+                    category: 'error',
+                    text: `Connection configuration is empty`,
+                },
+            };
+            // Connector Connection 配置项是否相同
+            const isSameConfig = connectorPropertyNames.filter((x) => !connectionPropertyNames.includes(x)).length === 0;
+            // Connection 配置项是否有空值
+            const hasEmptyConfig = (c) => {
+                return c.properties.findIndex((configProperty) => {
+                    return configProperty.values.find((configPropertyValue) => {
+                        return configPropertyValue.value === '';
+                    });
+                }) > -1;
+            };
+            if (connectorPropertyNames.length !== connectionPropertyNames.length) {
+                diagnostics.push(diagnostic);
+            }
+            else if (!isSameConfig) {
+                diagnostics.push(diagnostic);
+            }
+            else if (hasEmptyConfig(fileNode)) {
+                diagnostics.push(diagnostic);
+            }
+        }
+        else if (fileNode instanceof concepts_1.MetadataType) {
+            fileNode?.sourceMap.forEach((value, node) => {
+                const rulesMap = {};
+                const { rules, typeAnnotation } = node;
+                if (Array.isArray(rules)) {
+                    rules.forEach((rule) => {
+                        if (`${rule?.toUI()}` == 'undefined' || `${rule.toUI()}` == 'null')
+                            return;
+                        const match = rule.toUI?.().match(/^([^()]+)\(([\d\-.]+)\)$/);
+                        if (match) {
+                            const [, key, value] = match;
+                            rulesMap[key] = value;
+                        }
+                    });
+                }
+                const { typeName } = typeAnnotation || {};
+                const typeAnnotationErrorDetail = {
+                    severity: 'warning',
+                    errorPos: {},
+                };
+                const minVal = rulesMap.min;
+                const maxVal = rulesMap.max;
+                if (['Long', 'Decimal'].includes(typeName) && !typeAnnotationErrorDetail.errorPos.min) {
+                    if (minVal && maxVal) {
+                        if (new decimal_js_1.Decimal(maxVal).lessThan(minVal)) {
+                            const errorMsg = '最小值不得大于最大值';
+                            const diag = {
+                                node,
+                                severity: 'warning',
+                                message: errorMsg,
+                            };
+                            diagnostics.push(diag);
+                            typeAnnotationErrorDetail.errorPos.min = errorMsg;
+                        }
+                        else {
+                            typeAnnotationErrorDetail.errorPos = {};
+                            node.typeAnnotation.tsErrorDetail = null;
+                        }
+                    }
+                }
+                if (Object.keys(typeAnnotationErrorDetail.errorPos).length) {
+                    typeAnnotation.tsErrorDetail = typeAnnotationErrorDetail;
+                }
+            });
+        }
+        return diagnostics;
+    }
+    *_treeMetadataType2CoreType(type, app) {
+        const self = this;
+        yield* utils.wrapForEachToGenerator(type.typeArguments ?? [], function* wrapForEach(item) {
+            if (item.typeNamespace?.endsWith('.metadataTypes')) {
+                let originType = {};
+                if (item.typeNamespace === 'app.metadataTypes') {
+                    originType = app.metadataTypes?.find((metadataType) => metadataType.name === item.typeName)?.typeAnnotation;
+                }
+                else if (item.typeNamespace?.startsWith('extensions.') && item.typeNamespace?.endsWith('.metadataTypes')) {
+                    const dependencyName = item.typeNamespace.replace('extensions.', '').replace('.metadataTypes', '');
+                    originType = app.dependencies?.find((dependency) => dependency.name === dependencyName)?.metadataTypes?.find((ele) => ele.name === item.typeName)?.typeAnnotation ?? {};
+                }
+                item.typeKind = 'primitive';
+                item.typeNamespace = 'nasl.core';
+                item.typeName = originType?.typeName;
+            }
+            yield* utils.wrapForEachToGenerator(type.typeArguments ?? [], function* wrapForEach2(ele) {
+                yield* self._treeMetadataType2CoreType(ele, app);
+            });
+        });
+    }
+    *_isDuplicateCoreType(type) {
+        const argsStringList = type.typeArguments?.map((item) => JSON.stringify(item)) || [];
+        const setList = Array.from(new Set(argsStringList));
+        if (argsStringList.length > setList.length) {
+            return true;
+        }
+        let flag = false;
+        for (const ele of type.typeArguments ?? []) {
+            const subFlag = yield* this._isDuplicateCoreType(ele);
+            if (subFlag) {
+                flag = true;
+            }
+        }
+        return flag;
+    }
+    checkNodeError(node, diagnostics) {
+        if (!node)
+            return;
+        // 如果节点是match的看看节点里是不是有重复的
+        if (node instanceof concepts_1.Match) {
+            const typeMap = {};
+            if (node.expression?.__TypeAnnotation) {
+                const { typeName, typeNamespace } = node.expression.__TypeAnnotation;
+                if (typeName === 'Union' || typeName === 'Boolean' || typeNamespace?.endsWith('enums')) {
+                    node.cases.forEach((item) => {
+                        if (Array.isArray(item.patterns)) {
+                            item.patterns.forEach((pattern) => {
+                                if (pattern instanceof concepts_1.TypeAnnotation) {
+                                    if (typeMap[pattern.sortedTypeKey]) {
+                                        typeMap[pattern.sortedTypeKey].push(pattern);
+                                    }
+                                    else {
+                                        typeMap[pattern.sortedTypeKey] = [pattern];
+                                    }
+                                }
+                                else if (pattern instanceof concepts_1.MemberExpression) {
+                                    if (pattern.completeName && pattern.object?.namespace?.endsWith('enums')) {
+                                        const onlyKey = pattern.completeName;
+                                        if (typeMap[onlyKey]) {
+                                            typeMap[onlyKey].push(pattern);
+                                        }
+                                        else {
+                                            typeMap[onlyKey] = [pattern];
+                                        }
+                                    }
+                                }
+                                else if (pattern instanceof concepts_1.BooleanLiteral) {
+                                    const onlyKey = pattern.concept + pattern.value;
+                                    if (typeMap[onlyKey]) {
+                                        typeMap[onlyKey].push(pattern);
+                                    }
+                                    else {
+                                        typeMap[onlyKey] = [pattern];
+                                    }
+                                }
+                            });
+                        }
+                    });
+                }
+                Object.keys(typeMap).forEach((item) => {
+                    if (typeMap[item].length > 1) {
+                        typeMap[item].forEach((nodeItem) => {
+                            const diagnostic = {
+                                node: nodeItem,
+                                severity: 'error',
+                                message: '匹配：重复添加类型',
+                                titleTip: '重复添加此项',
+                            };
+                            nodeItem.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        });
+                    }
+                });
+            }
+            else if (node.expression) {
+                const diagnostic = {
+                    node: node.expression,
+                    severity: 'error',
+                    message: '类型不匹配，传入类型：void',
+                };
+                node.expression.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
+        if (node instanceof concepts_1.MatchCase && node.getAncestor('Match')?.isExpression && node.body.length === 0) {
+            // 如果不是其他就标红
+            if (node?.getIndexOfParent() !== (node.getAncestor('Match')?.cases?.length || 0) - 1) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配分支：返回内容不能为空',
+                    titleTip: '返回内容不能为空',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
+        // 如果节点是match的patterns 里的
+        if (node?.parentKey === 'patterns' && node.parentNode instanceof concepts_1.MatchCase) {
+            const matchNode = node.getAncestor('Match');
+            const matchExpressionType = matchNode?.expression?.__TypeAnnotation;
+            // 判断union类型是不是重复
+            // 先使用ts原始的报错，这个先注释掉
+            if (node instanceof concepts_1.TypeAnnotation && matchExpressionType?.typeKind === 'union') {
+                const haveType = matchExpressionType?.typeArguments.find((item) => item.sortedTypeKey === node.sortedTypeKey);
+                if (!haveType) {
+                    const diagnostic = {
+                        node,
+                        severity: 'error',
+                        message: '匹配：选择类型不存在',
+                        titleTip: '该类型已被删除',
+                    };
+                    node.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                }
+                // 如果TypeAnnotation 还存在，但是本身已经不是union类型，就是已经从union换别的类型了就都要报错
+            }
+            else if (node instanceof concepts_1.TypeAnnotation && matchExpressionType?.typeKind !== 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择类型不存在',
+                    titleTip: '该类型已被删除',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+                // 如果可枚举变量的 ，变量 还存在，但是本身已经是union类型，就是已经从别的类型 换了union就都要报错
+            }
+            else if (!(node instanceof concepts_1.TypeAnnotation) && matchExpressionType?.typeKind === 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择值不存在',
+                    titleTip: '该值无法匹配，请重新选择类型',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+            if (node.tsErrorDetail) {
+                // 如果父级是枚举，而且子集选的是变量，就提示枚举值已被删除
+                if (matchExpressionType?.typeNamespace?.includes('enums') && node instanceof concepts_1.MemberExpression) {
+                    node.tsErrorDetail.titleTip = '该枚举值已被删除';
+                }
+                else if (!node.tsErrorDetail.titleTip) {
+                    node.tsErrorDetail.titleTip = '该值已被删除';
+                }
+            }
+        }
+        // 如果forEach 中的each的内容是union类型就要提示报错
+        if (node?.parentKey === 'each' && node?.__TypeAnnotation?.typeKind === 'union') {
+            const diagnostic = {
+                node,
+                severity: 'error',
+                message: 'ForEach：参数类型不一致！传入类型：联合类型。接受类型：List类型。',
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
+        if (node instanceof concepts_1.ForEachStatement && !node.end && node.each) {
+            if (!['List'].includes(node.each.__TypeAnnotation?.typeName)) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: `ForEach：循环列表：参数类型不匹配！结束值自动推导失败。`,
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
+        if ((node instanceof concepts_1.OqlQueryComponent || node instanceof concepts_1.SqlQueryComponent) && node.parentNode instanceof concepts_1.Paginate && node.parentKey === 'list' && node.codeSourceMap && node.codeSourceMap.containsLimit) {
+            const diagnostic = {
+                node,
+                severity: 'error',
+                message: `SQL 查询已包含分页，请去除 SQL 查询中的 LIMIT 语句。`,
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
+        /**
+         * 如果节点是内置函数
+         * 穷举在线上的情况，不在线上就void报错， callinterface 因为原来有报错，所以就忽略掉
+         * && 他在父级中，不在body
+         * && 也不再 if的线上
+         * && 也不再 switch的线上consequent
+         * && 也不再草稿区域
+         * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
+         * && 而且也没有类型，就说明在槽位里，就需要报错
+         *
+         * 如果是内置函数而且也不在线上
+         * 只有下面自己实现的函数才会报错
+         */
+        if (node instanceof concepts_1.CallFunction &&
+            node.parentKey !== 'body' &&
+            node.parentKey !== 'alternate' &&
+            node.parentKey !== 'playground' &&
+            node.parentKey !== 'consequent' &&
+            node.parentNode?.parentNode?.concept !== 'CallInterface' &&
+            node.parentNode.concept !== 'Block' &&
+            !node.__TypeAnnotation) {
+            let showErr = false;
+            if (node.parentNode?.parentNode?.concept === 'CallLogic') {
+                // calllogic 中别的类型会强校验，但是内置函数，不会强制校验，下面这几个其实是走的内置函数的实现，所以需要手动增加一下校验
+                const { calleeNamespace, calleeName } = node.parentNode.parentNode;
+                if ((calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') &&
+                    (['showMessage', 'consoleLog', 'jsonDeserialize',
+                        'jsonSerialize'].includes(calleeName))) {
+                    showErr = true;
+                }
+            }
+            else {
+                showErr = true;
+            }
+            if (showErr) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: `类型不匹配，传入类型：void`,
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
+        // newMap key或者value没填都要有报错
+        if (node instanceof concepts_1.NewMap) {
+            // 如果一项没有key 或者没有 value 就报错
+            const findFlag = node.keys?.some((key, index) => !key || !node.values?.[index]);
+            if (findFlag) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: `新建Map的key和value应该都必填`,
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
+        // 赋值语句左右list 和 map等可以 必须都一样
+        if (node instanceof concepts_1.Assignment && !node.tsErrorDetail) {
+            const leftType = node.left?.__TypeAnnotation || {};
+            const rightType = node.right?.__TypeAnnotation || {};
+            // 如果左边节点是 泛型，而且 左边泛型的名字 和 右边一样， 而且是list 或者map 就强制报错
+            // 而且右边原来没有报错
+            if (leftType.typeKind === 'generic' &&
+                leftType.typeKind === rightType.typeKind &&
+                leftType.typeName === rightType.typeName &&
+                ['Map', 'List'].includes(leftType.typeName)) {
+                if (!node.right.tsErrorDetail && leftType.sortedTypeKey !== rightType.sortedTypeKey) {
+                    const excludeList = [
+                        'nasl.collection.List<nasl.core.String>',
+                        'nasl.collection.List<nasl.core.Email>',
+                        'nasl.collection.Map<nasl.core.String, nasl.core.String>',
+                        'nasl.collection.Map<nasl.core.String, nasl.core.Email>',
+                    ];
+                    const excludeList2 = ['nasl.collection.List<>', 'nasl.collection.List<T>'];
+                    // 先特殊处理等 类型合并后就可以去掉了
+                    if (excludeList.includes(leftType.sortedTypeKey) && excludeList.includes(rightType.sortedTypeKey)) {
+                        return null;
+                    }
+                    if (excludeList2.includes(leftType.sortedTypeKey) || excludeList2.includes(rightType.sortedTypeKey)) {
+                        return null;
+                    }
+                    const diagnostic = {
+                        node: node.right,
+                        severity: 'error',
+                        message: `左右参数类型不一致！左边类型：${leftType.typeChineseTitle}，右边类型：${rightType.typeChineseTitle}。`,
+                    };
+                    node.right.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                }
+            }
+        }
+    }
+    /**
+     * 判断当前CallInterface 对应的 Interface 是否含有鉴权方式
+     */
+    hasAuth(node) {
+        const tInterface = (0, utils_2.getNodeByNodeCallee)(node.rootNode, node.calleewholeKey);
+        return tInterface instanceof concepts_1.AuthInterface;
+    }
+    /* 接口导入查找 */
+    *existStructureFix(semanticDiagnostics, node, that) {
+        let module;
+        yield* utils.wrapForEachToGenerator(semanticDiagnostics, (diag) => {
+            const minRange = this._findMinRange(diag, node);
+            if (diag.text?.includes('has no exported member named')) {
+                if (minRange.node instanceof concepts_1.Logic) {
+                    return null;
+                }
+                const typeAnnotation = minRange.node instanceof concepts_1.TypeAnnotation ? minRange.node.upperNode.typeAnnotation : minRange.node.typeAnnotation;
+                const regNamespace = /<(\S*)>/;
+                const typeKey = (typeAnnotation?.typeKey.match(regNamespace) && typeAnnotation?.typeKey.match(regNamespace)[1]) || typeAnnotation?.typeKey;
+                const typeKeyArr = typeKey.split('.');
+                if (typeKeyArr[0] === 'apis') {
+                    const structureName = typeKeyArr[3];
+                    const moduleName = typeKeyArr[1];
+                    const { app } = typeAnnotation.upperNode;
+                    if (!app) {
+                        return null;
+                    }
+                    module = app.interfaceDependencies?.find((item) => item.name === moduleName);
+                    let existStructure = module?.structures?.find((item) => item.name.toUpperCase() === structureName.toUpperCase());
+                    if (!existStructure) {
+                        const realName = structureName.replace(/\d*$/, (m) => String(''));
+                        existStructure = module?.structures?.find((item) => item.name.toUpperCase() === realName.toUpperCase());
+                    }
+                    if (existStructure) {
+                        const editTypeAnnotation = JSON.parse(JSON.stringify(typeAnnotation?.toJSON() ?? {}).replace(new RegExp(structureName, 'g'), existStructure.name));
+                        actionArr.push({ target: typeAnnotation.parentNode, typeannotation: editTypeAnnotation });
+                    }
+                }
+                return null;
+            }
+        });
+        if (actionArr.length) {
+            if (timer)
+                return;
+            timer = window.setTimeout(() => {
+                const { app } = actionArr[0].target;
+                app.emit('collect:start', {
+                    actionMsg: '设置导入接口数据类型错误',
+                });
+                module.isAdd && module.setIsAdd(false);
+                actionArr.forEach((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 处理后的结果
+     */
+    *_resolveDiagnosticWithGenerator(diagnostic, fileNode, record) {
+        // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
+        if ((fileNode.module || fileNode.connector) && !(fileNode instanceof concepts_1.ConfigProperty)) {
+            return;
+        }
+        if (fileNode.concept === 'OverriddenLogic' && diagnostic.text === `'__LogicEmpty' is declared but its value is never read.`) {
+            return;
+        }
+        const minRange = yield* this._findMinRangeWithGenerator(diagnostic, fileNode);
+        const tsErrorDetail = {
+            severity: diagnostic.category === 'error' ? 'error' : 'warning',
+            message: (0, translator_2.translateDiagnosticMessage)(diagnostic.text),
+            // 保留原来的内容方便查询一些问题
+            originalDiagnostic: diagnostic,
+        };
+        yield;
+        let result;
+        if (minRange) {
+            // 节点的error要置为true
+            result = (0, translator_2.naslNodeTranslateMessage)(minRange, tsErrorDetail);
+            yield;
+        }
+        else {
+            // 没找到节点， 先把问题暴露出来
+            result = tsErrorDetail;
+        }
+        if (result) {
+            result.id = record.filePath + (result ? JSON.stringify({ start: result.originalDiagnostic.start, end: result.originalDiagnostic.end }) : '');
+        }
+        return result;
+    }
+    /**
+     * 查找节点
+     *
+     * @description 生成器原型函数
+     */
+    *_findMinRangeWithGenerator(diagnostic, fileNode) {
+        let minRange;
+        const { sourceMap } = fileNode;
+        // 是否找到了行内准确的，是的话，就不走多行的
+        let haveLineNode = false;
+        for (const [node, item] of sourceMap.entries()) {
+            /**
+             * 当前内容的开始行 <= 诊断开始的行 &&
+             * 当前内容的结束行 >= 诊断结束的行
+             */
+            if ((0, translator_1.lsp2tspNumber)(item.start.line) <= diagnostic.start.line && (0, translator_1.lsp2tspNumber)(item.end.line) >= diagnostic.end.line) {
+                // 如果找到某一行
+                if ((0, translator_1.lsp2tspNumber)(item.start.line) === diagnostic.start.line && (0, translator_1.lsp2tspNumber)(item.end.line) === diagnostic.end.line) {
+                    // 在行的范围但是又不在列的范围，不用给默认值，给了反而不对，
+                    // 需要在列的范围内
+                    if ((0, translator_1.lsp2tspNumber)(item.start.character) <= diagnostic.start.offset &&
+                        (0, translator_1.lsp2tspNumber)(item.end.character) >= diagnostic.end.offset) {
+                        // 比列更靠近 ，满足条件且长度更短
+                        // 如果先走到下面有一个默认值了就像在if for里面有个表达式
+                        // if for的内容也是包括当前的所以会重新赋值
+                        if (!minRange || (item.end.offset - item.start.offset) < (minRange.item.end.offset - minRange.item.start.offset)) {
+                            minRange = { item, node };
+                            haveLineNode = true;
+                        }
+                    }
+                }
+                else {
+                    // 没有节点 或者 行差比较小比已有的小就可以
+                    // 一般出现在一大块上，多半是if for 等等没有参数
+                    if (!minRange) {
+                        minRange = { node, item };
+                    }
+                    else if (!haveLineNode) {
+                        if ((0, translator_1.lsp2tspNumber)(item.start.line) === diagnostic.start.line &&
+                            diagnostic.start.offset >= (0, translator_1.lsp2tspNumber)(item.start.character)) {
+                            // 如果当前遍历的内容的行和列都 小于之前的， 而且是有效的
+                            // 如果两个内容位置行数是一样的，就比较下找到内容的位置信息
+                            // 找到的内容的开始位置， 要大于申明内容开始的位置，要不就不包含在内了
+                            if (diagnostic.start.offset - item.start.character <= diagnostic.start.offset - minRange.item.start.character) {
+                                minRange = { node, item };
+                            }
+                            else if (diagnostic.start.offset < (0, translator_1.lsp2tspNumber)(minRange.item.start.character)) {
+                                minRange = { node, item };
+                            }
+                        }
+                        else if (item.end.line - item.start.line <= minRange.item.end.line - minRange.item.start.line) {
+                            // 行都一致 ，比较列
+                            if (minRange.item.start.line === item.start.line && minRange.item.end.line === item.end.line) {
+                                // 如果两个起始和结束的行都一样，那么就比较开始列， 要比原来大，说明更精准
+                                if (item.start.character > minRange.item.start.character) {
+                                    minRange = { node, item };
+                                }
+                            }
+                            else {
+                                minRange = { node, item };
+                            }
+                        }
+                    }
+                }
+            }
+            yield;
+        }
+        if (!minRange) {
+            if (fileNode instanceof concepts_1.View || fileNode instanceof concepts_1.BusinessComponent) {
+                return { node: fileNode, item: sourceMap.get(fileNode) };
+            }
+            if (process.env.NODE_ENV === 'development') {
+                console.log(minRange, '需要特殊看下，为什么没找到内容-------------');
+            }
+        }
+        return minRange;
+    }
+    /**
+     * 查找节点
+     *
+     * @description 同步模式
+     */
+    _findMinRange(...args) {
+        return utils.runGeneratorSync(this._findMinRangeWithGenerator(...args));
+    }
+    /**
+     * 查看当前节点是不是有引用
+     * @param node 节点
+     * @returns 查找到的数组
+     */
+    async _isHaveRef(node) {
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        let refsList = [];
+        /**
+         * 未完成创建的节点 ，或者异常情况 可能找不到节点
+         */
+        if (currentSource) {
+            const newRefs = await this.references({
+                file: fileNode.getEmbeddedFilePath(),
+                line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character),
+            });
+            refsList = [...newRefs.refs];
+        }
+        else if (node instanceof concepts_1.Module && !(node instanceof concepts_1.Connector)) {
+            const lists = node.logics || node.structures || node.enums;
+            const moduleName = fileNode.getEmbeddedFilePath();
+            if (lists.length) {
+                const item = lists[0];
+                const { fileNode } = this.getCurrentSource(item);
+                if (fileNode) {
+                    const newRefs = await this.references({
+                        file: fileNode.getEmbeddedFilePath(),
+                        line: 1,
+                        offset: 22, // 固定的位置，module的位置信息
+                    });
+                    refsList = newRefs.refs.filter((item) => !item.file.startsWith(moduleName));
+                    // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
+                    refsList.unshift(newRefs.refs[0]);
+                }
+            }
+        }
+        else if (node instanceof concepts_1.Connector) {
+            // Conenctor 虽为 Module 的子类，但是具体引用逻辑与Module 并不一致，因此这边单独处理
+            // 由于 在与后端定义 Connector Namespace 前缀时， Logics 相关定义为 connector,
+            // 其余定义为 extension, 因此这边查找引用时，需要分别查找并去重复
+            // 这里选择 logic 与 interface 作为 查找源，因为一个 Connector 必定至少含有一个 logic 和 interface
+            const logicList = node.namespaces.find((ns) => ns.logics.length > 0)?.logics || [];
+            const interfaceList = node.interfaces;
+            const moduleName = fileNode.getEmbeddedFilePath();
+            const appName = node.rootNode.name; // 获取rootNode的name，用于过滤引用
+            if (logicList.length) {
+                const item = logicList[0];
+                const { fileNode } = this.getCurrentSource(item);
+                if (fileNode) {
+                    const newRefs = await this.references({
+                        file: fileNode.getEmbeddedFilePath(),
+                        line: 1,
+                        offset: 21, // 固定的位置， connector 前缀下 Connector 的位置信息
+                    });
+                    refsList = [...newRefs.refs];
+                }
+            }
+            if (interfaceList.length) {
+                const item = interfaceList[0];
+                const { fileNode } = this.getCurrentSource(item);
+                if (fileNode) {
+                    const newRefs = await this.references({
+                        file: fileNode.getEmbeddedFilePath(),
+                        line: 1,
+                        offset: 22, // 固定的位置， extension 前缀下 Connector 的位置信息
+                    });
+                    refsList = [...refsList, ...newRefs.refs];
+                }
+            }
+            // 根据 moduleName 中是否存在 dependencies 来判断是否为稳定态的Connector
+            const isStable = moduleName.includes(`/embedded/${appName}/dependencies`);
+            // 根据 item 的 file 去重
+            refsList = refsList.filter((item, index, arr) => {
+                const tempStable = item.file.includes(`/embedded/${appName}/dependencies`); // 约定
+                const isGlobalLogic = item.file.includes(`/embedded/${appName}/logics`); // 约定
+                // 关于 isGlobalLogic 单独判断的说明：
+                // 全局逻辑与Connector 有直接关联的只有两种情况
+                // 1. 全局逻辑通过 CallConnector 调用 Connector 中的方法，此时被 logicList 处查找的引用所检索
+                // 2. 全局逻辑中参类型赋值为 Connector 中某一 structure ，此时被 interfaceList 处查找的引用所检索
+                // 综上所述，检索到的全局逻辑相关一定是唯一的，且不重复的
+                return isGlobalLogic || (isStable ? tempStable : !tempStable); // 稳定态的Connector 只能引用稳定态的Connector
+            });
+        }
+        // 如果是DataSource就需要在单独，查一边来修改名字
+        if (node instanceof concepts_1.DataSource) {
+            // 过滤一把不需要改的信息
+            refsList = refsList.filter((item) => {
+                const dataSourceFile = fileNode.getEmbeddedFilePath();
+                const entityFilePrefix = dataSourceFile.replace('.ts', '');
+                /**
+                 * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
+                 * 所以全部过滤掉了,
+                 * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了11个函数之外的引用
+                 * 所以底部内容是11个函数,所以这里就 用entity的行数 减去11个函数的行数,然后其余的在进行处理
+                 * 进行过滤
+                 */
+                // 不要数据源下面的实体里的引用 ,保留原始的节点内容
+                let flag = false;
+                if (item.file.includes(entityFilePrefix)) {
+                    const entity = this.file2NodeMap.get(item.file);
+                    const { currentSource } = this.getCurrentSource(entity);
+                    // 42 11个函数的总行数
+                    if (item.end.line < currentSource.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((item) => fileNode.getEmbeddedFilePath() !== item.file || item.isDefinition === true);
+            // 防止死循环
+            const forRefsList = [...refsList];
+            for (let i = 0; i < forRefsList.length; i++) {
+                const refItem = forRefsList[i];
+                if (refItem.lineText?.includes('new nasl.langUtil.Collection')) {
+                    try {
+                        const fileNode = this.file2NodeMap.get(refItem.file);
+                        if (!fileNode)
+                            return;
+                        const minRange = this._findMinRange(refItem, fileNode);
+                        if (minRange.node && (minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression)) {
+                            const callQueryComponent = minRange.node.getAncestor('CallQueryComponent');
+                            let callQueryComponentTypeAnnotation;
+                            callQueryComponent.logic.sourceMap.forEach((value, key) => {
+                                if (key.concept === 'TypeAnnotation' && key.parentNode === callQueryComponent) {
+                                    callQueryComponentTypeAnnotation = key;
+                                }
+                            });
+                            const { currentSource: qcTypeAnnotationCurrentSource, fileNode: qcTypeCurrentFileNode } = callQueryComponentTypeAnnotation.getCurrentSource();
+                            const { currentSource: logicCurrentSource, fileNode: logicCurrentFileNode } = fileNode.getCurrentSource();
+                            const aggregateLength = callQueryComponent.select.selectAggregateElements.filter((item) => item.aggregateName && item.asName).length;
+                            const groupByLength = callQueryComponent.groupBy.filter((item) => item.groupElement?.propertyName && item.groupElement.asName).length;
+                            if (!groupByLength && !aggregateLength && callQueryComponentTypeAnnotation.typeKind === 'anonymousStructure') {
+                                // 拿到 List 的泛型（匿名数据结构）的所有属性
+                                const { properties } = callQueryComponentTypeAnnotation.properties[0].typeAnnotation.typeArguments[0];
+                                const targetProperty = properties.find((p) => p.name === utils.firstLowerCase(node.name));
+                                if (!targetProperty) {
+                                    continue;
+                                }
+                                const { currentSource: propertyTypeCurrentSource } = targetProperty.typeAnnotation.getCurrentSource();
+                                // 减去 ": " 2个字符、减去属性名长度
+                                const propertyCharacter = propertyTypeCurrentSource.start.character - 2 - targetProperty.name.length;
+                                const propertyOffset = propertyCharacter - qcTypeAnnotationCurrentSource.start.character;
+                                const qcTypeCurrentFilePath = qcTypeCurrentFileNode.getEmbeddedFilePath();
+                                const qcTypeAnnotationCurrentCode = this.getNodeCode(qcTypeCurrentFileNode, qcTypeAnnotationCurrentSource);
+                                const logicCurrentCode = this.getNodeCode(qcTypeCurrentFileNode, logicCurrentSource);
+                                const qcTypeAnnotationOffset = logicCurrentCode.indexOf(qcTypeAnnotationCurrentCode);
+                                const declarationCodeArr = logicCurrentCode.slice(0, qcTypeAnnotationOffset).split('\n');
+                                const line = declarationCodeArr.length - 1;
+                                const character = declarationCodeArr[declarationCodeArr.length - 1].length;
+                                // eslint-disable-next-line no-await-in-loop
+                                const newRefs = await this.references({
+                                    file: qcTypeCurrentFilePath,
+                                    line: line + 2,
+                                    offset: character + 1 + propertyOffset,
+                                });
+                                refsList.push(...newRefs.refs);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        console.error('naslServer实体引用', e);
+                    }
+                }
+            }
+            // 不再当前文件里
+            // 或者在当前列表但是位置小于entity的结束位置
+        }
+        if (node instanceof concepts_1.Return) {
+            // 过滤一下最后出去的值
+            refsList = refsList.filter((item) => !item.lineText.includes('return '));
+        }
+        // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
+        if (node instanceof concepts_1.Param && node.parentNode instanceof concepts_1.Logic && node.parentKey !== 'virtualParams') {
+            const logicNode = node.parentNode;
+            const { currentSource } = this.getCurrentSource(logicNode);
+            const parentRefs = await this.references({
+                file: fileNode.getEmbeddedFilePath(),
+                line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character),
+            });
+            // console.log(parentRefs.refs)
+            refsList = [...refsList, ...parentRefs.refs];
+        }
+        // 如果是参数修改, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
+        if (node instanceof concepts_1.Param && (node.parentNode instanceof concepts_1.View || node.parentNode instanceof concepts_1.Process)) {
+            const viewNode = node.parentNode;
+            const { currentSource, fileNode } = this.getCurrentSource(viewNode);
+            const code = this.getNodeCode(fileNode, currentSource);
+            const viewIndex = code.indexOf(' {');
+            const viewRefs = await this.references({
+                file: fileNode.getEmbeddedFilePath(),
+                line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character + viewIndex),
+            });
+            let filterViewRefs = [];
+            if (node.parentNode instanceof concepts_1.View) {
+                filterViewRefs = viewRefs.refs.filter((item) => item.lineText.includes('.$destination('));
+            }
+            else {
+                // 如果是参数修改, 就需要把Process的引用查找出来
+                filterViewRefs = viewRefs.refs.filter((item) => item.lineText.includes('.launch('));
+            }
+            refsList = [...refsList, ...filterViewRefs];
+        }
+        /**
+         * 暂时不要了， 因为生成的结构发生了变化
+         * view 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
+         * 找到第一个 { 之前的变量 进行修改
+         * 如果是VIew的查找，比较特殊，他查的是当前抛出的 {} 大括号前的
+         * 最后一个，因为生成的规则不一样
+         */
+        // if (node instanceof View) {
+        //     const code = currentSource.code;
+        //     const viewIndex = code.indexOf(' {');
+        //     const viewRefs = await naslServer.references({
+        //         file: (fileNode as FileNode).getEmbeddedFilePath(),
+        //         line: lsp2tspNumber(currentSource.start.line),
+        //         offset: lsp2tspNumber(currentSource.start.character + viewIndex),
+        //     });
+        //     refsList = [...viewRefs.refs];
+        // }
+        /**
+         * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
+         */
+        if (node instanceof concepts_1.ViewElement) {
+            if (currentSource) {
+                const code = this.getNodeCode(fileNode, currentSource);
+                const prefix = '__elements.';
+                const prefixIndex = code.indexOf(prefix) !== -1 ? code.indexOf(prefix) : 0;
+                const methodsNameIndex = prefixIndex + prefix.length;
+                const methods = await this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character + methodsNameIndex),
+                });
+                const methodRefs = [];
+                methods.refs.forEach((item) => {
+                    // 定义里的格式，在删除的时候留下来占位
+                    // 重命名的时候会过滤
+                    // 这里只过滤 __elements.button = new nasl.ui.Button<any>这种格式
+                    // 处理声明组件名可能重复的问题， 查找引用不提示
+                    const find = methodRefs.find((findItem) => item.lineText === findItem.lineText && item.lineText.includes(': nasl.ui.'));
+                    if (!find) {
+                        methodRefs.push(item);
+                    }
+                });
+                refsList = [...methodRefs];
+            }
+        }
+        if (node instanceof concepts_1.Process) {
+            if (currentSource) {
+                const code = this.getNodeCode(fileNode, currentSource);
+                const prefix = '__ProcessIdentification__';
+                let positions = [];
+                let pos = code.indexOf(prefix);
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                }
+                positions.shift();
+                // 拿到标识下定义的const process = {...}
+                positions = positions.map((position) => code.indexOf('const', position + prefix.length));
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        if ((node instanceof concepts_1.Param || node instanceof concepts_1.Return) && node.parentNode instanceof concepts_1.Process) {
+            const { currentSource, fileNode } = this.getCurrentSource(node.parentNode);
+            if (currentSource) {
+                const code = this.getNodeCode(fileNode, currentSource);
+                const prefix = '__ProcessIdentification__';
+                const positions = [];
+                let pos = code.indexOf(prefix);
+                pos = code.indexOf(node.name, pos + prefix.length);
+                // pos === -1：两种情况：
+                // 1、找到最后一个节点了，继续找找不下去了。
+                // 2、创建、删除节点的时候也会找不到（本身这两种操作就不应该进到这个方法）
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                    pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
+                }
+                positions.shift();
+                // 拿到标识下定义的参数名字
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        if (node instanceof concepts_1.ProcessElement) {
+            if (currentSource) {
+                const code = this.getNodeCode(fileNode, currentSource);
+                const prefix = '__ProcessIdentification__';
+                let positions = [];
+                let pos = code.indexOf(prefix);
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                }
+                // 拿到标识下定义的const process = {...}
+                positions = positions.map((position) => code.indexOf(`${node.name}:`, position + prefix.length));
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        if (node instanceof concepts_1.Return && node.parentNode instanceof concepts_1.ProcessElement) {
+            const { currentSource, fileNode } = this.getCurrentSource(node.parentNode);
+            if (currentSource) {
+                // 流程任务出参查找引用需要查找到流程任务完成逻辑
+                // const parentRefs = await this.references({
+                //   file: (fileNode as FileNode).getEmbeddedFilePath(),
+                //   line: lsp2tspNumber(currentSource.start.line),
+                //   offset: lsp2tspNumber(currentSource.start.character),
+                // });
+                // refsList = [...refsList, ...parentRefs.refs];
+                // console.log(parentRefs.refs)
+                // 流程任务出参查找引用比较特殊，需要查找到 const process = {...} 的引用
+                const code = this.getNodeCode(fileNode, currentSource);
+                const prefix = '__ProcessIdentification__';
+                const positions = [];
+                let pos = code.indexOf(prefix);
+                // 需要再次定位到processelement对象上，避免process上存在同名参数
+                pos = pos === -1 ? pos : code.indexOf(node.parentNode.name, pos + prefix.length);
+                pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
+                // pos === -1：两种情况：
+                // 1、找到最后一个节点了，继续找找不下去了。
+                // 2、创建、删除节点的时候也会找不到（本身这两种操作就不应该进到这个方法）
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                    // 需要再次定位到processelement对象上，避免process上存在同名参数
+                    pos = pos === -1 ? pos : code.indexOf(node.parentNode.name, pos + node.parentNode.name.length);
+                    pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
+                }
+                // 拿到标识下定义的参数名字
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    if (constRefs.symbolDisplayString.includes('(parameter)')) {
+                        return;
+                    }
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        // console.log(refsList, 'refsList');
+        return refsList;
+    }
+    /**
+     * 查找引用，并且做一些 修改前的准备工作，
+     * 有引用有的话，就返回集合
+     * @param node 当前重命名的节点
+     * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+     * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+     * @returns 找到的引用
+     */
+    _renamePrepare(node, refsList, newValue) {
+        const oldName = node?.name;
+        const result = refsList
+            .map((record) => {
+            const fileNode = this.file2NodeMap.get(record.file);
+            if (!fileNode)
+                return null;
+            const 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';
+                }
+                if (minRange.node instanceof concepts_1.CallConnector) {
+                    minRange.setTypeMethods = 'setCalleeConnectionName';
+                }
+                // 如果节点是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`;
+                }
+                if (minRange.node instanceof concepts_1.CallEvent) {
+                    minRange.setTypeMethods = 'setCalleeName';
+                }
+                // 如果节点是实体修改引发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中的 $替换成 ''
+                     *
+                     */
+                    const { tsCalleeNamespace } = minRange.node;
+                    // 先看下标位置
+                    const { lineText } = record;
+                    const index = lineText.indexOf(tsCalleeNamespace);
+                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                    const start = record.start.offset - index - 1;
+                    const end = record.end.offset - index - 1;
+                    // 新的完整的value
+                    let 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) {
+                    // 匹配到的内容，当前这一行的内容；
+                    // 因为要用下面的点位信息
+                    const { name } = minRange.node;
+                    // 如果name不改，那就是要改命名空间
+                    if (node instanceof concepts_1.Frontend || newValue === name) {
+                        const { namespace } = minRange.node;
+                        // 先看下标位置
+                        const { lineText } = record;
+                        const index = lineText.indexOf(namespace);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        const start = record.start.offset - index - 1;
+                        const end = record.end.offset - index - 1;
+                        // 新的完整的value
+                        const newTextValue = namespace.substring(0, start) + newValue + namespace.substring(end, namespace.length);
+                        minRange.setTypeMethods = 'setNamespace';
+                        minRange.newValue = newTextValue;
+                    }
+                }
+                if (node instanceof concepts_1.Enum) {
+                    // 如果是枚举修改，枚举的值刚好在Identifier 中选了 就修改值
+                    if (minRange.node instanceof concepts_1.Identifier) {
+                        minRange.newValue = newValue;
+                        minRange.setTypeMethods = 'setName';
+                    }
+                    else if (minRange.node instanceof concepts_1.EntityProperty) {
+                        // 如果枚举自己改名引用到了实体字段，而不是实体字段下的类型，就说明是默认值，默认值可以不处理
+                        return null;
+                    }
+                }
+                // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
+                if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Logic) {
+                    minRange.newValue = newValue;
+                    minRange.setTypeMethods = 'setName';
+                }
+                // 如果节点是MemberExpression表达式
+                if (minRange.node instanceof concepts_1.MemberExpression) {
+                    // 枚举key的特殊性，因为它不是原来的key+value形式的
+                    // 是加了中括号啥的，所以直接赋值新值
+                    if (node instanceof concepts_1.EnumItem) {
+                        const newTextValue = `${node.parentNode.name}.${newValue}`;
+                        minRange.newValue = newTextValue;
+                    }
+                    else {
+                        // 匹配到的内容，当前这一行的内容；
+                        // 因为要用下面的点位信息
+                        const a = record.lineText;
+                        // 之前的内容
+                        const oldValue = minRange.node.getValue();
+                        const index = a.indexOf(oldValue);
+                        const start = record.start.offset - index - 1;
+                        const end = record.end.offset - index - 1;
+                        const 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) {
+                        if (minRange.node.parentKey === 'selectElements') {
+                            minRange.setTypeMethods = 'setEntityAsNameAndEffect';
+                        }
+                        else {
+                            minRange.setTypeMethods = 'setEntityAsName';
+                        }
+                    }
+                    else if (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 = 'setEntityNameAndEffect';
+                    }
+                    else if (minRange.node instanceof concepts_1.BindAttribute && minRange.node.name === 'url') {
+                        // 如果是查找到 上传地址的链接引用
+                        let newName = newValue.replace(/[A-Z]/g, (item) => `-${item.toLowerCase()}`);
+                        newName = newName[0] === '-' ? newName.slice(1) : newName;
+                        const newTextValue = node.parentNode.name === 'defaultDS' ? `/api/${newName}/import` : `/api/${node.parentNode.name}/${newName}/import`;
+                        minRange.setTypeMethods = 'setUrlValue';
+                        minRange.newValue = newTextValue;
+                    }
+                    else if (minRange.node instanceof concepts_1.Identifier) {
+                        minRange.newValue = utils.firstLowerCase(newValue);
+                    }
+                }
+                // 如果是修改实体属性，要同步实体属性
+                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) {
+                    const newPropertyNameList = [...minRange.node.propertyNames];
+                    const findIndex = newPropertyNameList.findIndex((item) => item === oldName);
+                    if (findIndex !== -1) {
+                        // 修改数组的值
+                        newPropertyNameList.splice(findIndex, 1, newValue);
+                        minRange.setTypeMethods = 'setPropertyNames';
+                        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中的 $替换成 ''
+                     *
+                     */
+                    const { tsCalleeNamespace } = minRange.node;
+                    const { tsName } = minRange.node;
+                    const oldValue = `${tsCalleeNamespace}.${tsName}`;
+                    // 先看下标位置
+                    const { lineText } = record;
+                    const index = lineText.indexOf(oldValue);
+                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                    const start = record.start.offset - index - 1;
+                    const end = record.end.offset - index - 1;
+                    if (start > tsCalleeNamespace.length) {
+                        minRange.setTypeMethods = 'setViewName';
+                        minRange.newValue = newValue;
+                    }
+                    else {
+                        // 新的完整的value
+                        let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                        minRange.setTypeMethods = 'setViewNamespace';
+                        newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                        minRange.newValue = newTsNameSpace;
+                    }
+                }
+                if (node instanceof concepts_1.Frontend && minRange.node instanceof concepts_1.Destination) {
+                    const { tsCalleeNamespace } = minRange.node;
+                    const { tsName } = minRange.node;
+                    const oldValue = `${tsCalleeNamespace}.${tsName}`;
+                    // 先看下标位置
+                    const { lineText } = record;
+                    const index = lineText.indexOf(oldValue);
+                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                    const start = record.start.offset - index - 1;
+                    const end = record.end.offset - index - 1;
+                    if (start <= tsCalleeNamespace.length) {
+                        // 新的完整的value
+                        let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                        minRange.setTypeMethods = 'setViewNamespace';
+                        newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                        minRange.newValue = newTsNameSpace;
+                    }
+                }
+                // 如果是事件修改
+                // 如果是view也需要加前缀
+                // logic 和 views名称修改 可能会触发bindEvent修改
+                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中的 $替换成 ''
+                         */
+                        const { tsCalleeNamespace } = minRange.node;
+                        const oldValue = tsCalleeNamespace;
+                        // 先看下标位置
+                        const { lineText } = record;
+                        const index = lineText.indexOf(oldValue);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        const start = record.start.offset - index - 1;
+                        const end = record.end.offset - index - 1;
+                        // 新的完整的value
+                        if (start > tsCalleeNamespace.length) {
+                            minRange.setTypeMethods = 'setCalleeName';
+                            minRange.newValue = newValue;
+                        }
+                        else {
+                            // 新的完整的value
+                            let 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) {
+                        const nodeArguments = minRange.node.arguments;
+                        const findArgument = nodeArguments.find((item) => node.name === item.keyword);
+                        if (findArgument) {
+                            minRange.setTypeMethods = 'setArgumentsKeyWord';
+                            minRange.newValue = {
+                                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';
+                    const str = minRange.node.bindRoles.toString().replace(oldName, newValue);
+                    const 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) {
+                    const setTypeNamespace = (typeNamespace, record) => {
+                        // 先看下标位置
+                        const { lineText } = record;
+                        const index = lineText.indexOf(typeNamespace);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        const start = record.start.offset - index - 1;
+                        const end = record.end.offset - index - 1;
+                        // 新的完整的value
+                        const 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';
+                        const newValue = setTypeNamespace(minRange.node.typeNamespace, record);
+                        minRange.newValue = newValue;
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) {
+                        minRange.setTypeMethods = 'setEntityNamespace';
+                        const newValue = setTypeNamespace(minRange.node.entityNamespace, record);
+                        minRange.newValue = newValue;
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryFieldExpression) {
+                        return null;
+                    }
+                    else if (minRange.node instanceof concepts_1.CallLogic) {
+                        minRange.setTypeMethods = 'setCalleeNamespace';
+                        const newValue = setTypeNamespace(minRange.node.calleeNamespace, record);
+                        minRange.newValue = newValue;
+                    }
+                    else if (minRange.node instanceof concepts_1.EntityProperty) {
+                        minRange.setTypeMethods = 'setRelationNamespace';
+                        const newValue = setTypeNamespace(minRange.node.relationNamespace, record);
+                        minRange.newValue = newValue;
+                    }
+                    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 || node instanceof concepts_1.MetadataType)) {
+                    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;
+                }
+                if (minRange.node instanceof concepts_1.Argument && node instanceof concepts_1.Param) {
+                    minRange.setTypeMethods = 'setKeyword';
+                }
+                /**
+                 * 理论上 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 || minRange.node instanceof concepts_1.BusinessComponent) {
+                    if (node instanceof concepts_1.View || node instanceof concepts_1.BusinessComponent) {
+                        // 如果是子页面修改
+                        // 父页面引起子页面改名，就可以不改了，自动同步
+                        // 页面中的业务组件，业务组件中的业务组件等都需要忽略
+                        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.BusinessComponent) {
+                        minRange.setTypeMethods = 'setTag';
+                        minRange.newValue = `bs-${newValue}`;
+                    }
+                    else if (!(node instanceof concepts_1.Role)) {
+                        /**
+                         * 无论是逻辑还是实体中的key，修改都不应该触发
+                         * 理论上除了组件自己改名可以触发
+                         * 下面这里 不属于Role是因为上面代码里有， 不符合 规范 的role改名存在所以先保留
+                         */
+                        return null;
+                    }
+                }
+            }
+            else {
+                console.log('没找到节点需要排查', record, fileNode.sourceMap);
+            }
+            return minRange;
+        })
+            // 过滤掉不需要操作的
+            .filter((item) => !!item)
+            // 排序：
+            // QueryFieldExpression依赖Entity，把Entity放在QueryFieldExpression前，
+            .sort((a, b) => {
+            if (a.node.concept === 'QueryFieldExpression') {
+                return 1;
+            }
+            if (b.node.concept === 'QueryFieldExpression') {
+                return -1;
+            }
+            return 0;
+        });
+        return result;
+    }
+    // 增加参数的副作用，用于更新logic和view
+    _addParamsEffect(refsList, node) {
+        const parantNode = node?.parentNode;
+        refsList.forEach((record) => {
+            const fileNode = this.file2NodeMap.get(record.file);
+            if (!fileNode)
+                return null;
+            const minRange = this._findMinRange(record, fileNode);
+            if (minRange) {
+                // 如果找到节点是callLogic就去更新
+                if (node instanceof concepts_1.Param) {
+                    if (minRange.node instanceof concepts_1.CallLogic || minRange.node instanceof concepts_1.CallAuthInterface) {
+                        minRange.node.addCalleeArg(parantNode);
+                    }
+                    else if (minRange.node instanceof concepts_1.Destination) {
+                        // 跳转页面，可能在父级下增加参数，子的跳转页面也可以查找到引用
+                        // 精准匹配子页面的内容
+                        const viewNode = node.parentNode;
+                        if (viewNode instanceof concepts_1.View) {
+                            const viewNamespace = viewNode.getNamespace();
+                            if (viewNamespace === minRange.node.viewNamespace && viewNode.name === minRange.node.viewName) {
+                                minRange.node.addCalleeArg(parantNode);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+    _addParamsPrepare(node, refsList, needAdd) {
+        if (needAdd) {
+            const App = node?.rootNode;
+            const parantNode = node?.parentNode;
+            // 收集修改
+            App.emit('collect:start', {
+                actionMsg: '增加逻辑参数',
+            });
+            const index = node.getIndexOfParent();
+            node.create({
+                index,
+                parentNode: parantNode,
+                parentKey: node.parentKey,
+            });
+            this._addParamsEffect(refsList, node);
+            // 结束修改 ，批量操作
+            App.emit('collect:end');
+            return node;
+        }
+        this._addParamsEffect(refsList, node);
+        return node;
+    }
+    // 查找引用
+    async findReferences(node) {
+        let refsList = await this._isHaveRef(node);
+        // 如果查找引用查到自己里面的引用不展示
+        refsList = refsList.filter((item) => 
+        // 自己引用自己的过滤掉
+        // 删除的时候过滤一把组件删除提示
+        // 展示组件自己屏蔽掉
+        !item.isDefinition && !item.lineText.includes(' = new nasl.ui.'));
+        // 最后返回的结果
+        let result = new Map();
+        // 树的构造，key： 一个file的node， 值是 [[logic, params],[logic, returns]]
+        const resMap = new Map();
+        // 普通节点和要输出的节点做一个映射，为了引用地址一样
+        const nodeMap = new Map();
+        try {
+            refsList.forEach((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return;
+                const 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 result;
+    }
+    // 通过当前节点，查找被引用的节点
+    async nodeFindRefNodes(node) {
+        let refsList = await this._isHaveRef(node);
+        // 如果查找引用查到自己里面的引用不展示
+        refsList = refsList.filter((item) => 
+        // 自己引用自己的过滤掉
+        // 删除的时候过滤一把组件删除提示
+        // 展示组件自己屏蔽掉
+        !item.isDefinition && !item.lineText.includes(' = new nasl.ui.'));
+        // 最后返回的结果
+        const result = new Set();
+        try {
+            refsList.forEach((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return;
+                const minRange = this._findMinRange(record, fileNode);
+                result.add(minRange.node);
+            });
+        }
+        catch (err) {
+            console.log(err);
+        }
+        return [...result];
+    }
+    // 获取节点的上层渲染
+    _getTreeMap(minRange, fileNode, resMap, nodeMap) {
+        const minRangeNode = minRange.node;
+        let currentNode = minRangeNode;
+        let parantNode = currentNode;
+        // 顺序队列
+        const queue = [];
+        // 先插入自己,如果没有在往上找,
+        // 一直到file节点的父级
+        while (parantNode && !(parantNode instanceof concepts_1.App)) {
+            // 找到上一级 在map对象中构造出他的子集
+            currentNode = parantNode;
+            parantNode = parantNode.parentNode;
+            // 如果第一次就塞入子集和父节点，以后就只用父节点了
+            // 因为部分节点没有name，先过滤掉
+            // if (currentNode.name) {
+            // }
+            // 排除一些不放入集合的节点
+            let 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) {
+                // 名称
+                // 赋值图标
+                let 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 {
+                    const quoteNode = { node: currentNode, expanded: true, 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]);
+        }
+    }
+    handleTreeMap(resMap) {
+        const treeNodeMap = new Map();
+        resMap.forEach((value, fileNode) => {
+            // 循环处理tree的queue
+            const treeObj = this.handleTreeQueue(value);
+            treeNodeMap.set(fileNode, treeObj);
+        });
+        return treeNodeMap;
+    }
+    /**
+     * 处理tree的队列，把相同节点进行合并
+     * 这里把当前二维数组进行一个整合
+     * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
+     * @returns 最后要使用到的节点和对应的子集
+     */
+    handleTreeQueue(queueLists) {
+        const map = new Map();
+        let root = null;
+        if (!queueLists.length)
+            return;
+        for (const queueList of queueLists) {
+            let preNode = null;
+            for (const queueItem of queueList) {
+                if (!map.get(queueItem)) {
+                    map.set(queueItem, []);
+                }
+                if (preNode) {
+                    const find = map.get(preNode).find((item) => item === queueItem);
+                    if (!find) {
+                        map.get(preNode).push(queueItem);
+                    }
+                }
+                else {
+                    root = queueItem;
+                }
+                preNode = queueItem;
+            }
+        }
+        const children = this._recursionCreateResult(root, map);
+        return children;
+    }
+    /**
+     * 递归调用输出结果
+     * @param root 一个根节点
+     * @param map 当前所有节点的map对象
+     * @returns 当前节点，最后输出所有节点
+     */
+    _recursionCreateResult(root, map) {
+        const children = (map.get(root) || []).map((item) => this._recursionCreateResult(item, map));
+        if (children && children.length) {
+            root.children = children;
+        }
+        return root;
+    }
+    /**
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
+    getCurrentSource(node) {
+        if (node instanceof concepts_1.App || node instanceof concepts_1.Theme)
+            return { fileNode: null };
+        let { sourceMap } = node;
+        let fileNode = node;
+        // 连接器 操作，上层结构是 Namespace， Namespace 并无含义，因此需要过滤掉
+        const isConnectorLogic = node.getAncestor('Connector') && node.concept === 'Logic' && node.parentNode instanceof concepts_1.Namespace;
+        // 如果没有sourceMap,就继续向上找 ,或者到module结束
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是view就不要向上查找了
+        // 配置参数的ConfigProperty也不需要向上找
+        while (!sourceMap &&
+            fileNode &&
+            !(fileNode.parentNode instanceof concepts_1.App) &&
+            !(fileNode.parentNode instanceof concepts_1.Integration) &&
+            !(fileNode.parentNode instanceof concepts_1.Module) &&
+            !(fileNode.parentNode instanceof concepts_1.DataSource) &&
+            !(fileNode.parentNode instanceof concepts_1.Frontend) &&
+            !(fileNode.parentNode instanceof concepts_1.Backend) &&
+            !isConnectorLogic &&
+            !(fileNode instanceof concepts_1.View) &&
+            !(fileNode instanceof concepts_1.BusinessComponent) &&
+            !(fileNode instanceof concepts_1.ConfigProperty)) {
+            fileNode = fileNode.parentNode;
+            sourceMap = fileNode?.sourceMap;
+        }
+        const currentSource = sourceMap && sourceMap.get(node);
+        if (currentSource) {
+            // 这里处理一些加了注解或者需要定制位置的节点的取值
+            this.handlingCurrentSourceException(currentSource, node);
+            return { currentSource, fileNode };
+        }
+        return { fileNode };
+    }
+    handlingCurrentSourceException(currentSource, node) {
+        // 如果有前面的一些注解，元素在最后一行输出的值就给最后一行
+        if (node instanceof concepts_1.EntityProperty) {
+            if (currentSource.start.line !== currentSource.end.line) {
+                currentSource.start = { ...currentSource.start, line: currentSource.end.line };
+            }
+        }
+    }
+    // 获取element方法的可选值
+    getFieldKeySelectCompletion(node, fieldKey) {
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        if (currentSource && fileNode) {
+            const range = {
+                line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character),
+            };
+            // foreach 在最后一行自动补全
+            if (node.concept === 'ForEachStatement') {
+                range.line = currentSource.end.line;
+                range.offset = 0;
+            }
+            else if (node.concept === 'BindAttribute') {
+                range.offset += 7;
+            }
+            else if (node.concept === 'BindDirective') {
+                range.offset += 5;
+            }
+            return this._getFieldKeySelectCompletion({
+                file: fileNode.getEmbeddedFilePath(),
+                range,
+                getFieldKey: fieldKey,
+            });
+        }
+    }
+    _getFieldKeySelectCompletion(args) {
+        return this.messager.requestCommand('getFieldKeySelectCompletion', args);
+    }
+    /**
+     * 获取模块下多个CallInterface 被依赖的页面节点
+     * 查找callInterface 被依赖的页面级别的节点，要让他们重新生成一次代码，因为多个Interface重新导入，需要查找到引用的额内容
+     * 对应引用地方，需要重新生成，因为是生成方控制是不是必填的，
+     * @param oldInterfaceModule 发生修改的module，查他下面的Interface被引用的地方
+     * @returns 查找到的有引用这个内容的页面级别节点
+     */
+    async findModulesCallInterfaceFileRef(oldInterfaceModule) {
+        const oldInterfaces = oldInterfaceModule.interfaces;
+        const fileNodes = new Set();
+        for (let i = 0; i < oldInterfaces.length; i++) {
+            const item = oldInterfaces[i];
+            const refsList = await this._isHaveRef(item);
+            refsList.forEach((record) => {
+                if (record.isDefinition)
+                    return;
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (fileNode) {
+                    fileNodes.add(fileNode);
+                }
+            });
+        }
+        return [...fileNodes];
+    }
+    /**
+     * 查找calllogic 被依赖的页面级别的节点，要让他们重新生成一次代码，因为logic，参数必填非必填发生修改，
+     * 对应引用地方，需要重新生成，因为是生成方控制是不是必填的，
+     * @param logic 发生修改的logic
+     * @returns 查找到的有引用这个内容的页面级别节点
+     */
+    async findCallLogicFileRef(logic) {
+        const fileNodes = new Set();
+        const refsList = await this._isHaveRef(logic);
+        refsList.forEach((record) => {
+            if (record.isDefinition)
+                return;
+            const fileNode = this.file2NodeMap.get(record.file);
+            if (fileNode) {
+                fileNodes.add(fileNode);
+            }
+        });
+        return [...fileNodes];
+    }
+    /** 获取当前节点的已知类型
+     * @param node 当前要获取类型的节点
+     * @returns 不需要去查就可以返回类型的节点
+     */
+    getCurrentNodeKnownTypeAnnotation(node) {
+        if (node.concept === 'StringLiteral' ||
+            node.concept === 'StringInterpolation' ||
+            node.concept === 'BooleanLiteral' ||
+            node.concept === 'NullLiteral') {
+            let type = 'String';
+            switch (node.concept) {
+                case 'NullLiteral':
+                    type = 'Null';
+                    break;
+                case 'BooleanLiteral':
+                    type = 'Boolean';
+                    break;
+            }
+            return concepts_1.TypeAnnotation.createPrimitive(type);
+        }
+        // 如果是一元表达式，那么就是布尔值
+        if (node instanceof concepts_1.UnaryExpression) {
+            return concepts_1.TypeAnnotation.createPrimitive('Boolean');
+        }
+        // 这些原有类型的 比较的 返回值肯定就是布尔值，就不去调用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' && ['Convert', 'New', 'FromString'].includes(node.calleeName)) {
+            if (node.typeArguments.length) {
+                return node.typeArguments[0];
+            }
+        }
+        // Convert和new都是自身携带类型的，就不进行修改
+        if (node instanceof concepts_1.CallLogic && node.calleeNamespace === 'nasl.util' && node.calleeName === 'jsonDeserialize') {
+            if (node.typeArguments.length) {
+                return node.typeArguments[0];
+            }
+        }
+        // 特殊处理param有类型错误的
+        if (node instanceof concepts_1.Param) {
+            // index在nasl foreach上有脏数据
+            if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
+                return concepts_1.TypeAnnotation.createPrimitive('Long');
+            }
+        }
+        if (node instanceof concepts_1.CallQueryComponent || node instanceof concepts_1.SqlQueryComponent || node instanceof concepts_1.OqlQueryComponent) {
+            return node.typeAnnotation;
+        }
+        // 老数据可能typeKind 的primitive缺失
+        if (node instanceof concepts_1.NumericLiteral && node.typeAnnotation) {
+            return concepts_1.TypeAnnotation.from({
+                ...node.typeAnnotation?.toJSON(),
+                typeKind: 'primitive',
+            });
+        }
+    }
+    /**
+     * 获取传入节点的 TypeAnnotation
+     *
+     * @description 生成器模式原型
+     */
+    *_getQuickInfoNodesTypeMapWithGenerator(nodes) {
+        const self = this;
+        const args = [];
+        // 要通过自己或者依赖关系拿的
+        const getFromOthers = new Map();
+        // 总共要返回出去的
+        const types = new Map();
+        const newQuickInfoNodes = [];
+        yield* utils.wrapForEachToGenerator(nodes, function* getQuickInfoPosition(itemDetail, index) {
+            const { node, filePath, item } = itemDetail;
+            // 先按照顺序占位
+            types.set(node, null);
+            // 获取已知节点类型的类型
+            const nodeTypeAnnotation = self.getCurrentNodeKnownTypeAnnotation(node);
+            yield;
+            if (nodeTypeAnnotation) {
+                types.set(node, nodeTypeAnnotation);
+                return;
+            }
+            // 要通过自己或者依赖关系拿的，二次遍历
+            if (['Argument', 'Assignment', 'MatchCase'].includes(node.concept)) {
+                getFromOthers.set(node, null);
+            }
+            if (['Return', 'Variable'].includes(node.concept) && node.typeAnnotation) {
+                types.set(node, node.typeAnnotation);
+                return;
+            }
+            // 如果 入参不是虚拟节点的，就不去请求类型
+            // 只有虚拟节点的入参，才没有类型
+            if (node.concept === 'Param' && (node.parentKey !== 'virtualParams' && node.parentKey !== 'item' && node.parentNode.concept !== 'AnonymousFunction')) {
+                return;
+            }
+            if (![
+                'Identifier',
+                'BinaryExpression',
+                'CallLogic',
+                'CallFunction',
+                'CallInterface',
+                'MemberExpression',
+                'Return',
+                'Variable',
+                'Match',
+                'NewComposite',
+                'NewList',
+                'NewMap',
+                'OqlQueryComponent',
+                'QueryFieldExpression',
+                'QueryGroupByExpression',
+                'Param',
+                'Paginate',
+                'BackendVariable',
+                'CallAuthInterface',
+            ].includes(node.concept))
+                return;
+            // 要去ls那边获取的
+            newQuickInfoNodes.push(itemDetail);
+            const fileDetail = {
+                file: filePath,
+                line: (0, translator_1.lsp2tspNumber)(item.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(item.start.character),
+            };
+            const getCode = (range) => {
+                return self.tsFiles.get(filePath)?.slice(range.start.offset, range.end.offset) ?? '';
+            };
+            // 位置计算偏移
+            if ('getQuickInfoOffset' in node) {
+                Object.assign(fileDetail, node.getQuickInfoOffset(item, () => getCode(item)));
+            }
+            yield;
+            // 位置计算偏移2
+            // TODO: 之后考虑把这些偏移量计算全都挪到节点内部去
+            if (node.concept === 'MemberExpression' ||
+                node.concept === 'Identifier' ||
+                node.concept === 'QueryFieldExpression' ||
+                node.concept === 'QueryGroupByExpression') {
+                const code = getCode(item);
+                if (code.includes('.')) {
+                    const codeArr = code?.split('.');
+                    const lastLen = codeArr?.[codeArr.length - 1]?.length;
+                    // MemberExpression取最后一位当做类型
+                    const indexOf = code.length - lastLen;
+                    fileDetail.offset += indexOf;
+                }
+            }
+            else if (node.concept === 'Match') {
+                const code = getCode(item);
+                // 去查return 后面的返回值，变成函数调用
+                if (code?.endsWith(';\n')) {
+                    fileDetail.line = item.end.line - 1;
+                }
+                else {
+                    fileDetail.line = item.end.line;
+                }
+                const indexOf = code.indexOf('return __MatchExpressionFuntion');
+                let newCode = code.substring(0, indexOf);
+                newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+                fileDetail.offset = newCode.length + 'return '.length;
+            }
+            else if (['OqlQueryComponent'].includes(node.concept)) {
+                fileDetail.offset += 10;
+            }
+            args.push(fileDetail);
+        });
+        const resultMap = (yield this.getNaslNodeTypeFull(args))?.response;
+        yield* utils.wrapForEachToGenerator(args, function* wrapForEach({ file, line, offset }, index) {
+            const item = resultMap?.[file]?.[line]?.[offset];
+            const itemType = item?.[0]?.nodeType;
+            const nodeTypeAnnotation = yield* (0, formatTsUtils_1.type2TypeAnnotation)(itemType);
+            const { node } = newQuickInfoNodes[index];
+            types.set(node, Object.freeze(nodeTypeAnnotation));
+            const type = itemType ? (Object.isFrozen(itemType) ? itemType : Object.freeze(itemType)) : null;
+            if (type) {
+                node.__nodeType = type;
+            }
+            else {
+                delete node.__nodeType;
+            }
+        });
+        yield* utils.wrapIteratorToGenerator(getFromOthers.entries(), function* ([node]) {
+            if (node instanceof concepts_1.Assignment) {
+                if (!types.get(node.left)) {
+                    types.set(node.left, types.get(node.right));
+                }
+            }
+            else if (node instanceof concepts_1.Argument) {
+                // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
+                const argType = yield* self.getArgumentTypeAnnotationWithGenerator(node, newQuickInfoNodes, types);
+                types.set(node, argType);
+            }
+            else if (node instanceof concepts_1.MatchCase) {
+                // matchCase的类型
+                // 直接从最后一项的返回值取，有就有没有就没有
+                if (node.body?.length) {
+                    const last = node.body[node.body.length - 1];
+                    if (types.get(last)) {
+                        types.set(node, types.get(last));
+                    }
+                }
+            }
+        });
+        yield* utils.wrapIteratorToGenerator(types.entries(), ([node, value]) => {
+            try {
+                // 因为node可能是经过处理的TypeAnnotation
+                node.__isCorrectTypeAnnotation = true;
+                if (value) {
+                    if (node instanceof concepts_1.OqlQueryComponent) {
+                        // 自动推导情况
+                        const typeAnnotation = value;
+                        if (!node.typeAnnotation && typeAnnotation) {
+                            if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
+                                const { typeArguments } = typeAnnotation;
+                                if (typeArguments.length && typeArguments[0].isComplexType()) {
+                                    delete node.__TypeAnnotation;
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                    if (value instanceof concepts_1.TypeAnnotation) {
+                        node.__TypeAnnotation = value;
+                    }
+                    else if (value.typeAnnotation) {
+                        node.__TypeAnnotation = value.typeAnnotation;
+                    }
+                }
+                else {
+                    // 清空原来已经赋值上去的类型，可能原来有现在没有了
+                    delete node.__TypeAnnotation;
+                }
+            }
+            catch (err) {
+                // if (globalThis.window) {
+                //   console.log(err);
+                // }
+            }
+        });
+        return types;
+    }
+    /**
+     * 获取传入节点的 TypeAnnotation
+     */
+    getQuickInfoNodesTypeMap(nodes, flag) {
+        return utils.runGeneratorAsync(this._getQuickInfoNodesTypeMapWithGenerator(nodes));
+    }
+    // 全量标注并且返回json
+    async getNaslAnnotatedJSON(app, releaseFlag) {
+        if (this.changeStackList?.length) {
+            throw new Error(`当前还有${this.changeStackList.length}个文件还在执行更新操作`);
+        }
+        const nodes = [];
+        this.file2NodeMap.forEach((fileNode, filePath) => {
+            // 先不排除view，传递给后端的时候，去除views下的标注
+            if (!['DataSource', 'Enum', 'Role'].includes(fileNode.concept)) {
+                fileNode.sourceMap.forEach((item, node) => {
+                    nodes.push({
+                        filePath,
+                        node,
+                        item,
+                    });
+                });
+            }
+        });
+        console.time('全量标注');
+        const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
+        console.timeEnd('全量标注');
+        const json = app.toJSON();
+        console.log(json);
+        if (releaseFlag) {
+            // 全量标注后对json进行一些修改，为了服务端翻译处理
+            this.annotationToJson(typesMap, json);
+        }
+        return json;
+    }
+    // 增量标注
+    *_incrementalAnnotationJSONWithGenerator(records) {
+        console.time('增量标注');
+        const nodes = [];
+        const self = this;
+        yield* utils.wrapForEachToGenerator(records, function* findNodePosition(record) {
+            const fileNode = self.file2NodeMap.get(record.filePath);
+            if (!fileNode) {
+                return;
+            }
+            record.id = fileNode.id;
+            record.node = fileNode;
+            if (['Structure', 'DataSource', 'Entity', 'Enum', 'Role', 'MetadataType'].includes(fileNode.concept) || !fileNode.sourceMap) {
+                return;
+            }
+            yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), ([nodeItem, item]) => {
+                nodes.push({
+                    filePath: record.filePath,
+                    node: nodeItem,
+                    item,
+                });
+            });
+        });
+        yield* this._getQuickInfoNodesTypeMapWithGenerator(nodes);
+        console.timeEnd('增量标注');
+    }
+    annotationToJson(typesMap, json) {
+        typesMap.forEach((value, node) => {
+            // 如果节点本身有类型就不去在塞一遍了
+            // 有值而且没有类型再去设置
+            // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
+            if (value && (node instanceof concepts_1.Argument) && node.getAncestor('Connector')?.concept === 'Connector') {
+                const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                if (jsonNode) {
+                    jsonNode.typeAnnotation = value?.toJSON();
+                }
+            }
+            if (value && (!node.typeAnnotation || node instanceof concepts_1.Identifier || node instanceof concepts_1.MemberExpression)) {
+                const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                if (jsonNode) {
+                    jsonNode.typeAnnotation = value?.toJSON();
+                }
+            }
+            // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
+            if (node instanceof concepts_1.CallQueryComponent && !node.isAutoInfer()) {
+                const 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: 'Long',
+                                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) {
+                    const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Long').toJSON();
+                }
+            }
+            if (node instanceof concepts_1.Match) {
+                const matchExpression = node.expression;
+                if (matchExpression?.__TypeAnnotation?.typeKind === 'union' &&
+                    (matchExpression instanceof concepts_1.Identifier || matchExpression instanceof concepts_1.MemberExpression)) {
+                    const { currentSource, fileNode } = matchExpression?.getCurrentSource();
+                    fileNode.sourceMap.forEach((item, itemNode) => {
+                        if (itemNode.concept === matchExpression.concept && (0, translator_1.isSameRange)(item, currentSource)) {
+                            const jsonNode = jsoner.queryNodeByPath(json, itemNode.getNodePath(false));
+                            jsonNode.typeAnnotation = matchExpression.__TypeAnnotation;
+                        }
+                    });
+                }
+            }
+            // 特殊处理param有类型错误的
+            if (value && (node instanceof concepts_1.Param)) {
+                // index在nasl foreach上有脏数据
+                if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
+                    const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                    jsonNode.typeAnnotation = value.toJSON();
+                }
+            }
+            if (value && (node instanceof concepts_1.NewComposite) && (node.typeAnnotation?.typeKind === 'anonymousStructure' || node.typeAnnotation?.typeKind === 'generic')) {
+                const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                jsonNode.typeAnnotation = value.toJSON();
+            }
+            // jsonSerializer 是 CallLogic，其余是 CallFunction
+            if (node instanceof concepts_1.CallFunction || node instanceof concepts_1.CallLogic) {
+                const tzArgIdx = timeZoneArgumentIndexMap.get(node.calleeName);
+                const args = node.arguments;
+                const tzArg = args ? args[tzArgIdx] : undefined;
+                if (tzArgIdx && tzArg?.keyword === '时区' && !isCoreDateTimeType(node.arguments[0])) {
+                    if (!isFunctionWithFixedTimeZoneParam(node.calleeName)) {
+                        node.arguments.pop();
+                    }
+                }
+            }
+            // 服务端需要默认值节点有类型来判断父节点是否是日期类型
+            if (node instanceof concepts_1.DefaultValue && !value) {
+                const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                const parentNodeType = node.parentNode?.typeAnnotation || node.parentNode?.__TypeAnnotation;
+                if (parentNodeType && jsonNode) {
+                    jsonNode.typeAnnotation = parentNodeType?.toJSON();
+                }
+            }
+        });
+    }
+    /**
+     * 获取getArgument的参数位的类型
+     * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
+     * 获取logic的默认值和原来Arg的类型和默认值对应
+     */
+    *getArgumentTypeAnnotationWithGenerator(node, QuickInfoNodes, types) {
+        // 直接复用内部expression的type类型
+        if (node.parentNode instanceof concepts_1.CallLogic &&
+            node.parentNode.calleeNamespace?.includes('entities') &&
+            node.parentNode.calleeNamespace?.includes('logics') &&
+            node.parentNode.calleeName === 'delete') {
+            const nodeType = node.parentNode?.__nodeType;
+            if (nodeType && Array.isArray(nodeType.fnParams)) {
+                const index = node.parentNode.arguments.indexOf(node);
+                const type = nodeType.fnParams[index]?.typeInfo;
+                const nodeTypeAnnotation = yield* (0, formatTsUtils_1.type2TypeAnnotation)(type);
+                if (nodeTypeAnnotation) {
+                    return nodeTypeAnnotation;
+                }
+            }
+            yield;
+        }
+        // 获取返回值结果里找到父级的callLogic || CallInterface的类型填充进去Argument
+        const App = node.app;
+        const parent = node.parentNode;
+        // 如果nasl包下的 ，很多声明都含有T啥的先用自己内部的
+        if (!parent.calleeNamespace || parent.calleeNamespace?.startsWith('nasl')) {
+            if (types.get(node.expression)) {
+                return types.get(node.expression);
+            }
+        }
+        // 用户自己声明的用用户的
+        const callObj = App.findNodeByCompleteName(`${parent.calleeNamespace}.${parent.calleeName}`);
+        yield;
+        const index = parent.arguments.indexOf(node);
+        const param = callObj?.params?.[index] || {};
+        // 取出参数的类型
+        // 设置类型
+        return param.typeAnnotation;
+    }
+    async getCurrentTypeAnnotation(node, outTime = 600) {
+        if (node.__TypeAnnotation) {
+            return node.__TypeAnnotation;
+        }
+        return new Promise((resolve, reject) => {
+            const myTimer = setTimeout(() => {
+                console.warn(node, '没有获取到类型');
+                clearTimeout(myTimer);
+                clearInterval(mySetInterval);
+                if (node.__isCorrectTypeAnnotation) {
+                    resolve(node.__TypeAnnotation);
+                }
+                else {
+                    resolve(null);
+                }
+            }, outTime);
+            const mySetInterval = setInterval(() => {
+                if (node.__isCorrectTypeAnnotation) {
+                    resolve(node.__TypeAnnotation);
+                    clearInterval(mySetInterval);
+                    clearTimeout(myTimer);
+                }
+            }, 50);
+        });
+        // const res = new Promise((resolve, reject) => {
+        //     Object.defineProperty(node, '__TypeAnnotation', {
+        //         //修改  // 若只指定get方法，不指定set方法，那就默认该属性是只读的
+        //         get() {
+        //             return this.__newTypeAnnotation;
+        //         },
+        //         set: (__TypeAnnotation) => {
+        //             try {
+        //                 if (__TypeAnnotation) {
+        //                     (this as any).__newTypeAnnotation = __TypeAnnotation;
+        //                     resolve(__TypeAnnotation);
+        //                     return;
+        //                 }
+        //                 // 如果一直没变化 500毫秒后就返回没查找到
+        //                 setTimeout(() => {
+        //                     (this as any).__newTypeAnnotation = __TypeAnnotation;
+        //                     resolve(__TypeAnnotation || null);
+        //                 }, 500);
+        //             } catch (err) {
+        //                 console.log(err);
+        //             }
+        //         },
+        //     });
+        // });
+        // res.then((item) => { console.log(item) });
+        // return res;
+    }
+    // 获取节点标注，去动态查
+    async getBaseNodesTypeMap(nodes) {
+        const args = nodes.map((item) => {
+            const { currentSource, fileNode } = item.getCurrentSource();
+            return {
+                filePath: fileNode.getEmbeddedFilePath(),
+                node: item,
+                item: currentSource,
+            };
+        });
+        const typesMap = await this.getQuickInfoNodesTypeMap(args);
+        return typesMap;
+    }
+    _getTypeStrFull(args) {
+        return this.messager.requestCommand('typeStrFull', args);
+    }
+    async getNaslNodeTypeStrFull(args) {
+        const result = await this._getTypeStrFull(args);
+        return result;
+    }
+    /**
+     * 处理删除节点
+     * @param fileNode 当前删除节点的文件级别节点
+     * @param targetNode 当前操作的节点
+     * @param result toTs生成的内容
+     */
+    async handleDelete(fileNode, targetNode, result) {
+        const filePath = fileNode.getEmbeddedFilePath();
+        // 如果要删除，而且当前要删Logic就直接删除并且清除错误
+        /**
+         * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
+         */
+        let outputFiles = [];
+        // 先特殊处理业务组件
+        const pos = getBusinessComponentPos(fileNode);
+        // 删除之前先查一下内容的依赖
+        const newRefs = await this.references({
+            file: result.filePath,
+            line: pos?.line ?? EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
+            offset: pos?.offset ?? EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
+        });
+        // 如果是要删除的内容，就是当前的file节点，要关闭当前文件，就把内容置为空
+        if (fileNode === targetNode) {
+            outputFiles = [{ file: filePath, fileContent: '' }];
+            // 去掉原来存储的当前节点的nasl内存的存储,和错误的存储
+            // 已经删除的就不用在去check错误了
+            // check就会去取类型啥的，没有必要
+            this.diagnosticManager.deleteOwn(fileNode.id);
+            // 删除文件同时删除ls存储nasl 的引用
+            this.file2NodeMap.delete(filePath);
+        }
+        else {
+            // 如果是要删除logic一个小内容，要覆盖全部内容
+            // 其余要删除的都是把原来的file节点的内容全部覆盖一把
+            outputFiles = [{ file: result.filePath, fileContent: result.code }];
+        }
+        // 更新文件之后
+        await this.updateFiles({ outputFiles });
+        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+    }
+    /**
+     * 除去rename场景下的更新
+     * @param fileNode 文件级别的节点
+     * @param targetNode 触发修改的节点
+     * @param result 生成代码的code 和位置信息
+     */
+    async handleChange(fileNode, targetNode, result, action) {
+        this.file2NodeMap.set(result.filePath, fileNode);
+        const outputFiles = [{ file: result.filePath, fileContent: result.code }];
+        // 创建和更新都用update，内部会做判断
+        await this.updateFiles({ outputFiles });
+        // 先特殊处理业务组件
+        const pos = getBusinessComponentPos(fileNode);
+        // 查一下新函数名的依赖
+        const newRefs = await this.references({
+            file: result.filePath,
+            line: pos?.line ?? EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
+            offset: pos?.offset ?? EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
+        });
+        const files = new Set();
+        newRefs.refs.forEach((ref) => {
+            this.filesToCheck.add(ref.file);
+            files.add(ref.file);
+        });
+        // 唤起建立连接弹框
+        // 文件级别的建立连接采取提醒
+        if (action === 'create' && targetNode.__init) {
+            // 清除临时状态, 完成本次创建
+            delete targetNode.__init;
+            if (fileNode === targetNode && files.size > 1) {
+                const confirmParms = {
+                    actionType: 'createEstablishConnection',
+                    node: fileNode,
+                    icon: 'success',
+                };
+                (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => {
+                    // ..
+                });
+            }
+        }
+    }
+    /**
+     * 重命名的更新
+     * @param fileNode 文件级别的节点
+     * @param targetNode 触发修改的节点
+     * @param result 生成代码的code 和位置信息
+     * @param isRename 是不是修改名字
+     * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
+     */
+    async handleRename(fileNode, targetNode, result, oldFilePath) {
+        // rename 场景
+        const outputFiles = [{ file: result.filePath, fileContent: result.code }];
+        // 如果是要修改顶级文件名
+        // file节点和当前改得是同一节点
+        if (fileNode === targetNode) {
+            this.file2NodeMap.delete(oldFilePath);
+            this.file2NodeMap.set(result.filePath, fileNode);
+            // 修改名字新的添加进去，旧的置为空
+            outputFiles.unshift({ file: oldFilePath, fileContent: '' });
+            // 先特殊处理业务组件
+            const pos = getBusinessComponentPos(fileNode);
+            // 查一下旧文件名的依赖
+            const oldRefs = await this.references({
+                file: oldFilePath,
+                line: pos?.line ?? EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
+                offset: pos?.offset ?? EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
+            });
+            oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+            this.filesToCheck.delete(oldFilePath);
+            // 更新文件之后
+            await this.updateFiles({ outputFiles });
+            // 查一下新函数名的依赖
+            const newRefs = await this.references({
+                file: result.filePath,
+                line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
+                offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
+            });
+            const newRefFileList = new Set();
+            newRefs.refs.forEach((ref) => {
+                this.filesToCheck.add(ref.file);
+                newRefFileList.add(ref.file);
+            });
+            // 文件级别重命名，有依赖才唤起弹框
+            // 唤起重命名，提示有连接弹框
+            // 重命名建立连接先不展示弹框了
+            // if (newRefFileList.size > 1) {
+            //     const confirmParms = {
+            //         actionType: 'renameEstablishConnection',
+            //         node: fileNode,
+            //         icon: 'success',
+            //     };
+            //     invokeCommand('tsConfirm.open', confirmParms, () => {});
+            // }
+        }
+        else if (targetNode instanceof concepts_1.ViewElement) {
+            /**
+             * 因为平台类型比较特殊
+             * 修改之后只用查页面本身就好了
+             */
+            // 更新文件之后
+            await this.updateFiles({ outputFiles });
+            const newRefs2 = await this.references({
+                file: fileNode.getEmbeddedFilePath(),
+                line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
+                offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
+            });
+            newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+        }
+        else {
+            // 查一下当前属性依赖的文件
+            const { currentSource, fileNode } = this.getCurrentSource(targetNode);
+            // 如果当前节点存在
+            if (currentSource) {
+                /**
+                 * 其余的节点修改之后直接查本身就可以了
+                 */
+                const oldRefs = await this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character),
+                });
+                oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+                // 更新文件之后
+                await this.updateFiles({ outputFiles });
+                const newRefs2 = await this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.start.character),
+                });
+                newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+            }
+        }
+    }
+    /**
+     * 处理一些节点操作，子节点需要更新并且check的场景
+     * 因为删除，新增父页面，或者重命名会一起
+     * 删除或者新增view而且他有子集 就要执行同样的操作
+     * @param action 当前操作类型
+     * @param fileNode 文件节点
+     * @param targetNode 操作节点  这里要两个相等才会走家去面对哦逻辑
+     * @param oldpath 触发内容的oldpath
+     */
+    async incidentalAction(action, fileNode, targetNode, oldpath) {
+        if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
+            // 删除、更改、新增端
+            if (fileNode instanceof concepts_1.Frontend && (fileNode.views?.length || fileNode.variables?.length)) {
+                const fileNodeChildren = [...fileNode.views, ...fileNode.variables];
+                for (let i = 0; i < fileNodeChildren.length; i++) {
+                    const fileNodeItem = fileNodeChildren[i];
+                    const result = await utils.timeSlicingWithGenerator(fileNodeItem.toEmbeddedTSFile());
+                    fileNodeItem.sourceMap = result.sourceMap;
+                    if (action === 'create') {
+                        await this.handleChange(fileNodeItem, fileNodeItem, result, action);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'delete') {
+                        await this.handleDelete(fileNodeItem, fileNodeItem, result);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'update' && oldpath) {
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const foldName = fileNodeItem.concept === 'View' ? 'views' : 'variables';
+                        const currentOldPath = `${parentPath + foldName}/${fileNodeItem.name}.ts`;
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
+                    }
+                }
+            }
+            // 删除或者新增页面
+            if (fileNode instanceof concepts_1.View && fileNode.children?.length) {
+                const fileNodeChildren = fileNode.children;
+                for (let i = 0; i < fileNodeChildren.length; i++) {
+                    const fileNodeItem = fileNodeChildren[i];
+                    const result = await utils.timeSlicingWithGenerator(fileNodeItem.toEmbeddedTSFile());
+                    fileNodeItem.sourceMap = result.sourceMap;
+                    if (action === 'create') {
+                        await this.handleChange(fileNodeItem, fileNodeItem, result, action);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'delete') {
+                        await this.handleDelete(fileNodeItem, fileNodeItem, result);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'update' && oldpath) {
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const currentOldPath = `${parentPath + fileNodeItem.name}.ts`;
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
+                    }
+                }
+            }
+            // 删除或新增模块
+            // 需要把下面的哦内容全部都更新一遍
+            if (fileNode instanceof concepts_1.Module) {
+                if (fileNode.type === 'interface' && fileNode.isAdd && action === 'create') {
+                    isChangeInterface = true;
+                }
+                const module = targetNode;
+                const results = await utils.timeSlicingWithGenerator(this.contentToFile(module));
+                for (let i = 0; i < results.length; i++) {
+                    const result = results[i];
+                    const node = this.file2NodeMap.get(result.filePath);
+                    if (action === 'create') {
+                        await this.handleChange(node, node, result, action);
+                    }
+                    else {
+                        await this.handleDelete(node, node, result);
+                    }
+                }
+                // 删除模块通知更新列表
+                if (action === 'delete') {
+                    try {
+                        // 如果已经
+                        (0, common_1.invokeCommand)('module.delete', true);
+                    }
+                    catch (err) {
+                        console.log('module.delete', '组件销毁了,不用唤起了');
+                    }
+                }
+            }
+            /**
+             * DataSource只会重命名时候，需要把子集全部重新生成一下
+             */
+            if (fileNode instanceof concepts_1.DataSource) {
+                fileNode.entities.forEach(async (entity) => {
+                    try {
+                        const result = await utils.timeSlicingWithGenerator(entity.toEmbeddedTSFile());
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const currentOldPath = `${parentPath}/entities/${entity.name}.ts`;
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(entity, entity, result, currentOldPath);
+                    }
+                    catch (err) {
+                        console.log(err);
+                    }
+                });
+            }
+        }
+    }
+    async receiveHandleChange($event) {
+        this.singleFileChangeIng = true;
+        // 行为
+        const { action, oldObject = {}, object = {} } = $event;
+        // 根据行为跳过更新文件
+        // 如果更新国际化key，不需要修改ts文件
+        if (Object.keys(object || {}).length === 1 && Object.keys(oldObject).length === 1) {
+            if (object.i18nKey && !oldObject.i18nKey) {
+                return;
+            }
+            if (object.i18nInfo && !oldObject.i18nInfo) {
+                return;
+            }
+            if (!object.i18nKey && oldObject.i18nKey) {
+                // 撤销重做 也跳过更新
+                return;
+            }
+            if (!object.i18nInfo && oldObject.i18nInfo) {
+                // 撤销重做 也跳过更新
+                return;
+            }
+        }
+        const targetNode = $event.target;
+        console.log(targetNode, 'targetNode');
+        // 连接器namespace 没有真实文件，不需要走删除
+        if (targetNode instanceof concepts_1.Namespace && targetNode.parentNode instanceof concepts_1.Connector) {
+            return;
+        }
+        // Connection 相关配置的更新不需要写入文件
+        // i18nInfo 更新不需要写入文件
+        if (targetNode?.parentNode instanceof concepts_1.Connection || targetNode instanceof concepts_1.I18nInfo) {
+            return;
+        }
+        // 当前操作的文件节点
+        const { fileNode } = this.getCurrentSource(targetNode);
+        // 不处理系统配置参数
+        if (fileNode instanceof concepts_1.ConfigProperty && fileNode?.parentNode?.name === 'system') {
+            return;
+        }
+        // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
+        if (!fileNode || fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration || fileNode instanceof concepts_1.Integration) {
+            // module单独处理
+            if (fileNode instanceof concepts_1.Module) {
+                await this.incidentalAction(action, fileNode, targetNode);
+            }
+            return;
+        }
+        // debugger;
+        if (process.env.NODE_ENV === 'development') {
+            console.time('重新生成 TS 文件');
+        }
+        const fileTsPath = fileNode.getEmbeddedFilePath();
+        const result = await utils.timeSlicingWithGenerator(fileNode.toEmbeddedTSFile());
+        if (process.env.NODE_ENV === 'development') {
+            console.timeEnd('重新生成 TS 文件');
+            console.log('重新生成 TS 文件', fileTsPath);
+        }
+        // 当前操作的节点
+        // 如果当前没有生成tsFile
+        if (!result.sourceMap) {
+            return;
+        }
+        // 修改触发修改文件
+        this._debugInFileStorage(targetNode, [
+            {
+                file: result.filePath,
+                fileContent: result.code,
+            },
+        ]);
+        fileNode.sourceMap = result.sourceMap;
+        if (action === 'update' || action === 'create') {
+            if ($event?.field !== 'name') {
+                await this.handleChange(fileNode, targetNode, result, action);
+                await this.incidentalAction(action, fileNode, targetNode);
+            }
+            else {
+                const oldpath = fileNode.getEmbeddedFilePath($event.oldObject.name);
+                await this.handleRename(fileNode, targetNode, result, oldpath);
+                await this.incidentalAction(action, fileNode, targetNode, oldpath);
+            }
+        }
+        // 删除
+        if (action === 'delete') {
+            await this.incidentalAction(action, fileNode, targetNode);
+            await this.handleDelete(fileNode, targetNode, result);
+        }
+        return true;
+    }
+    changeFileNext() {
+        if (!this.singleFileChangeIng) {
+            const item = this.changeStackList.shift();
+            this.receiveHandleChange(item)
+                .catch((err) => {
+                console.log(err, 'receiveHandleChangeErr');
+            })
+                .finally(async () => {
+                // 每一个文件与change接触就把状态置为false，让下一个进入
+                this.singleFileChangeIng = false;
+                if (this.changeStackList.length) {
+                    this.changeFileNext();
+                }
+                else {
+                    if (process.env.NODE_ENV === 'development') {
+                        console.info('校验以下文件', Array.from(this.filesToCheck));
+                    }
+                    await this.getDiagnosticRecordsAndPushAll(Array.from(this.filesToCheck));
+                    this.filesToCheck.clear();
+                }
+            });
+        }
+    }
+    /**
+     * 获取 Connector 对应 Connector 的properties
+     */
+    static getPropertyNames(fileNode) {
+        const names = [];
+        // TODO 如果不存在对应的 Connector 时，应该提示错误
+        if (fileNode) {
+            fileNode.properties.forEach((property) => {
+                names.push(property.name);
+            });
+        }
+        return names;
+    }
+    getNodeCode(fileNode, range) {
+        return (this.tsFiles.get(fileNode.getEmbeddedFilePath()) ?? '').slice(range.start.offset, range.end.offset);
+    }
+};
+__decorate([
+    (0, decorators_1.withQueueExecute)('diagnostic')
+], NaslServer.prototype, "_resolveDiagnosticRecords", null);
+__decorate([
+    (0, decorators_1.withQueueExecute)('annotation')
+], NaslServer.prototype, "getNaslAnnotatedJSON", null);
+NaslServer = NaslServer_1 = __decorate([
+    sentry_1.sentryMonitorNaslServer
+], NaslServer);
+exports.NaslServer = NaslServer;
+//# sourceMappingURL=naslServer.js.map