@lcap/nasl 1.0.0-alpha → 1.0.0-alpha.11

package/src/server/naslServer.ts

@@ -1,5 +1,5 @@
 /// #if process.env.NODE_ENV
-import Worker from '../../../ts-worker/dist/bundle.js';
+// import Worker from '../../../ts-worker/dist/bundle.js';
 /// #else
 // import { Worker } from 'worker_threads';
 /// #endif
@@ -30,12 +30,20 @@ import {
     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,
@@ -55,14 +63,10 @@ interface setNameNode extends BaseNode {
     [propname: string]: any;
 }
 interface treeNode {
-    [propName: string]: {
-        name: string;
-        children: any[];
-        node: BaseNode;
-    }[];
+    [propName: string]: QuoteNode[];
 }
 export { transformType, translateDiagnosticMessage };
-const worker = new Worker(); // new Worker('../../../ts-worker/dist/bundle.js');
+const worker = new Worker('/ts-worker.js');
 const messager = new Messager({
     protocol: 'ts-worker',
     sender: 'ide',
@@ -108,72 +112,100 @@ const naslServer = {
      * 先用挂在点上面，简单的方法实现，后期再考虑解耦
      */
     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 {
-            const contentToFile = (module: Module | App) => {
-                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) => {
-                    const result = logic.toEmbeddedTSFile();
-                    results.push(result);
-                    logic.sourceMap = result.sourceMap;
-                    this.file2NodeMap.set(result.filePath, logic);
-                });
-
-                module.views.forEach((view) => {
-                    const result = view.toEmbeddedTSFile();
-                    results.push(result);
-                    view.sourceMap = result.sourceMap;
-                    this.file2NodeMap.set(result.filePath, view);
-                });
-                module.processes.forEach((process) => {
-                    const result = process.toEmbeddedTSFile();
-                    results.push(result);
-                    process.sourceMap = result.sourceMap;
-                    this.file2NodeMap.set(result.filePath, process);
-                });
-                app.roles.forEach((role) => {
-                    const result = role.toEmbeddedTSFile();
-                    results.push(result);
-                    // sourceMap都存在目录级别内容下，在页面层级下去找
-                    role.sourceMap = result.sourceMap;
-                    this.file2NodeMap.set(result.filePath, role);
-                });
-            };
             // app的创建内容
-            contentToFile(app);
+            naslServer.contentToFile(app, results);
             // 其他模块的创建内容
-            app.dependencies.forEach(contentToFile);
+            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);
         }
@@ -193,6 +225,26 @@ 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);
+    },
+    /**
+     * 初始化之前添加文件
+     */
+    addFile(file: tsProtocol.OpenRequestArgs) {
+        return this.messager.requestCommand('addFile', file);
+    },
     /**
      * 只新增文件
      * @param {*} files
@@ -216,7 +268,11 @@ const naslServer = {
     updateFiles(args: { outputFiles: Array<tsProtocol.OpenRequestArgs> }) {
         return this.messager.requestCommand('updateFiles', args);
     },
-    _debugInFileStorage(app: App, openFiles: Array<tsProtocol.OpenRequestArgs>) {
+    _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;
@@ -234,25 +290,90 @@ const naslServer = {
     async references(args: tsProtocol.FileLocationRequestArgs) {
         return ((await this.messager.requestCommand('references', args)) as any)?.response as tsProtocol.ReferencesResponseBody;
     },
-    getSelectCompletion(node: BaseNode) {
+    getValueSelectCompletion(node: BaseNode, value: string, noFilterList?: Array<string>) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         // console.log(currentSource, fileNode);
         if (currentSource && fileNode) {
-            return naslServer._getSelectCompletion({
+            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);
         }
     },
-    _getSelectCompletion(args: any) {
-        return this.messager.requestCommand('getSelectCompletion', args);
+    _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) {
+    getSelectNextCompletion(node: BaseNode, noFilterList?: Array<string>) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         // console.log(currentSource, fileNode);
         if (currentSource && fileNode) {
@@ -262,6 +383,7 @@ const naslServer = {
                     line: lsp2tspNumber(currentSource.range.start.line),
                     offset: lsp2tspNumber(currentSource.range.start.character),
                 },
+                noFilterList,
             });
         } else {
             console.log('没找到节点', currentSource, fileNode);
@@ -296,15 +418,24 @@ const naslServer = {
             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 = [];
-            } else {
-                record.suggestionDiagnostics = record.suggestionDiagnostics
-                    .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;
@@ -337,11 +468,29 @@ const naslServer = {
      * @returns
      */
     _diagnosticSpecialTreatment(minRange: MinRange, tsErrorDetail: Diagnostic) {
-        // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 callLogic上,
-        // 但是只少一个的时候就会找到准确的Argument上 需要特殊处理, ui层就可以统一处理
-        if (minRange.node instanceof Argument && /Expected (.+?) arguments, but got (.+?)./.exec(tsErrorDetail.text)) {
-            minRange.node = minRange.node.parentNode;
+        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,
@@ -387,39 +536,28 @@ const naslServer = {
     },
     // 查找引用
     async findReferences(node: BaseNode) {
-        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
-        let refsList: tsProtocol.ReferencesResponseItem[] = [];
-
-        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) {
-            const additionalRefs = await naslServer.references({
-                file: (fileNode as FileNode).getEmbeddedFilePath(),
-                line: lsp2tspNumber(currentSource.range.end.line + 2),
-                offset: 43,
-            });
-            refsList = [...refsList, ...additionalRefs.refs];
-        }
-        // 过滤一把不需要改的信息
-        refsList = refsList.filter((item) =>
-        // 不是创建者
-        // 如果查找引用查到自己里面的引用不展示
-            item.isDefinition !== true && (fileNode as FileNode).getEmbeddedFilePath() !== item.file);
+        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 = {};
-        // console.log(refsList, 'refsList');
         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);
                 }
             });
@@ -431,7 +569,7 @@ const naslServer = {
         console.log(result);
         return result;
     },
-    async _isHaveRef(node: BaseNode) {
+    async _isHaveRef(node: BaseNode, isFind: boolean = false) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         let refsList: tsProtocol.ReferencesResponseItem[] = [];
 
@@ -449,21 +587,15 @@ const naslServer = {
 
         // 如果是entity就需要在单独，查一边来修改名字
         if (node instanceof Entity) {
-            const additionalRefs = await naslServer.references({
-                file: (fileNode as FileNode).getEmbeddedFilePath(),
-                line: lsp2tspNumber(currentSource.range.end.line + 2),
-                offset: 43,
-            });
-            refsList = [...refsList, ...additionalRefs.refs];
             // 过滤一把不需要改的信息
             refsList = refsList.filter((item) =>
             // 不再当前文件里
             // 或者在当前列表但是位置小于entity的结束位置
-                (fileNode as FileNode).getEmbeddedFilePath() !== item.file || item.end.line < currentSource.range.end.line);
+                (fileNode as FileNode).getEmbeddedFilePath() !== item.file);
         }
 
         // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
-        if (node instanceof Param) {
+        if (node instanceof Param && node.parentNode instanceof Logic) {
             const logicNode = node.parentNode;
             const { currentSource } = naslServer.getCurrentSource(logicNode);
             const parentRefs = await naslServer.references({
@@ -473,6 +605,22 @@ const naslServer = {
             });
             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 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
          * 找到第一个 { 之前的变量 进行修改
@@ -489,6 +637,31 @@ const naslServer = {
             });
             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;
     },
     /**
@@ -519,21 +692,36 @@ const naslServer = {
                     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) {
+                    if (minRange.node instanceof CallLogic && (node instanceof Entity || node instanceof View)) {
                         // 匹配到的内容，当前这一行的内容；
                         // 因为要用下面的点位信息
-                        const namespace = minRange.node.calleeNamespace;
+                        /**
+                         * 如果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(namespace);
+                        const index = lineText.indexOf(tsCalleeNamespace);
                         // 在把开始结束位置的-开始位置，来知道是哪里要替换
                         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);
+                        let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                        newTsNameSpace = newTsNameSpace.replace(/.$/g, '.');
                         minRange.setTypeMethods = 'setCalleeNamespace';
-                        minRange.newValue = newTextValue;
+                        minRange.newValue = newTsNameSpace;
                     }
                     // 如果参数修改影响了 callLogic
                     if (minRange.node instanceof CallLogic && node instanceof Param) {
@@ -572,6 +760,11 @@ const naslServer = {
                             minRange.newValue = newTextValue;
                         }
                     }
+                    // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
+                    if (minRange.node instanceof Identifier && node instanceof Logic) {
+                        minRange.newValue = newValue;
+                        minRange.setTypeMethods = 'setName';
+                    }
                     // 如果节点是MemberExpression表达式
                     if (minRange.node instanceof MemberExpression) {
                         // 匹配到的内容，当前这一行的内容；
@@ -609,65 +802,84 @@ const naslServer = {
                     }
                     // 如果是跳转逻辑的修改
                     // 跳转逻辑本身页面 都需要带 View前缀
-                    if (minRange.node instanceof Destination) {
-                        const viewName = minRange.node.viewName;
-                        const viewNamespace = minRange.node.viewNamespace;
-                        const oldValue = viewNamespace + '.' + viewName;
+                    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;
-                        // 新的完整的value
-                        const newTextValue = oldValue.substring(0, start) + newValue + oldValue.substring(end, oldValue.length);
-                        const newValueArr = newTextValue.split('.');
-                        const newViewName = newValueArr[newValueArr.length - 1];
-
-                        if (newViewName !== viewName) {
+                        if (start > tsCalleeNamespace.length) {
                             minRange.setTypeMethods = 'setViewName';
                             minRange.newValue = newValue;
                         } else {
-                            newValueArr.pop();
-                            let newViewNamespace = '';
-                            newValueArr.forEach((item, index) => {
-                                newViewNamespace += index === 0 ? item : '.' + item;
-                            });
+                            // 新的完整的value
+                            let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
                             minRange.setTypeMethods = 'setViewNamespace';
-                            minRange.newValue = newViewNamespace;
+                            newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                            minRange.newValue = newTsNameSpace;
                         }
                     }
                     // 如果是事件修改
                     // 如果是view也需要加前缀
+                    // logic 和 views名称修改 可能会触发bindEvent修改
                     if (minRange.node instanceof BindEvent) {
-                        const calleeName = minRange.node.calleeName;
-                        const calleeNamespace = minRange.node.calleeNamespace;
-                        const oldValue = calleeNamespace + '.' + calleeName;
+                        /**
+                         * 如果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
-                        // 这里判断的时候先把view前缀加上，无所谓，要是下面判断改得是逻辑名，也是复制逻辑名，要是命名空间的话，可以直接使用值
-                        const newTextValue = oldValue.substring(0, start) + newValue + oldValue.substring(end, oldValue.length);
-                        const newValueArr = newTextValue.split('.');
-                        const newCalleeName = newValueArr[newValueArr.length - 1];
-                        if (newCalleeName !== calleeName) {
+                        if (start > tsCalleeNamespace.length) {
                             minRange.setTypeMethods = 'setCalleeName';
                             minRange.newValue = newValue;
                         } else {
-                            newValueArr.pop();
-                            let newCalleeNamespace = '';
-                            newValueArr.forEach((item, index) => {
-                                newCalleeNamespace += index === 0 ? item : '.' + item;
-                            });
+                            // 新的完整的value
+                            let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
                             minRange.setTypeMethods = 'setCalleeNamespace';
-                            minRange.newValue = newCalleeNamespace;
+                            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) {
                         // 什么都不做，用来跳过修改
@@ -682,6 +894,10 @@ const naslServer = {
                     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);
@@ -698,7 +914,9 @@ const naslServer = {
         const App = node.rootNode;
         const LogicNode = node.parentNode as Logic;
         // 收集修改
-        App.emit('collect:start');
+        App.emit('collect:start', {
+            actionMsg: '增加逻辑参数',
+        });
         node.create({
             index: 0,
             parentNode: LogicNode,
@@ -724,23 +942,74 @@ const naslServer = {
         const minRangeNode = minRange.node;
         let parantNode = minRangeNode;
         // 顺序队列
-        const queue = [];
-        // 先插入自己,如果没有在往上找
-        while (parantNode !== fileNode) {
+        const queue: any[] = [];
+        // 先插入自己,如果没有在往上找,
+        // 一直到file节点的父级
+        while (parantNode !== fileNode.parentNode) {
             // 找到上一级 在map对象中构造出他的子集
             const currentNode = parantNode;
             parantNode = parantNode.parentNode;
             // 如果第一次就塞入子集和父节点，以后就只用父节点了
             // 因为部分节点没有name，先过滤掉
-            if (currentNode.name) {
-                queue.unshift({ name: currentNode.name, node: currentNode });
+            // 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 = parantNode.concept + parantNode.name;
         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] = {
@@ -754,25 +1023,12 @@ const naslServer = {
     handleTreeMap(tree: ResMap) {
         const treeNodeMap: treeNode = {};
         for (const [sub, val] of Object.entries(tree)) {
-            if (!treeNodeMap[val.concept]) {
-                treeNodeMap[val.concept] = [];
-            }
             // 循环处理tree的queue
             const treeObj = naslServer.handleTreeQueue(val.queue);
-            if (treeNodeMap[val.concept].length) {
-                treeNodeMap[val.concept].push({
-                    name: sub,
-                    children: treeObj,
-                    node: val.node,
-                });
+            if (treeNodeMap[val.concept]) {
+                treeNodeMap[val.concept].push(treeObj);
             } else {
-                treeNodeMap[val.concept] = [
-                    {
-                        name: sub,
-                        children: treeObj,
-                        node: val.node,
-                    },
-                ];
+                treeNodeMap[val.concept] = [treeObj];
             }
         }
         return treeNodeMap;
@@ -810,7 +1066,7 @@ const naslServer = {
             }
         }
         const children = naslServer._recursionCreateResult(root, map);
-        return [children];
+        return children;
     },
     /**
      * 递归调用输出结果
@@ -819,7 +1075,6 @@ const naslServer = {
      * @returns 当前节点，最后输出所有节点
      */
     _recursionCreateResult(root: QuoteNode, map: { [propName: string]: QuoteNode[] }) {
-        console.log(root);
         const node = root;
         const rootKey = root.name;
         const children = map[rootKey].map((item: QuoteNode) => naslServer._recursionCreateResult(item, map));
@@ -837,7 +1092,9 @@ const naslServer = {
         let sourceMap = node.sourceMap;
         let fileNode = node;
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
-        while (!sourceMap && fileNode && fileNode.parentNode.concept !== 'App') {
+        // 如果 节点找到 app 或者module 停止
+
+        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof App) && !(fileNode.parentNode instanceof Module)) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -857,6 +1114,26 @@ 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(),
+                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);
+    },
 };
 /**
  * 处理删除节点
@@ -864,7 +1141,7 @@ const naslServer = {
  * @param targetNode 当前操作的节点
  * @param result toTs生成的内容
  */
- async function handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: ReturnType<Structure['toEmbeddedTSFile']>) {
+async function handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: ReturnType<Structure['toEmbeddedTSFile']>) {
     const filePath = (fileNode as FileNode).getEmbeddedFilePath();
     // 如果要删除，而且当前要删Logic就直接删除并且清除错误
     /**
@@ -902,6 +1179,8 @@ BaseNode.prototype.findUsage = function findUsage() {
     }
 };
 BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
+    console.log(newValue);
+    console.log(this);
     try {
         /**
          * 查找这个节点是不是有依赖
@@ -922,7 +1201,9 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
                 if (value) {
                     const App = this.rootNode;
                     // 收集修改
-                    App.emit('collect:start');
+                    App.emit('collect:start', {
+                        actionMsg: '重命名并更新引用',
+                    });
                     res.forEach((item) => {
                         const itemNode = item.node as setNameNode;
                         if (item.newValue) {
@@ -971,29 +1252,38 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
         /**
          * 查找这个节点是不是有依赖
          */
-        const refsList = await naslServer._isHaveRef(this);
+        const node = this;
+        const refsList = await naslServer._isHaveRef(node);
         // console.log(refsList, 'refsList');
         const confirmParms = {
             actionType: 'delete',
             tipFlag: false,
-            node: this,
+            node,
         };
         let callback = null;
         if (refsList.length <= 1) {
             callback = () => {
-                this.delete();
+                // 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 (this instanceof Param) {
+                if (node instanceof Param) {
                     const App = this.rootNode;
                     const logicNode = this.parentNode;
                     // 收集修改
-                    App.emit('collect:start');
+                    App.emit('collect:start', {
+                        actionMsg: '删除参数',
+                    });
                     this.delete();
                     refsList.forEach((record) => {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
@@ -1010,8 +1300,64 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     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;
+                }
+
                 // 其余的都直接调用删除
-                this.delete();
+                // Structure 和 Interface是内部有delete方法
+                if (node instanceof Structure || node instanceof Interface) {
+                    (this as any).deleteLogincAndModule();
+                } else {
+                    this.delete();
+                }
             };
         }
         invokeCommand('tsConfirm.open', confirmParms, callback);
@@ -1153,8 +1499,13 @@ async function receiveHandleChange($event: EventPayload) {
     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;
@@ -1186,7 +1537,7 @@ embeddedTSEmitter.on('change', ($event: EventPayload) => {
     // 收集到一个行为集合
     const eventValue = $event.value;
     eventValue.forEach((item: EventPayload) => {
-        receiveHandleChange(item);
+        receiveHandleChange(item.originEvent);
     });
 });