@lcap/nasl 0.3.15 → 1.0.0-alpha.10

package/src/server/naslServer.ts

@@ -0,0 +1,1545 @@
+/// #if process.env.NODE_ENV
+// import Worker from '../../../ts-worker/dist/bundle.js';
+/// #else
+// import { Worker } from 'worker_threads';
+/// #endif
+import Messager from '../common/Messager';
+import * as tsProtocol from 'typescript/lib/protocol';
+import {
+    Module,
+    BaseNode,
+    App,
+    Structure,
+    Logic,
+    Entity,
+    TypeAnnotation,
+    MemberExpression,
+    EntityProperty,
+    EntityIndex,
+    View,
+    Destination,
+    Enum,
+    BindEvent,
+    QueryFromExpression,
+    QueryJoinExpression,
+    QueryFieldExpression,
+    Identifier,
+    CallLogic,
+    EnumItem,
+    Param,
+    Process,
+    Interface,
+    Argument,
+    ViewElement,
+    BindAttribute,
+    Assignment,
+    CallQueryComponent,
+    Role,
+    Configuration,
+} from '../concepts';
+import { lsp2tspNumber, SourceMap, SourceMapItem, embeddedTSEmitter } from '../translator';
+import axios from '../service/storage';
+import { transformType, translateDiagnosticMessage } from './translator';
+import { EventPayload, invokeCommand, registerCommand } from '../common';
+import { DiagnosticRecord, Diagnostic, default as diagnosticManager } from '../manager/diagnostic';
+import formatUiTs from './createUiTs';
+import { primitiveTypeList } from '../concepts/basics/types/coreTypeList';
+
+const EmbeddedTSFileLineMap: { [name: string]: number } = {
+    Entity: 3,
+};
+
+interface FileNode extends BaseNode {
+    getEmbeddedFilePath(name?: string): string;
+    toEmbeddedTSFile(): {
+        code: string;
+        filePath: string;
+        sourceMap: SourceMap;
+    };
+}
+
+interface setNameNode extends BaseNode {
+    setName(name: string): any;
+    [propname: string]: any;
+}
+interface treeNode {
+    [propName: string]: QuoteNode[];
+}
+export { transformType, translateDiagnosticMessage };
+const worker = new Worker('/ts-worker.js');
+const messager = new Messager({
+    protocol: 'ts-worker',
+    sender: 'ide',
+    context: this,
+    getReceiver: () => worker as any,
+    getSender: () => worker as any,
+    handleMessage({ data }: any) {
+        if (data && data.event === 'publishDiagnostics') {
+            diagnosticManager.pushAll(naslServer._resolveDiagnosticRecords(data.records));
+        }
+    },
+});
+
+interface MinRange {
+    node: BaseNode;
+    item: SourceMapItem;
+}
+interface reNameMinRange extends MinRange {
+    newValue?: any;
+    setTypeMethods?: string;
+}
+// 查找引用节点
+interface QuoteNode {
+    name: any;
+    node: BaseNode;
+    children?: QuoteNode[];
+}
+// 组装后的resMap， 一个页面节点下可能有多个queue
+interface ResMap {
+    [propName: string]: {
+        queue: QuoteNode[][];
+        name: string;
+        concept: string;
+        node: BaseNode;
+    };
+}
+const naslServer = {
+    messager,
+    worker,
+    /**
+     * 按道理 fileSourceMap: new Map<string, SourceMap>() 比较合理，
+     * 但是要多维护一层 vertex 增删 -> file 增删的关系问题，
+     * 先用挂在点上面，简单的方法实现，后期再考虑解耦
+     */
+    file2NodeMap: new Map<string, BaseNode>(),
+    elementsLogic: <{ [elementLogicName: string]: Array<Logic> }>{},
+    start() {
+        return this.messager.requestCommand('start');
+    },
+    async createUiTs(allComponent: any) {
+        const { code, elementsLogic } = await formatUiTs(allComponent);
+        // 放入生產的uits文件
+        await naslServer.addFile({
+            file: 'nasl.ui.definition.ts',
+            fileContent: code,
+        });
+        naslServer.elementsLogic = elementsLogic;
+        // 全部文件加载完毕开始初始化
+        await naslServer.getDiagnosticRecordsAndPushAll();
+    },
+    contentToFile(module: Module | App, results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
+        module.structures.forEach((structure) => {
+            const result = structure.toEmbeddedTSFile();
+            results.push(result);
+            // sourceMap都存在目录级别内容下，在页面层级下去找
+            structure.sourceMap = result.sourceMap;
+            this.file2NodeMap.set(result.filePath, structure);
+        });
+        module.entities.forEach((entity) => {
+            const result = entity.toEmbeddedTSFile();
+            results.push(result);
+            // sourceMap都存在目录级别内容下，在页面层级下去找
+            entity.sourceMap = result.sourceMap;
+            this.file2NodeMap.set(result.filePath, entity);
+        });
+        module.interfaces.forEach((_interface) => {
+            const result = _interface.toEmbeddedTSFile();
+            results.push(result);
+            // sourceMap都存在目录级别内容下，在页面层级下去找
+            _interface.sourceMap = result.sourceMap;
+            this.file2NodeMap.set(result.filePath, _interface);
+        });
+        module.enums.forEach((_enum) => {
+            const result = _enum.toEmbeddedTSFile();
+            results.push(result);
+            // sourceMap都存在目录级别内容下，在页面层级下去找
+            _enum.sourceMap = result.sourceMap;
+            this.file2NodeMap.set(result.filePath, _enum);
+        });
+        module.logics.forEach((logic) => {
+            if (!(logic instanceof Logic))
+                return;
+            const result = logic.toEmbeddedTSFile();
+            results.push(result);
+            logic.sourceMap = result.sourceMap;
+            this.file2NodeMap.set(result.filePath, logic);
+        });
+
+        // view的生成
+        naslServer.view2TSFile(module.views, results);
+
+        module.processes.forEach((process) => {
+            const result = process.toEmbeddedTSFile();
+            results.push(result);
+            process.sourceMap = result.sourceMap;
+            this.file2NodeMap.set(result.filePath, process);
+        });
+
+        if (module instanceof App) {
+            module.roles.forEach((role) => {
+                const result = role.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                role.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, role);
+            });
+        }
+    },
+    view2TSFile(viewsChildren: View[], results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
+        // 子页面
+        viewsChildren.forEach((view) => {
+            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);
+            }
+        });
+    },
+    async openApp(app: App) {
+        const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
+        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);
+        // 修改名称回调
+        registerCommand('tsRename.change', (value: boolean, callback: Function) => {
+            callback(value);
+        });
+        // 删除回调
+        registerCommand('tsDelete.change', (callback: Function) => {
+            callback();
+        });
+    },
+    async importModule(module: Module) {
+        const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
+        try {
+            naslServer.contentToFile(module, results);
+        } catch (err) {
+            console.log(err);
+        }
+        const files = results.map((result) => ({
+            file: result.filePath,
+            fileContent: result.code,
+        }));
+        await this.writeFiles(files);
+        this._debugInFileStorage(module.parentNode as App, files);
+    },
+    /**
+     * 初始化之前添加文件
+     */
+    addFile(file: tsProtocol.OpenRequestArgs) {
+        return this.messager.requestCommand('addFile', file);
+    },
+    /**
+     * 只新增文件
+     * @param {*} files
+     */
+    writeFiles(files: Array<tsProtocol.OpenRequestArgs>) {
+        return this.messager.requestCommand('writeFiles', files);
+    },
+    /**
+     * 新增或修改文件
+     * @param {*} files
+     * @returns
+     */
+    outputFiles(files: Array<tsProtocol.OpenRequestArgs>) {
+        return this.messager.requestCommand('outputFiles', files);
+    },
+    /**
+     * 新增、修改
+     * 删除文件 文件用修改内容为空模拟，防止报错
+     * @param {*} args
+     */
+    updateFiles(args: { outputFiles: Array<tsProtocol.OpenRequestArgs> }) {
+        return this.messager.requestCommand('updateFiles', args);
+    },
+    _debugInFileStorage(node: BaseNode, openFiles: Array<tsProtocol.OpenRequestArgs>) {
+        let app = node;
+        if (node.concept !== 'App') {
+            app = (node as any).rootNode || (node as any).app;
+        }
+        return Promise.all(openFiles.map(async (file) => {
+            const res = await axios.post('/api/App/debugEmbedded?id=' + app.id, file);
+            return res.data;
+        }));
+    },
+    open() {
+        return this.messager.requestCommand('open');
+    },
+    updateOpen(args: tsProtocol.UpdateOpenRequestArgs) {
+        return this.messager.requestCommand('updateOpen', args);
+    },
+    fileReferences(filePath: string) {
+        return this.messager.requestCommand('fileReferences', filePath);
+    },
+    async references(args: tsProtocol.FileLocationRequestArgs) {
+        return ((await this.messager.requestCommand('references', args)) as any)?.response as tsProtocol.ReferencesResponseBody;
+    },
+    getValueSelectCompletion(node: BaseNode, value: string, noFilterList?: Array<string>) {
+        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
+        // console.log(currentSource, fileNode);
+        if (currentSource && fileNode) {
+            return naslServer._getValueSelectCompletion({
+                file: (fileNode as FileNode).getEmbeddedFilePath(),
+                range: {
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character),
+                },
+                value,
+                noFilterList,
+            });
+        } else {
+            console.log('没找到节点', node, currentSource, fileNode);
+        }
+    },
+    _getValueSelectCompletion(args: any) {
+        return this.messager.requestCommand('getValueSelectCompletion', args);
+    },
+    // 联合类型切割取出类型
+    getDisplayString2Type(displayString: string) {
+        // 取出匹配的内容
+        const reg = /\<([^()]+)\>/g;
+        const types = reg.exec(displayString);
+        // 取出提示的类型，组成是数组
+        const typeList: string[] = types[1].split(' | ').map((item: string) => {
+            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: BaseNode) {
+        console.log(node);
+        if (node instanceof Identifier) {
+            const callFunction = node.parentNode.parentNode;
+            /**
+             * currentSource callFunction 的节点，要去到当前节点的位置
+             * nasl.util.Convert(xxx),所以取到的位置要 + `nasl.util.C` 的长度
+             * fileNode
+             */
+            const { currentSource, fileNode } = naslServer.getCurrentSource(callFunction);
+            const quickInfo = await naslServer._getTypeQuickinfo({
+                file: (fileNode as FileNode).getEmbeddedFilePath(),
+                line: lsp2tspNumber(currentSource.range.start.line),
+                offset: lsp2tspNumber(currentSource.range.start.character) + `nasl.util.C`.length,
+            });
+            if (quickInfo.responseRequired) {
+                const displayString = quickInfo?.response?.displayString || '';
+                const typeList = naslServer.getDisplayString2Type(displayString);
+                let res: Array<TypeAnnotation> = [];
+                typeList.forEach((type) => {
+                    const typeAnnotation = primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
+                    if (typeAnnotation) {
+                        res.push(typeAnnotation);
+                    } else if (type === 'unknown') {
+                        return null;
+                    }
+                });
+                if (!res.length) {
+                    res = primitiveTypeList;
+                }
+                // 调整结构
+                const dataTypeList: Array<{
+                    title: string;
+                    children: Array<TypeAnnotation>;
+                }> = [{ title: '基础类型', children: res }];
+                return dataTypeList;
+            }
+        }
+    },
+    _getTypeQuickinfo(args: any) {
+        return this.messager.requestCommand('quickInfo', args) as unknown as { responseRequired: boolean; response: tsProtocol.QuickInfoResponseBody };
+    },
+    getSelectNextCompletion(node: BaseNode, noFilterList?: Array<string>) {
+        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
+        // console.log(currentSource, fileNode);
+        if (currentSource && fileNode) {
+            return naslServer._getSelectNextCompletion({
+                file: (fileNode as FileNode).getEmbeddedFilePath(),
+                range: {
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character),
+                },
+                noFilterList,
+            });
+        } else {
+            console.log('没找到节点', currentSource, fileNode);
+        }
+    },
+    _getSelectNextCompletion(args: any) {
+        return this.messager.requestCommand('getSelectNextCompletion', args);
+    },
+    async getDiagnosticRecords(fileNames?: Array<string>): Promise<Array<DiagnosticRecord>> {
+        const records = (await this.messager.requestCommand('getDiagnosticRecords', fileNames)) as Array<DiagnosticRecord>;
+        return this._resolveDiagnosticRecords(records);
+    },
+    async getDiagnosticRecordsAndPushAll(fileNames?: Array<string>) {
+        const records = await this.getDiagnosticRecords(fileNames);
+        // diagnosticManager.pushAll(records);
+    },
+    _resolveDiagnosticRecords(records: Array<DiagnosticRecord>) {
+        records.forEach((record) => {
+            const node = this.file2NodeMap.get(record.filePath);
+            if (!node)
+                return;
+            record.id = node.id;
+            record.node = node;
+
+            // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
+            const oldRecord = diagnosticManager.getRecord(record.id);
+            oldRecord?.semanticDiagnostics.forEach((item) => {
+                item.node ? (item.node.tsErrorDetail = undefined) : '';
+            });
+
+            // 语义诊断
+            record.semanticDiagnostics = record.semanticDiagnostics
+                .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node.sourceMap))
+                .filter((diag) => !!diag);
+
+            // 建议诊断
+            // 实体下的建议不用展示，因为都是平台自己写的逻辑
+            // if (node instanceof Entity) {
+            //     record.suggestionDiagnostics = [];
+            // }
+            // if (node instanceof View) {
+            //     // event在view中不展示建议使用,提示关闭掉
+            //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`'event'`));
+            // }
+            // if (node instanceof Logic) {
+            //     // logic在for循环中，不展示any提示
+            //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
+            // }
+            // record.suggestionDiagnostics = record.suggestionDiagnostics
+            //     .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node.sourceMap))
+            //     .filter((diag) => !!diag);
+            record.suggestionDiagnostics = [];
+            // 语法诊断暂时不需要
+        });
+        return records;
+    },
+    _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, sourceMap: SourceMap): Diagnostic {
+        const minRange = this._findMinRange(diagnostic, sourceMap);
+        const tsErrorDetail = {
+            severity: diagnostic.category === 'error' ? 'error' : 'warning',
+            message: translateDiagnosticMessage(diagnostic.text),
+            // 保留原来的内容方便查询一些问题
+            originalDiagnostic: diagnostic,
+        };
+
+        if (minRange) {
+            // let message = this.translateDiagnosticMessage(diagnostic.text);
+            // 节点的error要置为true
+            return naslServer._diagnosticSpecialTreatment(minRange, tsErrorDetail);
+        } else {
+            // 没找到节点， 先把问题暴露出来
+            return {
+                id: undefined,
+                ...tsErrorDetail,
+            };
+        }
+    },
+    /**
+     * 处理一些边界情况
+     * @param minRange
+     * @param tsErrorDetail 报错具体信息
+     * @returns
+     */
+    _diagnosticSpecialTreatment(minRange: MinRange, tsErrorDetail: Diagnostic) {
+        const text = tsErrorDetail.originalDiagnostic.text;
+        // 有一些节点报错信息不向外暴露,缺失一些原生标签等等的展示
+        if (minRange.node instanceof View || minRange.node instanceof ViewElement) {
+            if (text.startsWith(`'nasl.ui' has no exported member named `)) {
+                return null;
+            } else if (text.startsWith(`Property '`) && text.includes(`does not exist on type 'typeof ui'.`)) {
+                return null;
+            } else if (text.startsWith(`Namespace 'nasl.ui' has no exported member `)) {
+                return null;
+            }
+        }
+        if (/Expected (.+?) arguments, but got (.+?)./.exec(text)) {
+            // bindevent本身现在就不传参数
+            if (minRange.node instanceof BindEvent) {
+                return null;
+            }
+            // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 callLogic上,
+            // 但是只少一个的时候就会找到准确的Argument上 需要特殊处理, ui层就可以统一处理
+            if (minRange.node instanceof Argument) {
+                minRange.node = minRange.node.parentNode;
+            }
+        }
+
+        minRange.node.tsErrorDetail = tsErrorDetail;
+        return {
+            id: minRange.node.id,
+            node: minRange.node,
+            ...tsErrorDetail,
+        };
+    },
+    _findMinRange(diagnostic: tsProtocol.DiagnosticWithFileName | tsProtocol.ReferencesResponseItem, sourceMap: SourceMap) {
+        let minRange: MinRange;
+        for (const [node, item] of sourceMap.entries()) {
+            /**
+             * 当前内容的开始行 <= 诊断开始的行 &&
+             * 当前内容的结束行 >= 诊断结束的行
+             */
+            if (lsp2tspNumber(item.range.start.line) <= diagnostic.start.line && lsp2tspNumber(item.range.end.line) >= diagnostic.end.line) {
+                // 如果找到某一行
+                if (lsp2tspNumber(item.range.start.line) === diagnostic.start.line && lsp2tspNumber(item.range.end.line) === diagnostic.end.line) {
+                    // 在行的范围但是又不在列的范围，不用给默认值，给了反而不对，
+                    // 需要在列的范围内
+                    if (lsp2tspNumber(item.range.start.character) <= diagnostic.start.offset && 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) {
+            console.log(diagnostic, 'diagnostic');
+            console.log(sourceMap, 'sourceMap');
+            console.log(minRange, '需要特殊看下，为什么没找到内容-------------');
+        }
+        return minRange;
+    },
+    // 查找引用
+    async findReferences(node: BaseNode) {
+        console.log(node);
+        const refsList = await naslServer._isHaveRef(node, true);
+        console.log(refsList, 'refsList');
+        // refsList = refsList.filter((item) =>
+        // // 不是创建者
+        //     item.isDefinition !== true);
+        let result = {};
+        const resMap = {};
+        try {
+            refsList.forEach((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return;
+                const minRange = this._findMinRange(record, fileNode.sourceMap);
+                // 过滤一把不需要改的信息
+                if (minRange) {
+                    // 如果查找引用查到自己里面的引用不展示
+                    // 因为view生成的特殊性
+                    if (minRange.node === node || (minRange.node instanceof View && node instanceof View)) {
+                        return;
+                    }
+                    // 拼装树
+                    naslServer._getTreeMap(minRange, fileNode, resMap);
+                }
+            });
+            console.log(resMap, 'resMap');
+            result = naslServer.handleTreeMap(resMap);
+        } catch (err) {
+            console.log(err);
+        }
+        console.log(result);
+        return result;
+    },
+    async _isHaveRef(node: BaseNode, isFind: boolean = false) {
+        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
+        let refsList: tsProtocol.ReferencesResponseItem[] = [];
+
+        /**
+         * 未完成创建的节点 ，或者异常情况 可能找不到节点
+         */
+        if (currentSource) {
+            const newRefs = await naslServer.references({
+                file: (fileNode as FileNode).getEmbeddedFilePath(),
+                line: lsp2tspNumber(currentSource.range.start.line),
+                offset: lsp2tspNumber(currentSource.range.start.character),
+            });
+            refsList = [...newRefs.refs];
+        }
+
+        // 如果是entity就需要在单独，查一边来修改名字
+        if (node instanceof Entity) {
+            // 过滤一把不需要改的信息
+            refsList = refsList.filter((item) =>
+            // 不再当前文件里
+            // 或者在当前列表但是位置小于entity的结束位置
+                (fileNode as FileNode).getEmbeddedFilePath() !== item.file);
+        }
+
+        // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
+        if (node instanceof Param && node.parentNode instanceof Logic) {
+            const logicNode = node.parentNode;
+            const { currentSource } = naslServer.getCurrentSource(logicNode);
+            const parentRefs = await naslServer.references({
+                file: (fileNode as FileNode).getEmbeddedFilePath(),
+                line: lsp2tspNumber(currentSource.range.start.line),
+                offset: lsp2tspNumber(currentSource.range.start.character),
+            });
+            refsList = [...refsList, ...parentRefs.refs];
+        }
+
+        // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
+        if (node instanceof Param && node.parentNode instanceof View && isFind) {
+            const viewNode = node.parentNode;
+            const { currentSource } = naslServer.getCurrentSource(viewNode);
+            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),
+            });
+
+            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 ViewElement) {
+            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 as FileNode).getEmbeddedFilePath(),
+                line: lsp2tspNumber(currentSource.range.start.line),
+                offset: lsp2tspNumber(currentSource.range.start.character + methodsNameIndex),
+            });
+
+            const methodRefs = methods.refs.filter((item) => {
+                if (item.lineText.includes('__elements.') && item.lineText.includes('new nasl.ui.')) {
+                    return false;
+                }
+                if (item.lineText.includes(': <nasl.ui.')) {
+                    return false;
+                }
+                return true;
+            });
+            refsList = [...methodRefs];
+        }
+        return refsList;
+    },
+    /**
+     * 查找引用，并且做一些 修改前的准备工作，
+     * 有引用有的话，就返回集合
+     * @param node 当前重命名的节点
+     * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+     * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+     * @returns 找到的引用
+     */
+    _renamePrepare(node: BaseNode, refsList: any[], newValue: string) {
+        const oldName = node?.name;
+        const result = refsList
+            .map((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return null;
+                const minRange: reNameMinRange = this._findMinRange(record, fileNode.sourceMap);
+                if (minRange) {
+                    // 如果节点是TypeAnnotation类型,
+                    // 很复杂，可能是多级嵌套结构
+                    // 不一定只修改typeName
+                    if (minRange.node instanceof TypeAnnotation) {
+                        // console.log(record);
+                        minRange.setTypeMethods = 'setTypeName';
+                    }
+                    // 如果节点是logic修改引发calllogic修改
+                    if (minRange.node instanceof CallLogic && node instanceof Logic) {
+                        minRange.setTypeMethods = 'setCalleeName';
+                    }
+                    if (minRange.node instanceof CallLogic && node instanceof ViewElement) {
+                        minRange.setTypeMethods = 'setCalleeName';
+                        minRange.newValue = 'elements.' + newValue + '.logics';
+                    }
+                    // 如果节点是实体修改引发calllogic修改
+                    if (minRange.node instanceof CallLogic && (node instanceof Entity || node instanceof View)) {
+                        // 匹配到的内容，当前这一行的内容；
+                        // 因为要用下面的点位信息
+                        /**
+                         * 如果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 CallLogic && node instanceof Param) {
+                        // 逻辑第几个位置发生修改，对应的calllogic对应位置的内容要进行修改
+                        const nodeArguments = minRange.node.arguments;
+                        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 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 Identifier && node instanceof Logic) {
+                        minRange.newValue = newValue;
+                        minRange.setTypeMethods = 'setName';
+                    }
+                    // 如果节点是MemberExpression表达式
+                    if (minRange.node instanceof MemberExpression) {
+                        // 匹配到的内容，当前这一行的内容；
+                        // 因为要用下面的点位信息
+                        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 EntityProperty && node instanceof Entity) {
+                        minRange.setTypeMethods = 'setRelationEntity';
+                    }
+                    // 如果是修改实体属性，要同步实体属性
+                    if (minRange.node instanceof EntityProperty && node instanceof EntityProperty && record.lineText.includes('@nasl.annotation.EntityRelation')) {
+                        minRange.setTypeMethods = 'setRelationProperty';
+                    }
+                    // 如果要修改索引的
+                    if (minRange.node instanceof 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 View && minRange.node instanceof 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 BindEvent) {
+                        /**
+                         * 如果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;
+                        // 新的完整的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 Interface && node instanceof Logic) {
+                        minRange.setTypeMethods = 'setOriginLogicName';
+                    }
+                    // 如果是role改名,就需要查到变更后的数组
+                    if ((minRange.node instanceof View || minRange.node instanceof ViewElement) && node instanceof Role) {
+                        // oldName旧的节点存的值
+                        // newValue用户输入值
+                        // node.bindRoles 存的
+                        minRange.setTypeMethods = 'setBindRoles';
+                        const str = minRange.node.bindRoles.toString().replace(oldName, newValue);
+                        const newBindRoles = str.split(',');
+                        minRange.newValue = newBindRoles;
+                    }
+                    // 枚举修改枚举名，比较特殊
+                    if (minRange.node instanceof EnumItem && node instanceof Enum) {
+                        // 什么都不做，用来跳过修改
+                        return null;
+                    }
+                    // 如果是修改param查找到logic就不操作
+                    if (minRange.node instanceof Logic && node instanceof Param) {
+                        return null;
+                    }
+                    // 如果是子页面修改
+                    // 父页面引起子页面改名，就可以不改了，自动同步
+                    if (minRange.node instanceof View && node instanceof View && minRange.node !== node) {
+                        return null;
+                    }
+                    // 逻辑改名，触发了在定义里面的，element定义，的值，直接掠过
+                    if (minRange.node instanceof View && node instanceof Logic) {
+                        return null;
+                    }
+                } else {
+                    console.log('没找到节点需要排查');
+                    console.log(record, fileNode.sourceMap);
+                }
+
+                return minRange;
+            })
+            // 过滤掉不需要操作的
+            .filter((item) => !!item);
+        console.log(result);
+        return result;
+    },
+    _addParamsPrepare(node: BaseNode, refsList: any[]) {
+        const App = node.rootNode;
+        const LogicNode = node.parentNode as Logic;
+        // 收集修改
+        App.emit('collect:start', {
+            actionMsg: '增加逻辑参数',
+        });
+        node.create({
+            index: 0,
+            parentNode: LogicNode,
+            parentKey: node.parentKey,
+        });
+        refsList.forEach((record) => {
+            const fileNode = this.file2NodeMap.get(record.file);
+            if (!fileNode)
+                return null;
+            const minRange: MinRange = this._findMinRange(record, fileNode.sourceMap);
+            if (minRange) {
+                // 如果找到节点是callLogic就去更新
+                if (minRange.node instanceof CallLogic && node instanceof Param) {
+                    minRange.node.setCalleeArgName(LogicNode);
+                }
+            }
+        });
+        // 结束修改 ，批量操作
+        App.emit('collect:end');
+    },
+    // 获取节点的上层渲染
+    _getTreeMap(minRange: MinRange, fileNode: BaseNode, resMap: ResMap) {
+        const minRangeNode = minRange.node;
+        let parantNode = minRangeNode;
+        // 顺序队列
+        const queue: any[] = [];
+        // 先插入自己,如果没有在往上找,
+        // 一直到file节点的父级
+        while (parantNode !== fileNode.parentNode) {
+            // 找到上一级 在map对象中构造出他的子集
+            const currentNode = parantNode;
+            parantNode = parantNode.parentNode;
+            // 如果第一次就塞入子集和父节点，以后就只用父节点了
+            // 因为部分节点没有name，先过滤掉
+            // if (currentNode.name) {
+            // }
+
+            // 排除一些不放入集合的节点
+            let isNeedPush = true;
+            // 如果不是ViewElement 或者 Assignment ， 或者如果是的话， 排除l-root
+            if (currentNode instanceof ViewElement && (currentNode as ViewElement).tag !== 'l-root')
+                isNeedPush = false;
+            else if (currentNode instanceof Assignment)
+                isNeedPush = false;
+            else if (currentNode instanceof TypeAnnotation)
+                isNeedPush = false;
+            else if (currentNode instanceof CallQueryComponent)
+                isNeedPush = false;
+            else if (currentNode instanceof QueryFromExpression)
+                isNeedPush = false;
+            else if ((currentNode.concept === parantNode.concept) || (currentNode.name === parantNode.name))
+                isNeedPush = false;
+            if (isNeedPush) {
+                // 名称
+                let name = currentNode.name || currentNode.concept;
+                // 赋值图标
+                let icon = currentNode.concept && currentNode.concept.replace(/^./, (m) => m.toLowerCase());
+                if (currentNode instanceof ViewElement)
+                    icon = 'element';
+                else if (currentNode instanceof BindAttribute)
+                    icon = 'attr';
+                else if (currentNode instanceof Destination)
+                    icon = 'logicNode';
+                else if (currentNode instanceof CallLogic) {
+                    icon = 'interface';
+                    name = '调用逻辑';
+                }
+                queue.unshift({ name, node: currentNode, expanded: true, icon });
+            }
+        }
+
+        const key = fileNode.name;
+        // 一个logic 或者 view可能会有多个顺序队列
+        if (resMap[key]) {
+            // // 是否展示两个内容全等，但是两个queue的node可能不一样，但是只需要展示一个
+            // let equalFlag = false;
+            // const queues = resMap[key].queue;
+            // queues.forEach((item) => {
+            //     if (item.length === queue.length) {
+            //         let equalIndex = 0;
+            //         item.forEach((queueItem, index) => {
+            //             if (queueItem.name === queue[index].name)
+            //                 equalIndex++;
+            //         });
+            //         console.log(equalIndex)
+            //         if (equalIndex === queue.length)
+            //             equalFlag = true;
+            //     }
+            // });
+
+            // // 如果有值就return
+            // if (equalFlag)
+            //     return;
+            queue.length && resMap[key].queue.push(queue);
+        } else {
+            resMap[key] = {
+                queue: queue.length ? [queue] : [],
+                concept: fileNode.concept,
+                name: fileNode.name,
+                node: fileNode,
+            };
+        }
+    },
+    handleTreeMap(tree: ResMap) {
+        const treeNodeMap: treeNode = {};
+        for (const [sub, val] of Object.entries(tree)) {
+            // 循环处理tree的queue
+            const treeObj = naslServer.handleTreeQueue(val.queue);
+            if (treeNodeMap[val.concept]) {
+                treeNodeMap[val.concept].push(treeObj);
+            } else {
+                treeNodeMap[val.concept] = [treeObj];
+            }
+        }
+        return treeNodeMap;
+    },
+    /**
+     * 处理tree的队列，把相同节点进行合并
+     * 这里把当前二维数组进行一个整合
+     * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
+     * @returns 最后要使用到的节点和对应的子集
+     */
+    handleTreeQueue(arr: QuoteNode[][]) {
+        const map: { [propName: string]: QuoteNode[] } = {};
+        let root: null | QuoteNode = null;
+        if (!arr.length)
+            return;
+        for (const sub of arr) {
+            let preNode = null;
+            for (const item of sub) {
+                const node = item;
+                const key = item.name;
+
+                if (!map[key]) {
+                    map[key] = [];
+                }
+                if (preNode) {
+                    const preKey = preNode.name;
+                    const find = map[preKey].find((item) => node.name === item.name);
+                    if (!find) {
+                        map[preKey].push(node);
+                    }
+                } else {
+                    root = node;
+                }
+                preNode = node;
+            }
+        }
+        const children = naslServer._recursionCreateResult(root, map);
+        return children;
+    },
+    /**
+     * 递归调用输出结果
+     * @param root 一个根节点
+     * @param map 当前所有节点的map对象
+     * @returns 当前节点，最后输出所有节点
+     */
+    _recursionCreateResult(root: QuoteNode, map: { [propName: string]: QuoteNode[] }) {
+        const node = root;
+        const rootKey = root.name;
+        const children = map[rootKey].map((item: QuoteNode) => naslServer._recursionCreateResult(item, map));
+        if (children && children.length) {
+            node.children = children;
+        }
+        return node;
+    },
+
+    /**
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
+    getCurrentSource(node: BaseNode) {
+        let sourceMap = node.sourceMap;
+        let fileNode = node;
+        // 如果没有sourceMap,就继续向上找 ,或者到module结束
+        // 如果 节点找到 app 或者module 停止
+
+        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof App) && !(fileNode.parentNode instanceof Module)) {
+            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: SourceMapItem, node: BaseNode) {
+        // 如果有前面的一些注解，元素在最后一行输出的值就给最后一行
+        if (node instanceof EntityProperty) {
+            if (currentSource.range.start.line !== currentSource.range.end.line) {
+                currentSource.range.start = { ...currentSource.range.start, line: currentSource.range.end.line };
+            }
+        }
+    },
+    // 获取element方法的可选值
+    getFieldKeySelectCompletion(node: BaseNode, fieldKey?: string) {
+        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
+        console.log(currentSource);
+        if (currentSource && fileNode) {
+            return naslServer._getFieldKeySelectCompletion({
+                file: (fileNode as FileNode).getEmbeddedFilePath(),
+                range: {
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character),
+                },
+                getFieldKey: fieldKey,
+            });
+        } else {
+            console.log('没找到节点', currentSource, fileNode);
+        }
+    },
+    _getFieldKeySelectCompletion(args: any) {
+        return this.messager.requestCommand('getFieldKeySelectCompletion', args);
+    },
+};
+/**
+ * 处理删除节点
+ * @param fileNode 当前删除节点的文件级别节点
+ * @param targetNode 当前操作的节点
+ * @param result toTs生成的内容
+ */
+async function handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: ReturnType<Structure['toEmbeddedTSFile']>) {
+    const filePath = (fileNode as FileNode).getEmbeddedFilePath();
+    // 如果要删除，而且当前要删Logic就直接删除并且清除错误
+    /**
+     * 删除节点中的一个内容,删除了以后，就查一下引用的地方一起查一下异常
+     */
+    let outputFiles: any = [];
+    // 删除之前先查一下内容的依赖
+    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 });
+
+    const filesToCheck: Set<string> = new Set();
+    newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+    console.log('filesToCheck', filesToCheck, filesToCheck.size);
+    await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
+}
+// 查找引用
+BaseNode.prototype.findUsage = function findUsage() {
+    try {
+        return naslServer.findReferences(this);
+    } catch (err) {
+        console.log(err);
+    }
+};
+BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
+    console.log(newValue);
+    console.log(this);
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const refsList = await naslServer._isHaveRef(this);
+        // 是不是有引用有的话，就返回
+        /**
+         * @param this 当前重命名的节点
+         * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+         * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+         * @returns 找到的引用
+         */
+        const res = naslServer._renamePrepare(this, refsList, newValue);
+        if (res.length <= 1) {
+            (this as setNameNode).setName(newValue);
+        } else {
+            const callback = (value: boolean) => {
+                if (value) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '重命名并更新引用',
+                    });
+                    res.forEach((item) => {
+                        const itemNode = item.node as setNameNode;
+                        if (item.newValue) {
+                            // 如果有指定的修改方法，就用那个，没有就修改名字
+                            item.setTypeMethods ? itemNode[item.setTypeMethods](item.newValue) : itemNode.setName?.(item.newValue);
+                        } else {
+                            item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                } else {
+                    (this as setNameNode).setName(newValue);
+                }
+            };
+            const confirmParms = {
+                actionType: 'rename',
+                node: this,
+            };
+            /**
+             * nasl和vue的通信，回退，要触发vue的watch。
+             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
+             * 先修改之
+             */
+            const closeCallBack = () => {
+                const oldValue = this.name;
+                this.name = oldValue + ' ';
+                setTimeout(() => {
+                    this.name = oldValue;
+                }, 0);
+            };
+            updateAll ? callback(true) : invokeCommand('tsConfirm.open', confirmParms, callback, closeCallBack);
+
+            return;
+        }
+    } catch (err) {
+        console.log(err);
+    }
+};
+
+/**
+ * 准备删除
+ */
+BaseNode.prototype.prepareDelete = async function prepareDelete() {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const node = this;
+        const refsList = await naslServer._isHaveRef(node);
+        // console.log(refsList, 'refsList');
+        const confirmParms = {
+            actionType: 'delete',
+            tipFlag: false,
+            node,
+        };
+        let callback = null;
+        if (refsList.length <= 1) {
+            callback = () => {
+                // Structure 和 Interface是内部有delete方法
+                if (node instanceof Structure || node instanceof Interface) {
+                    (this as any).deleteLogincAndModule();
+                } else {
+                    this.delete();
+                }
+            };
+        } else {
+            // 如果有依赖就有一个查找引用提示
+            confirmParms.tipFlag = true;
+            const node = this;
+            callback = () => {
+                // removeParam
+                // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
+                if (node instanceof Param) {
+                    const App = this.rootNode;
+                    const logicNode = this.parentNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除参数',
+                    });
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode.sourceMap);
+                        if (minRange) {
+                            if (minRange.node instanceof CallLogic) {
+                                minRange.node.setCalleeArgName(logicNode as Logic);
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    return;
+                }
+                // 删除logic节点，如果有对应的interface要一起删除
+                if (node instanceof Logic) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除逻辑并删除导出的接口',
+                    });
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode.sourceMap);
+                        if (minRange) {
+                            if (minRange.node instanceof Interface) {
+                                minRange.node.delete();
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                }
+                // 删除权限节点
+                if (node instanceof Role) {
+                    const App = this.rootNode;
+                    // 收集修改
+                    App.emit('collect:start', {
+                        actionMsg: '删除权限',
+                    });
+                    this.delete();
+                    refsList.forEach((record) => {
+                        const fileNode = naslServer.file2NodeMap.get(record.file);
+                        if (!fileNode)
+                            return null;
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode.sourceMap);
+                        if (minRange) {
+                            if (minRange.node instanceof View || minRange.node instanceof ViewElement) {
+                                // oldName旧的节点存的值
+                                // newValue用户输入值
+                                // node.bindRoles 存的
+                                const str = minRange.node.bindRoles.toString().replace(this.name, '');
+                                const newBindRoles = str.split(',').filter((item) => !!item);
+                                minRange.node.setBindRoles(newBindRoles);
+                            }
+                        }
+                    });
+                    // 结束修改 ，批量操作
+                    App.emit('collect:end');
+                    return;
+                }
+
+                // 其余的都直接调用删除
+                // Structure 和 Interface是内部有delete方法
+                if (node instanceof Structure || node instanceof Interface) {
+                    (this as any).deleteLogincAndModule();
+                } else {
+                    this.delete();
+                }
+            };
+        }
+        invokeCommand('tsConfirm.open', confirmParms, callback);
+    } catch (err) {
+        console.log(err);
+    }
+};
+
+/**
+ * 如果添加需要触发查找引用并且在之后，对内容产生影响
+ */
+BaseNode.prototype.addParamsPrepare = async function addParamsPrepare() {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        const refsList = await naslServer._isHaveRef(this);
+        return naslServer._addParamsPrepare(this, refsList);
+    } catch (err) {
+        console.log(err);
+    }
+};
+
+/**
+ * 除去rename场景下的更新
+ * @param fileNode 文件级别的节点
+ * @param targetNode 触发修改的节点
+ * @param result 生成代码的code 和位置信息
+ */
+async function handleChange(fileNode: BaseNode, targetNode: BaseNode, result: ReturnType<Structure['toEmbeddedTSFile']>, action: string) {
+    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,
+    });
+    const filesToCheck: Set<string> = new Set();
+
+    newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+    // 唤起建立连接弹框
+    // 文件级别的建立连接采取提醒
+    if (fileNode === targetNode && action === 'create' && filesToCheck.size > 1) {
+        const confirmParms = {
+            actionType: 'createEstablishConnection',
+            node: fileNode,
+        };
+        invokeCommand('tsConfirm.open', confirmParms, () => {});
+    }
+    await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
+}
+
+/**
+ * 重命名的更新
+ * @param fileNode 文件级别的节点
+ * @param targetNode 触发修改的节点
+ * @param result 生成代码的code 和位置信息
+ * @param isRename 是不是修改名字
+ * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
+ */
+async function handleRename(fileNode: BaseNode, targetNode: BaseNode, result: ReturnType<Structure['toEmbeddedTSFile']>, oldFilePath?: string) {
+    // rename 场景
+    const outputFiles = [{ file: result.filePath, fileContent: result.code }];
+    const filesToCheck: Set<string> = new Set();
+    // 如果是要修改顶级文件名
+    // 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: Set<string> = new Set();
+        newRefs.refs.forEach((ref) => {
+            filesToCheck.add(ref.file);
+            newRefFileList.add(ref.file);
+        });
+
+        // 文件级别重命名，有依赖才唤起弹框
+        // 唤起重命名，提示有连接弹框
+        if (newRefFileList.size > 1) {
+            const confirmParms = {
+                actionType: 'renameEstablishConnection',
+                node: fileNode,
+            };
+            invokeCommand('tsConfirm.open', confirmParms, () => {});
+        }
+    } else {
+        // 查一下当前属性依赖的文件
+        const { currentSource, fileNode } = naslServer.getCurrentSource(targetNode);
+        const oldRefs = await naslServer.references({
+            file: (fileNode as FileNode).getEmbeddedFilePath(),
+            line: lsp2tspNumber(currentSource.range.start.line),
+            offset: lsp2tspNumber(currentSource.range.start.character),
+        });
+        oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+        // 更新文件之后
+        await naslServer.updateFiles({ outputFiles });
+
+        const newRefs2 = await naslServer.references({
+            file: (fileNode as FileNode).getEmbeddedFilePath(),
+            line: lsp2tspNumber(currentSource.range.start.line),
+            offset: lsp2tspNumber(currentSource.range.start.character),
+        });
+        newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+    }
+
+    console.log('filesToCheck', filesToCheck, filesToCheck.size);
+    await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
+    // outputFiles.map((file) => file.file));
+}
+
+async function receiveHandleChange($event: EventPayload) {
+    // 行为
+    const action = $event.action;
+    const targetNode = $event.target;
+    // 当前操作的文件节点
+    const { fileNode } = naslServer.getCurrentSource(targetNode);
+    // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
+    if (fileNode instanceof Module || fileNode instanceof Configuration) {
+        return;
+    }
+
+    const result = (fileNode as 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);
+        else {
+            await handleRename(fileNode, targetNode, result, (fileNode as FileNode).getEmbeddedFilePath($event.oldName));
+        }
+    }
+    // 删除
+    if (action === 'delete') {
+        await handleDelete(fileNode, targetNode, result);
+    }
+}
+
+// 监听所有改变操作
+embeddedTSEmitter.on('change', ($event: EventPayload) => {
+    // 收集到一个行为集合
+    const eventValue = $event.value;
+    eventValue.forEach((item: EventPayload) => {
+        receiveHandleChange(item.originEvent);
+    });
+});
+
+naslServer.messager.options.context = naslServer;
+export default naslServer;