@lcap/nasl 2.12.0 → 2.13.0-beta

package/out/server/naslServer.js

@@ -1,1733 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/// #if process.env.NODE_ENV
-// import Worker from '../../../ts-worker/dist/bundle.js';
-/// #else
-// import { Worker } from 'worker_threads';
-/// #endif
-const Messager_1 = __importDefault(require("../common/Messager"));
-const concepts_1 = require("../concepts");
-const translator_1 = require("../translator");
-const storage_1 = __importDefault(require("../service/storage"));
-const translator_2 = require("./translator");
-const common_1 = require("../common");
-const diagnostic_1 = __importDefault(require("../manager/diagnostic"));
-const createUiTs_1 = __importDefault(require("./createUiTs"));
-const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
-const utils_1 = require("../utils");
-const EmbeddedTSFileLineMap = {
-    Entity: 3,
-};
-// 要Check的文件
-const filesToCheck = new Set();
-const worker = new Worker('/ts-worker.js');
-const messager = new Messager_1.default({
-    protocol: 'ts-worker',
-    sender: 'ide',
-    context: this,
-    getReceiver: () => worker,
-    getSender: () => worker,
-    handleMessage({ data }) {
-        if (data && data.event === 'publishDiagnostics') {
-            diagnostic_1.default.pushAll(naslServer._resolveDiagnosticRecords(data.records));
-        }
-    },
-});
-let isChangeInterface = false; //判断是否导入接口
-let actionArr = []; //用于导入接口收集更改的节点
-let timer = null; //超时器用于收集导入接口相关
-const naslServer = {
-    messager,
-    worker,
-    /**
-     * 按道理 fileSourceMap: new Map<string, SourceMap>() 比较合理，
-     * 但是要多维护一层 vertex 增删 -> file 增删的关系问题，
-     * 先用挂在点上面，简单的方法实现，后期再考虑解耦
-     */
-    file2NodeMap: new Map(),
-    elementsLogic: {},
-    start() {
-        return this.messager.requestCommand('start');
-    },
-    async createUiTs(allComponent) {
-        const { code, elementsLogic, naslStdlibMap } = await (0, createUiTs_1.default)(allComponent);
-        // 放入生產的uits文件
-        await naslServer.addFile({
-            file: 'nasl.ui.definition.ts',
-            fileContent: code,
-        });
-        Object.keys(naslStdlibMap).forEach(async (libFileName) => {
-            await naslServer.addFile({
-                file: '/' + libFileName,
-                fileContent: naslStdlibMap[libFileName],
-            });
-        });
-        naslServer.elementsLogic = elementsLogic;
-        // 全部文件加载完毕开始初始化
-        await naslServer.getDiagnosticRecordsAndPushAll();
-    },
-    contentToFile(module, results) {
-        module.structures.forEach((structure) => {
-            try {
-                const result = structure.toEmbeddedTSFile();
-                results.push(result);
-                // sourceMap都存在目录级别内容下，在页面层级下去找
-                structure.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, structure);
-            }
-            catch (err) {
-                console.log(err);
-            }
-        });
-        module.dataSources?.forEach((dataSource) => {
-            // 本身dataSource也要生成一个文件用于改名
-            try {
-                const result = dataSource.toEmbeddedTSFile();
-                results.push(result);
-                // sourceMap都存在目录级别内容下，在页面层级下去找
-                dataSource.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, dataSource);
-            }
-            catch (err) {
-                console.log(err);
-            }
-            dataSource.entities.forEach((entity) => {
-                try {
-                    const result = entity.toEmbeddedTSFile();
-                    results.push(result);
-                    // sourceMap都存在目录级别内容下，在页面层级下去找
-                    entity.sourceMap = result.sourceMap;
-                    this.file2NodeMap.set(result.filePath, entity);
-                }
-                catch (err) {
-                    console.log(err);
-                }
-            });
-        });
-        module.interfaces.forEach((_interface) => {
-            try {
-                const result = _interface.toEmbeddedTSFile();
-                results.push(result);
-                // sourceMap都存在目录级别内容下，在页面层级下去找
-                _interface.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, _interface);
-            }
-            catch (err) {
-                console.log(err);
-            }
-        });
-        module.enums.forEach((_enum) => {
-            try {
-                const result = _enum.toEmbeddedTSFile();
-                results.push(result);
-                // sourceMap都存在目录级别内容下，在页面层级下去找
-                _enum.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, _enum);
-            }
-            catch (err) {
-                console.log(err);
-            }
-        });
-        module.logics.forEach((logic) => {
-            try {
-                if (!(logic instanceof concepts_1.Logic))
-                    return;
-                const result = logic.toEmbeddedTSFile();
-                results.push(result);
-                logic.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, logic);
-            }
-            catch (err) {
-                console.log(err);
-            }
-        });
-        // view的生成
-        naslServer.view2TSFile(module.views, results);
-        module.processes.forEach((process) => {
-            try {
-                const result = process.toEmbeddedTSFile();
-                results.push(result);
-                process.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, process);
-            }
-            catch (err) {
-                console.log(err);
-            }
-        });
-        if (module instanceof concepts_1.App) {
-            module.roles.forEach((role) => {
-                try {
-                    const result = role.toEmbeddedTSFile();
-                    results.push(result);
-                    // sourceMap都存在目录级别内容下，在页面层级下去找
-                    role.sourceMap = result.sourceMap;
-                    this.file2NodeMap.set(result.filePath, role);
-                }
-                catch (err) {
-                    console.log(err);
-                }
-            });
-        }
-    },
-    view2TSFile(viewsChildren, results) {
-        // 如果有子页面
-        if (viewsChildren && viewsChildren.length) {
-            viewsChildren.forEach((view) => {
-                try {
-                    const result = view.toEmbeddedTSFile();
-                    results.push(result);
-                    view.sourceMap = result.sourceMap;
-                    this.file2NodeMap.set(result.filePath, view);
-                    if (view.children.length) {
-                        naslServer.view2TSFile(view.children, results);
-                    }
-                }
-                catch (err) {
-                    console.log(err);
-                }
-            });
-        }
-    },
-    async openApp(app) {
-        const results = [];
-        try {
-            // app的创建内容
-            naslServer.contentToFile(app, results);
-            // 其他模块的创建内容
-            app.dependencies.forEach((item) => naslServer.contentToFile(item, results));
-            app.interfaceDependencies.forEach((item) => naslServer.contentToFile(item, results));
-            app.componentDependencies.forEach((item) => naslServer.contentToFile(item, results));
-        }
-        catch (err) {
-            console.log(err);
-        }
-        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) => {
-            callback(value);
-        });
-        // 删除回调
-        (0, common_1.registerCommand)('tsDelete.change', (callback) => {
-            callback();
-        });
-    },
-    async refreshApp(app) {
-        // 清除所有问题
-        diagnostic_1.default.clear();
-        await naslServer.deleteDirectoryFiles({ directoryName: '/embedded' });
-        // 清楚check count的数量
-        await this.messager.requestCommand('_clearTimeout');
-        // 重新加载app下内容
-        await naslServer.openApp(app);
-        // 重新check一遍所有内容
-        await naslServer.getDiagnosticRecordsAndPushAll();
-    },
-    /**
-     * 初始化之前添加文件
-     */
-    addFile(file) {
-        return this.messager.requestCommand('addFile', file);
-    },
-    /**
-     * 只新增文件
-     * @param {*} files
-     */
-    writeFiles(files) {
-        return this.messager.requestCommand('writeFiles', files);
-    },
-    /**
-     * 新增、修改
-     * 删除文件 文件用修改内容为空模拟，防止报错
-     * @param {*} args
-     */
-    updateFiles(args) {
-        return this.messager.requestCommand('updateFiles', args);
-    },
-    /**
-     * 清除一个目录下的所有文件
-     */
-    deleteDirectoryFiles(args) {
-        return this.messager.requestCommand('deleteDirectoryFiles', args);
-    },
-    _debugInFileStorage(node, openFiles) {
-        /// #if process.env.NODE_ENV === 'development'
-        let app = node;
-        if (node.concept !== 'App') {
-            app = node.rootNode || node.app;
-        }
-        return 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) => {
-            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 } = naslServer.getCurrentSource(node);
-        // console.log(currentSource, fileNode);
-        if (currentSource && fileNode) {
-            return naslServer._getValueSelectCompletion({
-                file: fileNode.getEmbeddedFilePath(),
-                range: {
-                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-                },
-                value,
-                noFilterList,
-            });
-        }
-        else {
-            console.log('没找到节点', node, currentSource, fileNode);
-        }
-    },
-    _getValueSelectCompletion(args) {
-        return this.messager.requestCommand('getValueSelectCompletion', args);
-    },
-    // 联合类型切割取出类型
-    getDisplayString2Type(displayString) {
-        // 取出匹配的内容
-        const reg = /\<([^()]+)\>/g;
-        const types = reg.exec(displayString);
-        // 取出提示的类型，组成是数组
-        const typeList = types[1].split(' | ').map((item) => {
-            if (/\<([^()]+)\>/g.exec(item)) {
-                return item;
-            }
-            else if (item.includes(' ')) {
-                const strs = item.split(' ');
-                const type = strs[strs.length - 1];
-                return type;
-            }
-            else if (item.includes('.')) {
-                const strs = item.split('.');
-                const type = strs[strs.length - 1];
-                return type;
-            }
-            else {
-                return item;
-            }
-        });
-        return typeList;
-    },
-    async getTypeQuickinfo(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 } = naslServer.getCurrentSource(callFunction);
-            try {
-                const quickInfo = await naslServer._getTypeQuickinfo({
-                    file: fileNode.getEmbeddedFilePath(),
-                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `nasl.util.C`.length,
-                });
-                if (quickInfo.responseRequired) {
-                    const displayString = quickInfo?.response?.displayString || '';
-                    const typeList = naslServer.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 [];
-                    }
-                    else {
-                        return [{ title: '基础类型', children: res }];
-                    }
-                }
-            }
-            catch (err) {
-                console.log(err);
-                // 如果有异常就先放开全部可选，兜底逻辑
-                return [];
-            }
-        }
-        else {
-            // 字符串 和 inter
-            return [{ title: '基础类型', children: [coreTypeList_1.primitiveTypeList[4]] }];
-        }
-    },
-    async getDataSchemaType(node) {
-        if (!(node instanceof concepts_1.ViewElement))
-            return;
-        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
-        const quickInfo = await naslServer._getTypeQuickinfo({
-            file: fileNode.getEmbeddedFilePath(),
-            line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-            offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `__elements.`.length,
-        });
-        if (quickInfo.responseRequired) {
-            const displayString = quickInfo?.response?.displayString || '';
-            const flag = displayString.includes('<') && displayString.includes('>');
-            if (flag) {
-                let str = '';
-                const types = naslServer.getDisplayString2Type(displayString);
-                if (Array.isArray(types) && types.length) {
-                    const type = types[0];
-                    str = type === 'any' || type === 'unknown' || type === 'never' ? '' : type;
-                }
-                return str;
-            }
-        }
-        return '';
-    },
-    _getTypeQuickinfo(args) {
-        return this.messager.requestCommand('quickInfo', args);
-    },
-    getSelectNextCompletion(node, noFilterList) {
-        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
-        // console.log(currentSource, fileNode);
-        if (currentSource && fileNode) {
-            return naslServer._getSelectNextCompletion({
-                file: fileNode.getEmbeddedFilePath(),
-                range: {
-                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-                },
-                noFilterList,
-            });
-        }
-        else {
-            console.log('没找到节点', currentSource, fileNode);
-        }
-    },
-    _getSelectNextCompletion(args) {
-        return this.messager.requestCommand('getSelectNextCompletion', args);
-    },
-    async getDiagnosticRecords(fileNames) {
-        const records = (await this.messager.requestCommand('getDiagnosticRecords', fileNames));
-        return this._resolveDiagnosticRecords(records);
-    },
-    async getDiagnosticRecordsAndPushAll(fileNames) {
-        const records = await this.getDiagnosticRecords(fileNames);
-        // diagnosticManager.pushAll(records);
-    },
-    _resolveDiagnosticRecords(records) {
-        records.forEach((record) => {
-            const node = this.file2NodeMap.get(record.filePath);
-            if (!node)
-                return;
-            record.id = node.id;
-            record.node = node;
-            // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
-            const oldRecord = diagnostic_1.default.getRecord(record.id);
-            oldRecord?.semanticDiagnostics.forEach((item) => {
-                item.node ? (item.node.tsErrorDetail = undefined) : '';
-            });
-            // 语义诊断
-            if (isChangeInterface) {
-                this.existStructureFix(record.semanticDiagnostics, node, this);
-            }
-            record.semanticDiagnostics = record.semanticDiagnostics
-                .map((diag) => this._resolveDiagnostic(diag, node))
-                .filter((diag) => !!diag);
-            record.semanticDiagnostics.push(...this._attachDiagnostics(node));
-            // 建议诊断
-            // 实体下的建议不用展示，因为都是平台自己写的逻辑
-            // if (node instanceof Entity) {
-            //     record.suggestionDiagnostics = [];
-            // }
-            // if (node instanceof View) {
-            //     // event在view中不展示建议使用,提示关闭掉
-            //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`'event'`));
-            // }
-            // if (node instanceof Logic) {
-            //     // logic在for循环中，不展示any提示
-            //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
-            // }
-            // record.suggestionDiagnostics = record.suggestionDiagnostics
-            //     .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node.sourceMap))
-            //     .filter((diag) => !!diag);
-            record.suggestionDiagnostics = [];
-            // 语法诊断暂时不需要
-        });
-        return records;
-    },
-    _attachDiagnostics(fileNode) {
-        const diagnostics = [];
-        if (fileNode instanceof concepts_1.View) {
-            (0, utils_1.traverse)((current) => {
-                if (current.node.tag) {
-                    current.node.bindAttrs.forEach((bindAttr) => {
-                        if ((bindAttr.model || bindAttr.sync) && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
-                            const diagnostic = {
-                                node: bindAttr,
-                                severity: 'error',
-                                message: '页面元素双向绑定：只允许绑定可赋值的变量和字段。',
-                            };
-                            bindAttr.tsErrorDetail = diagnostic;
-                            diagnostics.push(diagnostic);
-                        }
-                    });
-                }
-            }, { node: { children: fileNode.elements } });
-        }
-        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) {
-                    property.values.forEach((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);
-                        }
-                    });
-                }
-            }
-        }
-        return diagnostics;
-    },
-    /* 接口导入查找 */
-    existStructureFix(semanticDiagnostics, node, that) {
-        let module;
-        semanticDiagnostics.map((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.app;
-                    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).replace(new RegExp(structureName, 'g'), existStructure.name));
-                        actionArr.push({ target: typeAnnotation.parentNode, typeannotation: editTypeAnnotation });
-                    }
-                }
-                return null;
-            }
-            else {
-                return diag;
-            }
-        });
-        if (actionArr.length) {
-            if (timer)
-                return;
-            timer = window.setTimeout(() => {
-                const app = actionArr[0].target.app;
-                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);
-        }
-    },
-    _resolveDiagnostic(diagnostic, fileNode) {
-        const minRange = this._findMinRange(diagnostic, fileNode);
-        const tsErrorDetail = {
-            severity: diagnostic.category === 'error' ? 'error' : 'warning',
-            message: (0, translator_2.translateDiagnosticMessage)(diagnostic.text),
-            // 保留原来的内容方便查询一些问题
-            originalDiagnostic: diagnostic,
-        };
-        if (minRange) {
-            // 节点的error要置为true
-            return (0, translator_2.naslNodeTranslateMessage)(minRange, tsErrorDetail);
-        }
-        else {
-            // 没找到节点， 先把问题暴露出来
-            return {
-                id: undefined,
-                ...tsErrorDetail,
-            };
-        }
-    },
-    _findMinRange(diagnostic, fileNode) {
-        let minRange;
-        const sourceMap = fileNode.sourceMap;
-        for (const [node, item] of sourceMap.entries()) {
-            /**
-             * 当前内容的开始行 <= 诊断开始的行 &&
-             * 当前内容的结束行 >= 诊断结束的行
-             */
-            if ((0, translator_1.lsp2tspNumber)(item.range.start.line) <= diagnostic.start.line && (0, translator_1.lsp2tspNumber)(item.range.end.line) >= diagnostic.end.line) {
-                // 如果找到某一行
-                if ((0, translator_1.lsp2tspNumber)(item.range.start.line) === diagnostic.start.line && (0, translator_1.lsp2tspNumber)(item.range.end.line) === diagnostic.end.line) {
-                    // 在行的范围但是又不在列的范围，不用给默认值，给了反而不对，
-                    // 需要在列的范围内
-                    if ((0, translator_1.lsp2tspNumber)(item.range.start.character) <= diagnostic.start.offset && (0, translator_1.lsp2tspNumber)(item.range.end.character) >= diagnostic.end.offset) {
-                        // 比列更靠近 ，满足条件且长度更短
-                        // 如果先走到下面有一个默认值了就像在if for里面有个表达式
-                        // if for的内容也是包括当前的所以会重新赋值
-                        if (!minRange || item.code.length < minRange.item.code.length) {
-                            minRange = { item, node };
-                        }
-                    }
-                }
-                else {
-                    // 没有节点 或者 行差比较小比已有的小就可以
-                    // 一般出现在一大块上，多半是if for 等等没有参数
-                    if (!minRange || item.range.end.line - item.range.start.line < minRange.item.range.end.line - minRange.item.range.start.line) {
-                        minRange = { node, item };
-                    }
-                }
-            }
-        }
-        if (!minRange) {
-            if (fileNode instanceof concepts_1.View) {
-                return { node: fileNode, item: sourceMap.get(fileNode) };
-            }
-            console.log(diagnostic, 'diagnostic');
-            console.log(sourceMap, 'sourceMap');
-            console.log(minRange, '需要特殊看下，为什么没找到内容-------------');
-        }
-        return minRange;
-    },
-    async _isHaveRef(node) {
-        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
-        let refsList = [];
-        /**
-         * 未完成创建的节点 ，或者异常情况 可能找不到节点
-         */
-        if (currentSource) {
-            const newRefs = await naslServer.references({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-            });
-            refsList = [...newRefs.refs];
-        }
-        else {
-            if (node instanceof concepts_1.Module) {
-                const lists = node.logics || node.structures || node.enums;
-                const moduleName = fileNode.getEmbeddedFilePath();
-                if (lists.length) {
-                    const item = lists[0];
-                    const { fileNode } = naslServer.getCurrentSource(item);
-                    const newRefs = await naslServer.references({
-                        file: fileNode.getEmbeddedFilePath(),
-                        line: 1,
-                        offset: 22, //固定的位置，module的位置信息
-                    });
-                    refsList = newRefs.refs.filter((item) => !item.file.startsWith(moduleName));
-                    // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
-                    refsList.unshift(newRefs.refs[0]);
-                }
-            }
-        }
-        // 如果是DataSource就需要在单独，查一边来修改名字
-        if (node instanceof concepts_1.DataSource) {
-            // 过滤一把不需要改的信息
-            refsList = refsList.filter((item) => {
-                const dataSourceFile = fileNode.getEmbeddedFilePath();
-                const entityFilePrefix = dataSourceFile.replace('.ts', '');
-                /**
-                 * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
-                 * 所以全部过滤掉了,
-                 * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了8个函数之外的引用
-                 * 所以底部内容是8个函数,所以这里就 用entity的行数 减去8个函数的行数,然后其余的在进行处理
-                 * 进行过滤
-                 */
-                // 不要数据源下面的实体里的引用 ,保留原始的节点内容
-                let flag = false;
-                if (item.file.includes(entityFilePrefix)) {
-                    const entity = this.file2NodeMap.get(item.file);
-                    const { currentSource } = naslServer.getCurrentSource(entity);
-                    // 32 8个函数的总行数
-                    if (item.end.line < currentSource.range.end.line - 32 && 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);
-            // 不再当前文件里
-            // 或者在当前列表但是位置小于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) {
-            const logicNode = node.parentNode;
-            const { currentSource } = naslServer.getCurrentSource(logicNode);
-            const parentRefs = await naslServer.references({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-            });
-            refsList = [...refsList, ...parentRefs.refs];
-        }
-        // 如果是参数修改, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来d
-        if (node instanceof concepts_1.Param && node.parentNode instanceof concepts_1.View) {
-            const viewNode = node.parentNode;
-            const { currentSource } = naslServer.getCurrentSource(viewNode);
-            const code = currentSource.code;
-            const viewIndex = code.indexOf(' {');
-            const viewRefs = await naslServer.references({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + viewIndex),
-            });
-            const filterViewRefs = viewRefs.refs.filter((item) => item.lineText.includes('.$destination('));
-            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.range.start.line),
-        //         offset: lsp2tspNumber(currentSource.range.start.character + viewIndex),
-        //     });
-        //     refsList = [...viewRefs.refs];
-        // }
-        /**
-         * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
-         */
-        if (node instanceof concepts_1.ViewElement) {
-            if (currentSource) {
-                const code = currentSource.code;
-                const prefix = '__elements.';
-                const prefixIndex = code.indexOf(prefix) !== -1 ? code.indexOf(prefix) : 0;
-                const methodsNameIndex = prefixIndex + prefix.length;
-                const methods = await naslServer.references({
-                    file: fileNode.getEmbeddedFilePath(),
-                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + methodsNameIndex),
-                });
-                const methodRefs = [];
-                methods.refs.forEach((item) => {
-                    // 定义里的格式，在删除的时候留下来占位
-                    // 重命名的时候会过滤
-                    // 这里只过滤 __elements.button = new nasl.ui.Button<any>这种格式
-                    // if (item.lineText.includes('__elements.') && item.lineText.includes('new nasl.ui.'))
-                    //     return false;
-                    // 处理声明组件名可能重复的问题， 查找引用不提示
-                    const find = methodRefs.find((findItem) => item.lineText === findItem.lineText && item.lineText.includes(': nasl.ui.'));
-                    if (!find) {
-                        methodRefs.push(item);
-                    }
-                });
-                refsList = [...methodRefs];
-            }
-        }
-        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) {
-                // 如果节点是TypeAnnotation类型,
-                // 很复杂，可能是多级嵌套结构
-                // 不一定只修改typeName
-                if (minRange.node instanceof concepts_1.TypeAnnotation) {
-                    // console.log(record);
-                    // 如果是fake的逻辑，内部的重命名都不需要修改
-                    // if ((minRange.node?.parentNode as any).logic && (minRange.node?.parentNode as any).logic?.fake) {
-                    //     return null;
-                    // }
-                    minRange.setTypeMethods = 'setTypeName';
-                }
-                // 如果节点是logic修改引发calllogic修改
-                if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Logic) {
-                    minRange.setTypeMethods = 'setCalleeName';
-                }
-                if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.ViewElement) {
-                    minRange.setTypeMethods = 'setCalleeNamespace';
-                    minRange.newValue = 'elements.' + newValue + '.logics';
-                }
-                // 如果节点是实体修改引发calllogic修改
-                if (minRange.node instanceof concepts_1.CallLogic && (node instanceof concepts_1.Entity || node instanceof concepts_1.View || node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
-                    // 匹配到的内容，当前这一行的内容；
-                    // 因为要用下面的点位信息
-                    /**
-                     * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
-                     * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
-                     * 但是505 要改名为 666 ，要存的是666
-                     * 'app.views.Student.views.404.views.666.views.update'
-                     * 1.取到转后的
-                     * 2.在匹配到的内容中取转后的namespace的位置
-                     * 3.然后把namespace中的 $替换成 ''
-                     *
-                     */
-                    const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
-                    // 先看下标位置
-                    const lineText = record.lineText;
-                    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;
-                    // 如果name不改，那就是要改命名空间
-                    if (newValue === name) {
-                        const namespace = minRange.node.namespace;
-                        // 先看下标位置
-                        const lineText = record.lineText;
-                        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;
-                    }
-                }
-                // 如果是枚举修改，枚举的值刚好在Identifier 中选了 就修改值
-                if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Enum) {
-                    minRange.newValue = newValue;
-                    minRange.setTypeMethods = 'setName';
-                }
-                // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
-                if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Logic) {
-                    minRange.newValue = newValue;
-                    minRange.setTypeMethods = 'setName';
-                }
-                // 如果节点是MemberExpression表达式
-                if (minRange.node instanceof concepts_1.MemberExpression) {
-                    // 枚举key的特殊性，因为它不是原来的key+value形式的
-                    // 是加了中括号啥的，所以直接赋值新值
-                    if (node instanceof concepts_1.EnumItem) {
-                        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 (minRange.node instanceof concepts_1.EntityProperty && node instanceof concepts_1.Entity) {
-                    minRange.setTypeMethods = 'setRelationEntity';
-                }
-                // 如果是修改实体属性，要同步实体属性
-                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 = 'setPropertyNameList';
-                        minRange.newValue = newPropertyNameList;
-                    }
-                }
-                // 如果是跳转逻辑的修改
-                // 跳转逻辑本身页面 都需要带 View前缀
-                if (node instanceof concepts_1.View && minRange.node instanceof concepts_1.Destination) {
-                    /**
-                     * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
-                     * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
-                     * 但是505 要改名为 666 ，要存的是666
-                     * 'app.views.Student.views.404.views.666.views.update'
-                     * 1.取到转后的
-                     * 2.在匹配到的内容中取转后的namespace的位置
-                     * 3.然后把namespace中的 $替换成 ''
-                     *
-                     */
-                    const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
-                    const tsName = minRange.node.tsName;
-                    const oldValue = tsCalleeNamespace + '.' + tsName;
-                    // 先看下标位置
-                    const lineText = record.lineText;
-                    const index = lineText.indexOf(oldValue);
-                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
-                    const start = record.start.offset - index - 1;
-                    const end = record.end.offset - index - 1;
-                    if (start > tsCalleeNamespace.length) {
-                        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;
-                    }
-                }
-                // 如果是事件修改
-                // 如果是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.tsCalleeNamespace;
-                        const oldValue = tsCalleeNamespace;
-                        // 先看下标位置
-                        const lineText = record.lineText;
-                        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 (minRange.node instanceof concepts_1.EntityProperty && node instanceof concepts_1.EnumItem) {
-                    minRange.setTypeMethods = 'setDefaultValue';
-                }
-                if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.Entity) {
-                    minRange.setTypeMethods = 'setEntityAsName';
-                }
-                // 如果修改的是dataSource字段
-                if (node instanceof concepts_1.DataSource) {
-                    const setTypeNamespace = (typeNamespace, record) => {
-                        // 先看下标位置
-                        const lineText = record.lineText;
-                        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.setTypeMethods = 'setDataSource';
-                    }
-                }
-                if (minRange.node instanceof concepts_1.QueryGroupByExpression && node instanceof concepts_1.Entity) {
-                    minRange.setTypeMethods = 'setEntityAsName';
-                }
-                if ((minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) && node instanceof concepts_1.Entity) {
-                    minRange.setTypeMethods = 'setEntityName';
-                }
-                if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.EntityProperty) {
-                    minRange.setTypeMethods = 'setPropertyName';
-                }
-                if (minRange.node instanceof concepts_1.QueryGroupByExpression && node instanceof concepts_1.EntityProperty) {
-                    minRange.setTypeMethods = 'setPropertyName';
-                }
-                // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
-                if ((minRange.node instanceof concepts_1.Param || minRange.node instanceof concepts_1.Variable || minRange.node instanceof concepts_1.Return)
-                    && (node instanceof concepts_1.Entity || node instanceof concepts_1.Enum || node instanceof concepts_1.Structure)) {
-                    return null;
-                }
-                if (minRange.node instanceof concepts_1.Destination && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
-                    return null;
-                }
-                if (minRange.node instanceof concepts_1.Assignee && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
-                    return null;
-                }
-                // 枚举修改枚举名，比较特殊
-                if (minRange.node instanceof concepts_1.EnumItem && node instanceof concepts_1.Enum) {
-                    // 什么都不做，用来跳过修改
-                    return null;
-                }
-                // params修改 查找bindevent不需要修改
-                if (minRange.node instanceof concepts_1.BindEvent && node instanceof concepts_1.Param) {
-                    return null;
-                }
-                // 如果是子页面修改
-                // 父页面引起子页面改名，就可以不改了，自动同步
-                if (minRange.node instanceof concepts_1.View && node instanceof concepts_1.View && minRange.node !== node) {
-                    return null;
-                }
-                /**
-                 * 屏蔽组件生成内容块中的变量或者逻辑，出现在表格选择中。在bindAttr中还会有，所以过滤一把
-                 */
-                if ((minRange.node instanceof concepts_1.Identifier || minRange.node instanceof concepts_1.MemberExpression) && node instanceof concepts_1.Param && minRange.node.parentNode instanceof concepts_1.BindAttribute) {
-                    return null;
-                }
-                // 修改element引发view改名
-                if (node instanceof concepts_1.ViewElement && minRange.node instanceof concepts_1.View) {
-                    return null;
-                }
-                // params修改 查找View不需要修改
-                // 逻辑改名，触发了在定义里面的，element定义，的值，直接掠过
-                if (minRange.node instanceof concepts_1.View && (node instanceof concepts_1.Logic || node instanceof concepts_1.Param)) {
-                    /**
-                     * 这里过滤一下，一些查找引用，重复的内容，直接屏蔽掉，防止操作重复
-                     * 因为在生成的时候 ，可能弄了一些副作用的引用
-                     */
-                    // 本来是想在上面过滤一把的先放到这里匹配这两个的时候 就会找到
-                    // refsList = refsList.filter((item) => {
-                    //     屏蔽组件查找查到定义这里，也过滤一下
-                    //     if (item.lineText.includes(': nasl.ui.'))
-                    //         return false;
-                    //     return true;
-                    // });
-                    return null;
-                }
-                /**
-                 * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
-                 * 流程改名不触发Logic改名
-                 * 如果是修改param查找到logic就不操作
-                 * 除非想在内部修改别的内容所以暂时屏蔽掉
-                 */
-                if (minRange.node instanceof concepts_1.Logic && node !== minRange.node) {
-                    return null;
-                }
-            }
-            else {
-                console.log('没找到节点需要排查');
-                console.log(record, fileNode.sourceMap);
-            }
-            return minRange;
-        })
-            // 过滤掉不需要操作的
-            .filter((item) => !!item);
-        console.log(result);
-        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 (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
-                    minRange.node.setCalleeArgName(parantNode);
-                }
-                // 如果节点参数增加页面也要更新
-                if (minRange.node instanceof concepts_1.Destination && node instanceof concepts_1.Param) {
-                    minRange.node.setViewArgument(parantNode);
-                }
-            }
-        });
-    },
-    _addParamsPrepare(node, refsList, needAdd) {
-        if (needAdd) {
-            const App = node?.rootNode;
-            const parantNode = node?.parentNode;
-            // 收集修改
-            App.emit('collect:start', {
-                actionMsg: '增加逻辑参数',
-            });
-            node.create({
-                index: 0,
-                parentNode: parantNode,
-                parentKey: node.parentKey,
-            });
-            naslServer._addParamsEffect(refsList, node);
-            // 结束修改 ，批量操作
-            App.emit('collect:end');
-            return node;
-        }
-        naslServer._addParamsEffect(refsList, node);
-        return node;
-    },
-    // 查找引用
-    async findReferences(node) {
-        let refsList = await naslServer._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) {
-                    // 拼装树
-                    naslServer._getTreeMap(minRange, fileNode, resMap, nodeMap);
-                }
-            });
-            console.log(resMap, 'resMap');
-            if (resMap.size > 0) {
-                result = naslServer.handleTreeMap(resMap);
-            }
-        }
-        catch (err) {
-            console.log(err);
-        }
-        console.log(result);
-        return result;
-    },
-    // 获取节点的上层渲染
-    _getTreeMap(minRange, fileNode, resMap, nodeMap) {
-        const minRangeNode = minRange.node;
-        let currentNode = minRangeNode;
-        let parantNode = currentNode.parentNode;
-        // 顺序队列
-        const queue = [];
-        // 先插入自己,如果没有在往上找,
-        // 一直到file节点的父级
-        while (!(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;
-            // 需要放到数组中
-            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 = naslServer.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 = naslServer._recursionCreateResult(root, map);
-        return children;
-    },
-    /**
-     * 递归调用输出结果
-     * @param root 一个根节点
-     * @param map 当前所有节点的map对象
-     * @returns 当前节点，最后输出所有节点
-     */
-    _recursionCreateResult(root, map) {
-        const children = map.get(root).map((item) => naslServer._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.sourceMap;
-        let fileNode = node;
-        // 如果没有sourceMap,就继续向上找 ,或者到module结束
-        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
-        // 如果当前节点是view就不要向上查找了
-        while (!sourceMap
-            && fileNode
-            && !(fileNode.parentNode instanceof concepts_1.App)
-            && !(fileNode.parentNode instanceof concepts_1.Module)
-            && !(fileNode.parentNode instanceof concepts_1.DataSource)
-            && !(fileNode instanceof concepts_1.View)) {
-            fileNode = fileNode.parentNode;
-            sourceMap = fileNode?.sourceMap;
-        }
-        const currentSource = sourceMap && sourceMap.get(node);
-        if (currentSource) {
-            // 这里处理一些加了注解或者需要定制位置的节点的取值
-            naslServer.handlingCurrentSourceException(currentSource, node);
-            return { currentSource, fileNode };
-        }
-        return { fileNode };
-    },
-    handlingCurrentSourceException(currentSource, node) {
-        // 如果有前面的一些注解，元素在最后一行输出的值就给最后一行
-        if (node instanceof concepts_1.EntityProperty) {
-            if (currentSource.range.start.line !== currentSource.range.end.line) {
-                currentSource.range.start = { ...currentSource.range.start, line: currentSource.range.end.line };
-            }
-        }
-    },
-    // 获取element方法的可选值
-    getFieldKeySelectCompletion(node, fieldKey) {
-        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
-        if (currentSource && fileNode) {
-            return naslServer._getFieldKeySelectCompletion({
-                file: fileNode.getEmbeddedFilePath(),
-                range: {
-                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-                },
-                getFieldKey: fieldKey,
-            });
-        }
-        else {
-            console.log('没找到节点', currentSource, fileNode);
-        }
-    },
-    _getFieldKeySelectCompletion(args) {
-        return this.messager.requestCommand('getFieldKeySelectCompletion', args);
-    },
-};
-/**
- * 处理删除节点
- * @param fileNode 当前删除节点的文件级别节点
- * @param targetNode 当前操作的节点
- * @param result toTs生成的内容
- */
-async function handleDelete(fileNode, targetNode, result) {
-    const filePath = fileNode.getEmbeddedFilePath();
-    // 如果要删除，而且当前要删Logic就直接删除并且清除错误
-    /**
-     * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
-     */
-    let outputFiles = [];
-    // 删除之前先查一下内容的依赖
-    const newRefs = await naslServer.references({
-        file: result.filePath,
-        line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
-        offset: 6,
-    });
-    // 如果是要删除的内容，就是当前的file节点，要关闭当前文件，就把内容置为空
-    if (fileNode === targetNode) {
-        outputFiles = [{ file: filePath, fileContent: '' }];
-    }
-    else {
-        // 如果是要删除logic一个小内容，要覆盖全部内容
-        // 其余要删除的都是把原来的file节点的内容全部覆盖一把
-        outputFiles = [{ file: result.filePath, fileContent: result.code }];
-    }
-    // 更新文件之后
-    await naslServer.updateFiles({ outputFiles });
-    newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-}
-/**
- * 除去rename场景下的更新
- * @param fileNode 文件级别的节点
- * @param targetNode 触发修改的节点
- * @param result 生成代码的code 和位置信息
- */
-async function handleChange(fileNode, targetNode, result, action) {
-    naslServer.file2NodeMap.set(result.filePath, fileNode);
-    const outputFiles = [{ file: result.filePath, fileContent: result.code }];
-    // 创建和更新都用update，内部会做判断
-    await naslServer.updateFiles({ outputFiles });
-    // 查一下新函数名的依赖
-    const newRefs = await naslServer.references({
-        file: result.filePath,
-        line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
-        offset: 6,
-    });
-    newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-    // 唤起建立连接弹框
-    // 文件级别的建立连接采取提醒
-    if (action === 'create' && targetNode.__init) {
-        // 清除临时状态, 完成本次创建
-        delete targetNode.__init;
-        if (fileNode === targetNode && filesToCheck.size > 1) {
-            const confirmParms = {
-                actionType: 'createEstablishConnection',
-                node: fileNode,
-                icon: 'success',
-            };
-            (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => { });
-        }
-    }
-}
-/**
- * 重命名的更新
- * @param fileNode 文件级别的节点
- * @param targetNode 触发修改的节点
- * @param result 生成代码的code 和位置信息
- * @param isRename 是不是修改名字
- * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
- */
-async function handleRename(fileNode, targetNode, result, oldFilePath) {
-    // rename 场景
-    const outputFiles = [{ file: result.filePath, fileContent: result.code }];
-    // 如果是要修改顶级文件名
-    // file节点和当前改得是同一节点
-    if (fileNode === targetNode) {
-        naslServer.file2NodeMap.delete(oldFilePath);
-        naslServer.file2NodeMap.set(result.filePath, fileNode);
-        // 修改名字新的添加进去，旧的置为空
-        outputFiles.unshift({ file: oldFilePath, fileContent: '' });
-        // 查一下旧文件名的依赖
-        const oldRefs = await naslServer.references({
-            file: oldFilePath,
-            line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
-            offset: 6,
-        });
-        oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-        filesToCheck.delete(oldFilePath);
-        // 更新文件之后
-        await naslServer.updateFiles({ outputFiles });
-        // 查一下新函数名的依赖
-        const newRefs = await naslServer.references({
-            file: result.filePath,
-            line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
-            offset: 6,
-        });
-        const newRefFileList = new Set();
-        newRefs.refs.forEach((ref) => {
-            filesToCheck.add(ref.file);
-            newRefFileList.add(ref.file);
-        });
-        // 文件级别重命名，有依赖才唤起弹框
-        // 唤起重命名，提示有连接弹框
-        // 重命名建立连接先不展示弹框了
-        // if (newRefFileList.size > 1) {
-        //     const confirmParms = {
-        //         actionType: 'renameEstablishConnection',
-        //         node: fileNode,
-        //         icon: 'success',
-        //     };
-        //     invokeCommand('tsConfirm.open', confirmParms, () => {});
-        // }
-    }
-    else {
-        // 查一下当前属性依赖的文件
-        const { currentSource, fileNode } = naslServer.getCurrentSource(targetNode);
-        if (currentSource) {
-            const oldRefs = await naslServer.references({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-            });
-            oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-            // 更新文件之后
-            await naslServer.updateFiles({ outputFiles });
-            const newRefs2 = await naslServer.references({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-            });
-            newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
-        }
-    }
-}
-/**
- * 处理一些节点操作，子节点需要更新并且check的场景
- * 因为删除，新增父页面，或者重命名会一起
- * 删除或者新增view而且他有子集 就要执行同样的操作
- * @param action 当前操作类型
- * @param fileNode 文件节点
- * @param targetNode 操作节点  这里要两个相等才会走家去面对哦逻辑
- * @param oldpath 触发内容的oldpath
- */
-async function incidentalAction(action, fileNode, targetNode, oldpath) {
-    if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
-        // 删除或者新增页面
-        if (fileNode instanceof concepts_1.View && fileNode.children?.length) {
-            const fileNodeChildren = fileNode.children;
-            for (let i = 0; i < fileNodeChildren.length; i++) {
-                const fileNodeItem = fileNodeChildren[i];
-                const result = fileNodeItem.toEmbeddedTSFile();
-                fileNodeItem.sourceMap = result.sourceMap;
-                if (action === 'create') {
-                    await handleChange(fileNodeItem, fileNodeItem, result, action);
-                    await incidentalAction(action, fileNodeItem, fileNodeItem);
-                }
-                else if (action === 'delete') {
-                    await handleDelete(fileNodeItem, fileNodeItem, result);
-                    await incidentalAction(action, fileNodeItem, fileNodeItem);
-                }
-                else if (action === 'update' && oldpath) {
-                    const parentPath = oldpath.replace('.ts', '/');
-                    const currentOldPath = parentPath + fileNodeItem.name + '.ts';
-                    // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
-                    await handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
-                    await incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
-                }
-            }
-        }
-        // 删除或新增模块
-        // 需要把下面的哦内容全部都更新一遍
-        if (fileNode instanceof concepts_1.Module) {
-            if (fileNode.type === 'interface' && fileNode.isAdd && action === 'create') {
-                isChangeInterface = true;
-            }
-            const module = targetNode;
-            const results = [];
-            naslServer.contentToFile(module, results);
-            for (let i = 0; i < results.length; i++) {
-                const result = results[i];
-                const node = naslServer.file2NodeMap.get(result.filePath);
-                if (action === 'create') {
-                    await handleChange(node, node, result, action);
-                }
-                else {
-                    await handleDelete(node, node, result);
-                }
-            }
-            // 删除模块通知更新列表
-            if (action === 'delete') {
-                try {
-                    // 如果已经
-                    (0, common_1.invokeCommand)('module.delete', true);
-                }
-                catch (err) {
-                    console.log('module.delete', '组件销毁了,不用唤起了');
-                }
-            }
-        }
-        /**
-         * DataSource只会重命名时候，需要把子集全部重新生成一下
-         */
-        if (fileNode instanceof concepts_1.DataSource) {
-            fileNode.entities.forEach(async (entity) => {
-                try {
-                    const result = entity.toEmbeddedTSFile();
-                    const parentPath = oldpath.replace('.ts', '/');
-                    const currentOldPath = parentPath + '/entities/' + entity.name + '.ts';
-                    // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
-                    await handleRename(entity, entity, result, currentOldPath);
-                }
-                catch (err) {
-                    console.log(err);
-                }
-            });
-        }
-    }
-}
-async function receiveHandleChange($event) {
-    // 行为
-    const action = $event.action;
-    const targetNode = $event.target;
-    // 当前操作的文件节点
-    const { fileNode } = naslServer.getCurrentSource(targetNode);
-    // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
-    if (!fileNode || fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration) {
-        // module单独处理
-        if (fileNode instanceof concepts_1.Module) {
-            await incidentalAction(action, fileNode, targetNode);
-        }
-        return;
-    }
-    const result = fileNode.toEmbeddedTSFile();
-    // 当前操作的节点
-    // 如果当前没有生成tsFile
-    if (!result) {
-        return;
-    }
-    // 修改触发修改文件
-    naslServer._debugInFileStorage($event.currentTarget, [
-        {
-            file: result.filePath,
-            fileContent: result.code,
-        },
-    ]);
-    fileNode.sourceMap = result.sourceMap;
-    if (action === 'update' || action === 'create') {
-        if ($event?.field !== 'name') {
-            await handleChange(fileNode, targetNode, result, action);
-            await incidentalAction(action, fileNode, targetNode);
-        }
-        else {
-            const oldpath = fileNode.getEmbeddedFilePath($event.oldObject.name);
-            await handleRename(fileNode, targetNode, result, oldpath);
-            await incidentalAction(action, fileNode, targetNode, oldpath);
-        }
-    }
-    // 删除
-    if (action === 'delete') {
-        await incidentalAction(action, fileNode, targetNode);
-        await handleDelete(fileNode, targetNode, result);
-    }
-    return true;
-}
-// 监听所有改变操作
-translator_1.embeddedTSEmitter.on('change', ($event) => {
-    // 收集到一个行为集合
-    const eventValue = $event.value;
-    const stackList = [];
-    eventValue.forEach(async (item) => {
-        stackList.push(item.originEvent);
-    });
-    // 异步状态机,一个完成了在执行下一个
-    function next() {
-        const item = stackList.shift();
-        receiveHandleChange(item).then(async () => {
-            if (stackList.length) {
-                next();
-            }
-            else {
-                console.log('filesToCheck', filesToCheck, filesToCheck.size);
-                await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-                filesToCheck.clear();
-            }
-        });
-    }
-    // 如果有长度开始执行状态机
-    if (stackList.length) {
-        next();
-    }
-});
-naslServer.messager.options.context = naslServer;
-exports.default = naslServer;
-//# sourceMappingURL=naslServer.js.map