@lcap/nasl 1.0.0-alpha.9 → 1.0.2

package/src/server/naslServer.ts

@@ -23,6 +23,7 @@ import {
     QueryFromExpression,
     QueryJoinExpression,
     QueryFieldExpression,
+    QueryGroupByExpression,
     Identifier,
     CallLogic,
     EnumItem,
@@ -36,20 +37,31 @@ import {
     CallQueryComponent,
     Role,
     Configuration,
+    CallInterface,
+    Return,
+    ProcessElement,
+    NullLiteral,
+    Namespace,
+    Theme,
+    Variable,
+    Assignee,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem, embeddedTSEmitter } from '../translator';
 import axios from '../service/storage';
-import { transformType, translateDiagnosticMessage } from './translator';
+import { translateDiagnosticMessage, naslNodeTranslateMessage, MinRange } 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';
+import { traverse } from '../utils';
 
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
     Entity: 3,
 };
+// 要Check的文件
+const filesToCheck: Set<string> = new Set();
 
-interface FileNode extends BaseNode {
+export interface FileNode extends BaseNode {
     getEmbeddedFilePath(name?: string): string;
     toEmbeddedTSFile(): {
         code: string;
@@ -58,14 +70,11 @@ interface FileNode extends BaseNode {
     };
 }
 
-interface setNameNode extends BaseNode {
+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',
@@ -80,29 +89,17 @@ const messager = new Messager({
     },
 });
 
-interface MinRange {
-    node: BaseNode;
-    item: SourceMapItem;
-}
-interface reNameMinRange extends MinRange {
+interface RenameMinRange extends MinRange {
     newValue?: any;
     setTypeMethods?: string;
 }
 // 查找引用节点
 interface QuoteNode {
-    name: any;
+    icon: any;
     node: BaseNode;
+    expanded: boolean;
     children?: QuoteNode[];
 }
-// 组装后的resMap， 一个页面节点下可能有多个queue
-interface ResMap {
-    [propName: string]: {
-        queue: QuoteNode[][];
-        name: string;
-        concept: string;
-        node: BaseNode;
-    };
-}
 const naslServer = {
     messager,
     worker,
@@ -117,85 +114,125 @@ const naslServer = {
         return this.messager.requestCommand('start');
     },
     async createUiTs(allComponent: any) {
-        const { code, elementsLogic } = await formatUiTs(allComponent);
+        const { code, elementsLogic, naslStdlibMap } = await formatUiTs(allComponent);
         // 放入生產的uits文件
         await naslServer.addFile({
             file: 'nasl.ui.definition.ts',
             fileContent: code,
         });
+        Object.keys(naslStdlibMap).forEach(async (libFileName: string) => {
+            await naslServer.addFile({
+                file: '/' + libFileName,
+                fileContent: naslStdlibMap[libFileName],
+            });
+        });
         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);
+            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.entities.forEach((entity) => {
-            const result = entity.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            entity.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, 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) => {
-            const result = _interface.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            _interface.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, _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) => {
-            const result = _enum.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            _enum.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, _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) => {
-            if (!(logic instanceof Logic))
-                return;
-            const result = logic.toEmbeddedTSFile();
-            results.push(result);
-            logic.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, logic);
+            try {
+                if (!(logic instanceof 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) => {
-            const result = process.toEmbeddedTSFile();
-            results.push(result);
-            process.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, 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 App) {
             module.roles.forEach((role) => {
-                const result = role.toEmbeddedTSFile();
-                results.push(result);
-                // sourceMap都存在目录级别内容下，在页面层级下去找
-                role.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, 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: 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);
-            }
-        });
+        // 如果有子页面
+        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: App) {
         const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
@@ -225,19 +262,16 @@ const naslServer = {
             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);
+    async refreshApp(app: App) {
+        // 清除所有问题
+        diagnosticManager.clear();
+        await naslServer.deleteDirectoryFiles({ directoryName: '/embedded' });
+        // 清楚check count的数量
+        await this.messager.requestCommand('_clearTimeout');
+        // 重新加载app下内容
+        await naslServer.openApp(app);
+        // 重新check一遍所有内容
+        await naslServer.getDiagnosticRecordsAndPushAll();
     },
     /**
      * 初始化之前添加文件
@@ -252,14 +286,7 @@ const naslServer = {
     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);
-    },
+
     /**
      * 新增、修改
      * 删除文件 文件用修改内容为空模拟，防止报错
@@ -268,15 +295,26 @@ const naslServer = {
     updateFiles(args: { outputFiles: Array<tsProtocol.OpenRequestArgs> }) {
         return this.messager.requestCommand('updateFiles', args);
     },
+
+    /**
+     * 清除一个目录下的所有文件
+     */
+    deleteDirectoryFiles(args: { directoryName: string }) {
+        return this.messager.requestCommand('deleteDirectoryFiles', 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;
-        // }));
+        /// #if process.env.NODE_ENV === 'development'
+        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;
+        })).catch((e) => {
+            console.error(e);
+        });
+        /// #endif
     },
     open() {
         return this.messager.requestCommand('open');
@@ -317,7 +355,9 @@ const naslServer = {
         const types = reg.exec(displayString);
         // 取出提示的类型，组成是数组
         const typeList: string[] = types[1].split(' | ').map((item: string) => {
-            if (item.includes(' ')) {
+            if (/\<([^()]+)\>/g.exec(item)) {
+                return item;
+            } else if (item.includes(' ')) {
                 const strs = item.split(' ');
                 const type = strs[strs.length - 1];
                 return type;
@@ -332,8 +372,7 @@ const naslServer = {
         return typeList;
     },
     async getTypeQuickinfo(node: BaseNode) {
-        console.log(node);
-        if (node instanceof Identifier) {
+        if (node && node instanceof BaseNode) {
             const callFunction = node.parentNode.parentNode;
             /**
              * currentSource callFunction 的节点，要去到当前节点的位置
@@ -341,34 +380,63 @@ const naslServer = {
              * 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;
-                    }
+            try {
+                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 (!res.length) {
-                    res = primitiveTypeList;
+                if (quickInfo.responseRequired) {
+                    const displayString = quickInfo?.response?.displayString || '';
+                    const typeList = naslServer.getDisplayString2Type(displayString);
+                    const res: Array<TypeAnnotation> = [];
+                    typeList.forEach((type) => {
+                        const typeAnnotation = 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: [primitiveTypeList[4]] }];
+        }
+    },
+    async getDataSchemaType(node: BaseNode) {
+        if (!(node instanceof ViewElement))
+            return;
+        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
+        const quickInfo = await naslServer._getTypeQuickinfo({
+            file: (fileNode as FileNode).getEmbeddedFilePath(),
+            line: lsp2tspNumber(currentSource.range.start.line),
+            offset: 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;
                 }
-                // 调整结构
-                const dataTypeList: Array<{
-                    title: string;
-                    children: Array<TypeAnnotation>;
-                }> = [{ title: '基础类型', children: res }];
-                return dataTypeList;
+                return str;
             }
         }
+        return '';
     },
     _getTypeQuickinfo(args: any) {
         return this.messager.requestCommand('quickInfo', args) as unknown as { responseRequired: boolean; response: tsProtocol.QuickInfoResponseBody };
@@ -416,8 +484,9 @@ const naslServer = {
 
             // 语义诊断
             record.semanticDiagnostics = record.semanticDiagnostics
-                .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node.sourceMap))
+                .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode))
                 .filter((diag) => !!diag);
+            record.semanticDiagnostics.push(...this._attachDiagnostics(node));
 
             // 建议诊断
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
@@ -440,8 +509,31 @@ const naslServer = {
         });
         return records;
     },
-    _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, sourceMap: SourceMap): Diagnostic {
-        const minRange = this._findMinRange(diagnostic, sourceMap);
+    _attachDiagnostics(fileNode: BaseNode): Diagnostic[] {
+        const diagnostics: Diagnostic[] = [];
+        if (fileNode instanceof View) {
+            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 } as ViewElement });
+        }
+
+        return diagnostics;
+    },
+    _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode): Diagnostic {
+        const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
             severity: diagnostic.category === 'error' ? 'error' : 'warning',
             message: translateDiagnosticMessage(diagnostic.text),
@@ -450,9 +542,8 @@ const naslServer = {
         };
 
         if (minRange) {
-            // let message = this.translateDiagnosticMessage(diagnostic.text);
             // 节点的error要置为true
-            return naslServer._diagnosticSpecialTreatment(minRange, tsErrorDetail);
+            return naslNodeTranslateMessage(minRange, tsErrorDetail);
         } else {
             // 没找到节点， 先把问题暴露出来
             return {
@@ -461,45 +552,10 @@ const naslServer = {
             };
         }
     },
-    /**
-     * 处理一些边界情况
-     * @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) {
+    _findMinRange(diagnostic: tsProtocol.DiagnosticWithFileName | tsProtocol.ReferencesResponseItem, fileNode: FileNode) {
         let minRange: MinRange;
+        const sourceMap: SourceMap = fileNode.sourceMap;
+
         for (const [node, item] of sourceMap.entries()) {
             /**
              * 当前内容的开始行 <= 诊断开始的行 &&
@@ -528,51 +584,18 @@ const naslServer = {
             }
         }
         if (!minRange) {
+            if (fileNode instanceof View) {
+                return { node: fileNode, item: sourceMap.get(fileNode) };
+            }
             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) {
+    async _isHaveRef(node: BaseNode) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         let refsList: tsProtocol.ReferencesResponseItem[] = [];
-
         /**
          * 未完成创建的节点 ，或者异常情况 可能找不到节点
          */
@@ -583,15 +606,36 @@ const naslServer = {
                 offset: lsp2tspNumber(currentSource.range.start.character),
             });
             refsList = [...newRefs.refs];
+        } else {
+            if (node instanceof Module) {
+                const lists = node.logics || node.structures || node.enums;
+                const moduleName = (fileNode as FileNode).getEmbeddedFilePath();
+                if (lists.length) {
+                    const item = lists[0];
+                    const { fileNode } = naslServer.getCurrentSource(item);
+                    const newRefs = await naslServer.references({
+                        file: (fileNode as FileNode).getEmbeddedFilePath(),
+                        line: 1,
+                        offset: 22, //固定的位置，module的位置信息
+                    });
+                    refsList = newRefs.refs.filter((item) => !item.file.startsWith(moduleName));
+                    // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
+                    refsList.unshift(newRefs.refs[0]);
+                }
+            }
         }
 
         // 如果是entity就需要在单独，查一边来修改名字
         if (node instanceof Entity) {
             // 过滤一把不需要改的信息
-            refsList = refsList.filter((item) =>
+            refsList = refsList.filter((item) => (fileNode as FileNode).getEmbeddedFilePath() !== item.file || item.isDefinition === true);
             // 不再当前文件里
             // 或者在当前列表但是位置小于entity的结束位置
-                (fileNode as FileNode).getEmbeddedFilePath() !== item.file);
+        }
+
+        if (node instanceof Return) {
+            // 过滤一下最后出去的值
+            refsList = refsList.filter((item) => !item.lineText.includes('return '));
         }
 
         // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
@@ -606,8 +650,8 @@ const naslServer = {
             refsList = [...refsList, ...parentRefs.refs];
         }
 
-        // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
-        if (node instanceof Param && node.parentNode instanceof View && isFind) {
+        // 如果是参数修改, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来d
+        if (node instanceof Param && node.parentNode instanceof View) {
             const viewNode = node.parentNode;
             const { currentSource } = naslServer.getCurrentSource(viewNode);
             const code = currentSource.code;
@@ -622,46 +666,54 @@ const naslServer = {
             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];
-        }
+        // 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),
-            });
+            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 as FileNode).getEmbeddedFilePath(),
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character + methodsNameIndex),
+                });
+                const methodRefs: tsProtocol.ReferencesResponseItem[] = [];
+                methods.refs.forEach((item) => {
+                    // 定义里的格式，在删除的时候留下来占位
+                    // 重命名的时候会过滤
 
-            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];
+                    // 这里只过滤 __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;
     },
     /**
@@ -679,13 +731,17 @@ const naslServer = {
                 const fileNode = this.file2NodeMap.get(record.file);
                 if (!fileNode)
                     return null;
-                const minRange: reNameMinRange = this._findMinRange(record, fileNode.sourceMap);
+                const minRange: RenameMinRange = this._findMinRange(record, fileNode as FileNode);
                 if (minRange) {
                     // 如果节点是TypeAnnotation类型,
                     // 很复杂，可能是多级嵌套结构
                     // 不一定只修改typeName
                     if (minRange.node instanceof 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修改
@@ -693,11 +749,11 @@ const naslServer = {
                         minRange.setTypeMethods = 'setCalleeName';
                     }
                     if (minRange.node instanceof CallLogic && node instanceof ViewElement) {
-                        minRange.setTypeMethods = 'setCalleeName';
+                        minRange.setTypeMethods = 'setCalleeNamespace';
                         minRange.newValue = 'elements.' + newValue + '.logics';
                     }
                     // 如果节点是实体修改引发calllogic修改
-                    if (minRange.node instanceof CallLogic && (node instanceof Entity || node instanceof View)) {
+                    if (minRange.node instanceof CallLogic && (node instanceof Entity || node instanceof View || node instanceof Process || node instanceof ProcessElement)) {
                         // 匹配到的内容，当前这一行的内容；
                         // 因为要用下面的点位信息
                         /**
@@ -719,26 +775,29 @@ const naslServer = {
                         const end = record.end.offset - index - 1;
                         // 新的完整的value
                         let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
-                        newTsNameSpace = newTsNameSpace.replace(/.$/g, '.');
+                        newTsNameSpace = newTsNameSpace.replace(/.\$/g, '.');
                         minRange.setTypeMethods = 'setCalleeNamespace';
                         minRange.newValue = newTsNameSpace;
                     }
                     // 如果参数修改影响了 callLogic
                     if (minRange.node instanceof CallLogic && node instanceof Param) {
+                        return null;
                         // 逻辑第几个位置发生修改，对应的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;
-                        }
+                        // 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 Identifier) {
@@ -760,6 +819,11 @@ const naslServer = {
                             minRange.newValue = newTextValue;
                         }
                     }
+                    // 如果是枚举修改，枚举的值刚好在Identifier 中选了 就修改值
+                    if (minRange.node instanceof Identifier && node instanceof Enum) {
+                        minRange.newValue = newValue;
+                        minRange.setTypeMethods = 'setName';
+                    }
                     // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
                     if (minRange.node instanceof Identifier && node instanceof Logic) {
                         minRange.newValue = newValue;
@@ -767,19 +831,26 @@ const naslServer = {
                     }
                     // 如果节点是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;
+                        // 枚举key的特殊性，因为它不是原来的key+value形式的
+                        // 是加了中括号啥的，所以直接赋值新值
+                        if (node instanceof 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 EntityProperty && node instanceof Entity) {
@@ -837,7 +908,12 @@ const naslServer = {
                     // 如果是view也需要加前缀
                     // logic 和 views名称修改 可能会触发bindEvent修改
                     if (minRange.node instanceof BindEvent) {
-                        /**
+                        // 页面逻辑直接赋值就可以, 因为是相对路径
+                        if ((node instanceof 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
@@ -846,25 +922,45 @@ const naslServer = {
                          * 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 {
+                            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
-                            let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
-                            minRange.setTypeMethods = 'setCalleeNamespace';
-                            newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
-                            minRange.newValue = newTsNameSpace;
+                            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 Destination && node instanceof Param) {
+                        // 因为view是key value 绑定所以需要重新赋值
+                        if (node.parentNode instanceof 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 Interface && node instanceof Logic) {
@@ -880,13 +976,44 @@ const naslServer = {
                         const newBindRoles = str.split(',');
                         minRange.newValue = newBindRoles;
                     }
+                    // 修改枚举值找到了EntityProperty就说明给了默认值
+                    if (minRange.node instanceof EntityProperty && node instanceof EnumItem) {
+                        minRange.setTypeMethods = 'setDefaultValue';
+                    }
+                    if (minRange.node instanceof QueryFieldExpression && node instanceof Entity) {
+                        minRange.setTypeMethods = 'setEntityAsName';
+                    }
+                    if (minRange.node instanceof QueryGroupByExpression && node instanceof Entity) {
+                        minRange.setTypeMethods = 'setEntityAsName';
+                    }
+
+                    if ((minRange.node instanceof QueryFromExpression || minRange.node instanceof QueryJoinExpression) && node instanceof Entity) {
+                        minRange.setTypeMethods = 'setEntityName';
+                    }
+                    if (minRange.node instanceof QueryFieldExpression && node instanceof EntityProperty) {
+                        minRange.setTypeMethods = 'setPropertyName';
+                    }
+                    if (minRange.node instanceof QueryGroupByExpression && node instanceof EntityProperty) {
+                        minRange.setTypeMethods = 'setPropertyName';
+                    }
+
+                    // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
+                    if ((minRange.node instanceof Param || minRange.node instanceof Variable || minRange.node instanceof Return) && (node instanceof Entity || node instanceof Enum || node instanceof Structure)) {
+                        return null;
+                    }
+                    if (minRange.node instanceof Destination && (node instanceof Process || node instanceof ProcessElement)) {
+                        return null;
+                    }
+                    if (minRange.node instanceof Assignee && (node instanceof Process || node instanceof ProcessElement)) {
+                        return null;
+                    }
                     // 枚举修改枚举名，比较特殊
                     if (minRange.node instanceof EnumItem && node instanceof Enum) {
                         // 什么都不做，用来跳过修改
                         return null;
                     }
-                    // 如果是修改param查找到logic就不操作
-                    if (minRange.node instanceof Logic && node instanceof Param) {
+                    // params修改 查找bindevent不需要修改
+                    if (minRange.node instanceof BindEvent && node instanceof Param) {
                         return null;
                     }
                     // 如果是子页面修改
@@ -894,8 +1021,39 @@ const naslServer = {
                     if (minRange.node instanceof View && node instanceof View && minRange.node !== node) {
                         return null;
                     }
+                    /**
+                     * 屏蔽组件生成内容块中的变量或者逻辑，出现在表格选择中。在bindAttr中还会有，所以过滤一把
+                     */
+                    if ((minRange.node instanceof Identifier || minRange.node instanceof MemberExpression) && node instanceof Param && minRange.node.parentNode instanceof BindAttribute) {
+                        return null;
+                    }
+                    // 修改element引发view改名
+                    if (node instanceof ViewElement && minRange.node instanceof View) {
+                        return null;
+                    }
+                    // params修改 查找View不需要修改
                     // 逻辑改名，触发了在定义里面的，element定义，的值，直接掠过
-                    if (minRange.node instanceof View && node instanceof Logic) {
+                    if (minRange.node instanceof View && (node instanceof Logic || node instanceof 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 Logic && node !== minRange.node) {
                         return null;
                     }
                 } else {
@@ -910,54 +1068,107 @@ const naslServer = {
         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,
-        });
+    // 增加参数的副作用，用于更新logic和view
+    _addParamsEffect(refsList: any[], node: Param) {
+        const parantNode = node?.parentNode as Logic | View;
         refsList.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.file);
             if (!fileNode)
                 return null;
-            const minRange: MinRange = this._findMinRange(record, fileNode.sourceMap);
+            const minRange: MinRange = this._findMinRange(record, fileNode as FileNode);
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
                 if (minRange.node instanceof CallLogic && node instanceof Param) {
-                    minRange.node.setCalleeArgName(LogicNode);
+                    minRange.node.setCalleeArgName((parantNode) as Logic);
+                }
+                // 如果节点参数增加页面也要更新
+                if (minRange.node instanceof Destination && node instanceof Param) {
+                    minRange.node.setViewArgument((parantNode) as View);
                 }
             }
         });
-        // 结束修改 ，批量操作
-        App.emit('collect:end');
+    },
+    _addParamsPrepare(node: BaseNode, refsList: any[], needAdd: boolean) {
+        if (needAdd) {
+            const App = node?.rootNode;
+            const parantNode = node?.parentNode as Logic | View;
+            // 收集修改
+            App.emit('collect:start', {
+                actionMsg: '增加逻辑参数',
+            });
+            node.create({
+                index: 0,
+                parentNode: parantNode,
+                parentKey: node.parentKey,
+            });
+            naslServer._addParamsEffect(refsList, (node) as Param);
+            // 结束修改 ，批量操作
+            App.emit('collect:end');
+            return node;
+        }
+        naslServer._addParamsEffect(refsList, (node) as Param);
+        return node;
+    },
+    // 查找引用
+    async findReferences(node: BaseNode) {
+        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<BaseNode, Array<Array<QuoteNode>>>();
+        // 普通节点和要输出的节点做一个映射，为了引用地址一样
+        const nodeMap = new Map<BaseNode, QuoteNode>();
+        try {
+            refsList.forEach((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return;
+                const minRange = this._findMinRange(record, fileNode as 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: MinRange, fileNode: BaseNode, resMap: ResMap) {
+    _getTreeMap(minRange: MinRange, fileNode: BaseNode, resMap: Map<BaseNode, Array<Array<QuoteNode>>>, nodeMap: Map<BaseNode, QuoteNode>) {
         const minRangeNode = minRange.node;
-        let parantNode = minRangeNode;
+        let currentNode = minRangeNode;
+        let parantNode = currentNode.parentNode;
         // 顺序队列
         const queue: any[] = [];
         // 先插入自己,如果没有在往上找,
         // 一直到file节点的父级
-        while (parantNode !== fileNode.parentNode) {
+        while (!(parantNode instanceof App)) {
             // 找到上一级 在map对象中构造出他的子集
-            const currentNode = parantNode;
+            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')
+            if (currentNode instanceof ViewElement && (currentNode as ViewElement).tag === 'l-root')
+                isNeedPush = false;
+            else if (currentNode instanceof Argument)
                 isNeedPush = false;
             else if (currentNode instanceof Assignment)
                 isNeedPush = false;
@@ -967,13 +1178,11 @@ const naslServer = {
                 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());
+                let icon = '';
                 if (currentNode instanceof ViewElement)
                     icon = 'element';
                 else if (currentNode instanceof BindAttribute)
@@ -982,55 +1191,34 @@ const naslServer = {
                     icon = 'logicNode';
                 else if (currentNode instanceof CallLogic) {
                     icon = 'interface';
-                    name = '调用逻辑';
                 }
-                queue.unshift({ name, node: currentNode, expanded: true, icon });
+
+                // 相同节点使用一个引用
+                if (nodeMap.get(currentNode)) {
+                    queue.unshift(nodeMap.get(currentNode));
+                } else {
+                    const quoteNode: QuoteNode = { node: currentNode, expanded: true, icon };
+                    nodeMap.set(currentNode, quoteNode);
+                    queue.unshift(quoteNode);
+                }
             }
         }
 
-        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);
+        if (resMap.get(currentNode)) {
+            // 是否展示两个内容全等，但是两个queue的node可能不一样，但是只需要展示一个
+            resMap.get(currentNode).push(queue);
         } else {
-            resMap[key] = {
-                queue: queue.length ? [queue] : [],
-                concept: fileNode.concept,
-                name: fileNode.name,
-                node: fileNode,
-            };
+            resMap.set(currentNode, [queue]);
         }
     },
-    handleTreeMap(tree: ResMap) {
-        const treeNodeMap: treeNode = {};
-        for (const [sub, val] of Object.entries(tree)) {
+    handleTreeMap(resMap: Map<BaseNode, Array<Array<QuoteNode>>>) {
+        const treeNodeMap = new Map();
+        resMap.forEach((value, fileNode) => {
             // 循环处理tree的queue
-            const treeObj = naslServer.handleTreeQueue(val.queue);
-            if (treeNodeMap[val.concept]) {
-                treeNodeMap[val.concept].push(treeObj);
-            } else {
-                treeNodeMap[val.concept] = [treeObj];
-            }
-        }
+            const treeObj = naslServer.handleTreeQueue(value);
+            treeNodeMap.set(fileNode, treeObj);
+        });
         return treeNodeMap;
     },
     /**
@@ -1039,30 +1227,26 @@ const naslServer = {
      * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
      * @returns 最后要使用到的节点和对应的子集
      */
-    handleTreeQueue(arr: QuoteNode[][]) {
-        const map: { [propName: string]: QuoteNode[] } = {};
-        let root: null | QuoteNode = null;
-        if (!arr.length)
+    handleTreeQueue(queueLists: Array<Array<QuoteNode>>) {
+        const map = new Map<QuoteNode, Array<QuoteNode>>();
+        let root: QuoteNode = null;
+        if (!queueLists.length)
             return;
-        for (const sub of arr) {
+        for (const queueList of queueLists) {
             let preNode = null;
-            for (const item of sub) {
-                const node = item;
-                const key = item.name;
-
-                if (!map[key]) {
-                    map[key] = [];
+            for (const queueItem of queueList) {
+                if (!map.get(queueItem)) {
+                    map.set(queueItem, []);
                 }
                 if (preNode) {
-                    const preKey = preNode.name;
-                    const find = map[preKey].find((item) => node.name === item.name);
+                    const find = map.get(preNode).find((item: QuoteNode) => item === queueItem);
                     if (!find) {
-                        map[preKey].push(node);
+                        map.get(preNode).push(queueItem);
                     }
                 } else {
-                    root = node;
+                    root = queueItem;
                 }
-                preNode = node;
+                preNode = queueItem;
             }
         }
         const children = naslServer._recursionCreateResult(root, map);
@@ -1074,14 +1258,12 @@ const naslServer = {
      * @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));
+    _recursionCreateResult(root: QuoteNode, map: Map<QuoteNode, Array<QuoteNode>>) {
+        const children = map.get(root).map((item: QuoteNode) => naslServer._recursionCreateResult(item, map));
         if (children && children.length) {
-            node.children = children;
+            root.children = children;
         }
-        return node;
+        return root;
     },
 
     /**
@@ -1089,12 +1271,13 @@ const naslServer = {
      *  当前this上下文 的Source 和 父级文件级别的节点
      */
     getCurrentSource(node: BaseNode) {
+        if (node instanceof App || node instanceof Theme)
+            return { fileNode: null };
         let sourceMap = node.sourceMap;
         let fileNode = node;
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
         // 如果 节点找到 app 或者module 停止
-
-        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof App) && !(fileNode.parentNode instanceof Module)) {
+        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof App) && !(fileNode.parentNode instanceof Module) && !(fileNode instanceof View)) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -1117,7 +1300,6 @@ const naslServer = {
     // 获取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(),
@@ -1165,221 +1347,8 @@ async function handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: Re
     // 更新文件之后
     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场景下的更新
@@ -1400,19 +1369,22 @@ async function handleChange(fileNode: BaseNode, targetNode: BaseNode, result: Re
         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, () => {});
+    if (action === 'create' && (targetNode as any).__init) {
+        // 清除临时状态, 完成本次创建
+        delete (targetNode as any).__init;
+        if (fileNode === targetNode && filesToCheck.size > 1) {
+            const confirmParms = {
+                actionType: 'createEstablishConnection',
+                node: fileNode,
+                icon: 'success',
+            };
+            invokeCommand('tsConfirm.open', confirmParms, () => {});
+        }
     }
-    await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
 }
 
 /**
@@ -1426,7 +1398,6 @@ async function handleChange(fileNode: BaseNode, targetNode: BaseNode, result: Re
 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) {
@@ -1461,36 +1432,98 @@ async function handleRename(fileNode: BaseNode, targetNode: BaseNode, result: Re
 
         // 文件级别重命名，有依赖才唤起弹框
         // 唤起重命名，提示有连接弹框
-        if (newRefFileList.size > 1) {
-            const confirmParms = {
-                actionType: 'renameEstablishConnection',
-                node: fileNode,
-            };
-            invokeCommand('tsConfirm.open', confirmParms, () => {});
-        }
+        // 重命名建立连接先不展示弹框了
+
+        // if (newRefFileList.size > 1) {
+        //     const confirmParms = {
+        //         actionType: 'renameEstablishConnection',
+        //         node: fileNode,
+        //         icon: 'success',
+        //     };
+        //     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 });
+        if (currentSource) {
+            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));
+            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));
+        }
     }
+}
+
+/**
+ * 处理一些节点操作，子节点需要更新并且check的场景
+ * 因为删除，新增父页面，或者重命名会一起
+ * 删除或者新增view而且他有子集 就要执行同样的操作
+ * @param action 当前操作类型
+ * @param fileNode 文件节点
+ * @param targetNode 操作节点  这里要两个相等才会走家去面对哦逻辑
+ * @param oldpath 触发内容的oldpath
+ */
+async function incidentalAction(action: string, fileNode: BaseNode, targetNode: BaseNode, oldpath?: string) {
+    if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
+        // 删除或者新增页面
+        if (fileNode instanceof View && fileNode.children?.length) {
+            const fileNodeChildren = fileNode.children;
+            for (let i = 0; i < fileNodeChildren.length; i++) {
+                const fileNodeItem = fileNodeChildren[i];
+                const result = (fileNodeItem as FileNode).toEmbeddedTSFile();
+                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 Module) {
+            const module: Module = (targetNode) as Module;
+            const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
+            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);
+                }
+            }
 
-    console.log('filesToCheck', filesToCheck, filesToCheck.size);
-    await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-    // outputFiles.map((file) => file.file));
+            // 删除模块通知更新列表
+            if (action === 'delete') {
+                try {
+                    // 如果已经
+                    invokeCommand('module.delete', true);
+                } catch (err) {
+                    console.log('module.delete', '组件销毁了,不用唤起了');
+                }
+            }
+        }
+    }
 }
 
 async function receiveHandleChange($event: EventPayload) {
@@ -1500,7 +1533,11 @@ async function receiveHandleChange($event: EventPayload) {
     // 当前操作的文件节点
     const { fileNode } = naslServer.getCurrentSource(targetNode);
     // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
-    if (fileNode instanceof Module || fileNode instanceof Configuration) {
+    if (!fileNode || fileNode instanceof Module || fileNode instanceof Configuration) {
+        // module单独处理
+        if (fileNode instanceof Module) {
+            await incidentalAction(action, fileNode, targetNode);
+        }
         return;
     }
 
@@ -1520,25 +1557,50 @@ async function receiveHandleChange($event: EventPayload) {
 
     fileNode.sourceMap = result.sourceMap;
     if (action === 'update' || action === 'create') {
-        if ($event?.field !== 'name')
+        if ($event?.field !== 'name') {
             await handleChange(fileNode, targetNode, result, action);
-        else {
-            await handleRename(fileNode, targetNode, result, (fileNode as FileNode).getEmbeddedFilePath($event.oldName));
+            await incidentalAction(action, fileNode, targetNode);
+        } else {
+            const oldpath = (fileNode as 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;
 }
 
 // 监听所有改变操作
 embeddedTSEmitter.on('change', ($event: EventPayload) => {
     // 收集到一个行为集合
     const eventValue = $event.value;
-    eventValue.forEach((item: EventPayload) => {
-        receiveHandleChange(item.originEvent);
+    const stackList: Array<EventPayload> = [];
+    eventValue.forEach(async (item: EventPayload) => {
+        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;