@lcap/nasl 1.0.0-alpha.13 → 1.0.0-alpha.16

package/src/server/naslServer.ts

@@ -39,10 +39,13 @@ import {
     CallInterface,
     Return,
     ProcessElement,
+    NullLiteral,
+    Namespace,
+    Theme,
 } 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';
@@ -61,12 +64,11 @@ interface FileNode extends BaseNode {
     };
 }
 
-interface setNameNode extends BaseNode {
+interface SetNameNode extends BaseNode {
     setName(name: string): any;
     [propname: string]: any;
 }
 
-export { transformType, translateDiagnosticMessage };
 const worker = new Worker('/ts-worker.js');
 const messager = new Messager({
     protocol: 'ts-worker',
@@ -81,10 +83,6 @@ const messager = new Messager({
     },
 });
 
-interface MinRange {
-    node: BaseNode;
-    item: SourceMapItem;
-}
 interface reNameMinRange extends MinRange {
     newValue?: any;
     setTypeMethods?: string;
@@ -110,12 +108,18 @@ 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();
@@ -207,20 +211,22 @@ const naslServer = {
         }
     },
     view2TSFile(viewsChildren: View[], results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
-        // 子页面
-        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);
+        // 如果有子页面
+        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);
                 }
-            } catch (err) {
-                console.log(err);
-            }
-        });
+            });
+        }
     },
     async openApp(app: App) {
         const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
@@ -250,19 +256,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();
     },
     /**
      * 初始化之前添加文件
@@ -277,14 +280,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);
-    },
+
     /**
      * 新增、修改
      * 删除文件 文件用修改内容为空模拟，防止报错
@@ -293,21 +289,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>) {
-        try {
-            if (window && window.location.host.includes('localhost')) {
-                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 (err) {
-            console.log(err);
+        /// #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');
@@ -348,7 +349,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;
@@ -363,7 +366,7 @@ const naslServer = {
         return typeList;
     },
     async getTypeQuickinfo(node: BaseNode) {
-        if (node instanceof Identifier) {
+        if (node && node instanceof BaseNode) {
             const callFunction = node.parentNode.parentNode;
             /**
              * currentSource callFunction 的节点，要去到当前节点的位置
@@ -384,22 +387,45 @@ const naslServer = {
                     const typeAnnotation = primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
                     if (typeAnnotation) {
                         res.push(typeAnnotation);
-                    } else if (type === 'unknown') {
+                    } else if (type === 'unknown' || type === 'never') {
                         return null;
                     }
                 });
                 if (!res.length) {
-                    res = primitiveTypeList;
+                    return [];
+                } else {
+                    return [{ title: '基础类型', children: res }];
                 }
-                // 调整结构
-                const dataTypeList: Array<{
-                    title: string;
-                    children: Array<TypeAnnotation>;
-                }> = [{ title: '基础类型', children: res }];
-                return dataTypeList;
             }
+        } 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;
+                }
+                return str;
+            }
+        }
+        return '';
+    },
     _getTypeQuickinfo(args: any) {
         return this.messager.requestCommand('quickInfo', args) as unknown as { responseRequired: boolean; response: tsProtocol.QuickInfoResponseBody };
     },
@@ -446,7 +472,7 @@ const naslServer = {
 
             // 语义诊断
             record.semanticDiagnostics = record.semanticDiagnostics
-                .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, (node as FileNode)))
+                .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode))
                 .filter((diag) => !!diag);
 
             // 建议诊断
@@ -480,9 +506,8 @@ const naslServer = {
         };
 
         if (minRange) {
-            // let message = this.translateDiagnosticMessage(diagnostic.text);
             // 节点的error要置为true
-            return naslServer._diagnosticSpecialTreatment(minRange, tsErrorDetail);
+            return naslNodeTranslateMessage(minRange, tsErrorDetail);
         } else {
             // 没找到节点， 先把问题暴露出来
             return {
@@ -491,60 +516,6 @@ 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) {
-            if (/Expected (.+?) arguments, but got (.+?)./.exec(text)) {
-                minRange.node = minRange.node.parentNode;
-            } else {
-                // if (/Type '(.+?)' is not assignable to type '(.+?)'./.exec(text)) {
-                // }
-                // Argument在callInterface上的报错放到内部
-                if (minRange.node.expression) {
-                    minRange.node = minRange.node.expression;
-                }
-            }
-        }
-
-        if (/'(.+?)' has no exported member(?: named)? '(.+?)'/.exec(text) || /Property '(.+?)' does not exist on type '(.+?)'./.exec(text)) {
-            if (minRange.node instanceof TypeAnnotation) {
-                // 变量type的报错放到内部
-                minRange.node = minRange.node.parentNode;
-            }
-        }
-
-        minRange.node.tsErrorDetail = tsErrorDetail;
-        return {
-            id: minRange.node.id,
-            node: minRange.node,
-            ...tsErrorDetail,
-        };
-    },
     _findMinRange(diagnostic: tsProtocol.DiagnosticWithFileName | tsProtocol.ReferencesResponseItem, fileNode: FileNode) {
         let minRange: MinRange;
         const sourceMap: SourceMap = fileNode.sourceMap;
@@ -599,6 +570,23 @@ 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就需要在单独，查一边来修改名字
@@ -611,7 +599,7 @@ const naslServer = {
 
         if (node instanceof Return) {
             // 过滤一下最后出去的值
-            refsList = refsList.filter((item) => !(item.lineText.includes('return ')));
+            refsList = refsList.filter((item) => !item.lineText.includes('return '));
         }
 
         // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
@@ -672,18 +660,24 @@ const naslServer = {
                     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;
+                const methodRefs: tsProtocol.ReferencesResponseItem[] = [];
+                methods.refs.forEach((item) => {
+                    // 定义里的格式，在删除的时候留下来占位
+                    // 重命名的时候会过滤
+
+                    // 这里只过滤 __elements.button = new nasl.ui.Button<any>这种格式
+                    // if (item.lineText.includes('__elements.') && item.lineText.includes('new nasl.ui.'))
+                    //     return false;
+                    // 处理声明组件名可能重复的问题， 查找引用不提示
+                    const find = methodRefs.find((findItem) => item.lineText === findItem.lineText && item.lineText.includes(': nasl.ui.'));
+                    if (!find) {
+                        methodRefs.push(item);
                     }
-                    return true;
                 });
                 refsList = [...methodRefs];
             }
         }
+        console.log(refsList, 'refsList');
         return refsList;
     },
     /**
@@ -701,7 +695,7 @@ const naslServer = {
                 const fileNode = this.file2NodeMap.get(record.file);
                 if (!fileNode)
                     return null;
-                const minRange: reNameMinRange = this._findMinRange(record, (fileNode as FileNode));
+                const minRange: reNameMinRange = this._findMinRange(record, fileNode as FileNode);
                 if (minRange) {
                     // 如果节点是TypeAnnotation类型,
                     // 很复杂，可能是多级嵌套结构
@@ -715,7 +709,7 @@ 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修改
@@ -862,7 +856,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
@@ -871,26 +870,45 @@ const naslServer = {
                          * 2.在匹配到的内容中取转后的namespace的位置
                          * 3.然后把namespace中的 $替换成 ''
                          */
-                        const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
-                        const oldValue = tsCalleeNamespace;
-                        // 先看下标位置
-                        const lineText = record.lineText;
-                        const index = lineText.indexOf(oldValue);
+                            const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                            const oldValue = tsCalleeNamespace;
 
-                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
-                        const start = record.start.offset - index - 1;
-                        const end = record.end.offset - index - 1;
+                            // 先看下标位置
+                            const lineText = record.lineText;
+                            const index = lineText.indexOf(oldValue);
+
+                            // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                            const start = record.start.offset - index - 1;
+                            const end = record.end.offset - index - 1;
 
-                        // 新的完整的value
-                        if (start > tsCalleeNamespace.length) {
-                            minRange.setTypeMethods = 'setCalleeName';
-                            minRange.newValue = newValue;
-                        } else {
                             // 新的完整的value
-                            let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
-                            minRange.setTypeMethods = 'setCalleeNamespace';
-                            newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
-                            minRange.newValue = newTsNameSpace;
+                            if (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) {
@@ -906,17 +924,17 @@ const naslServer = {
                         const newBindRoles = str.split(',');
                         minRange.newValue = newBindRoles;
                     }
-                    if ((minRange.node instanceof QueryFieldExpression) && (node instanceof Entity)) {
+                    if (minRange.node instanceof QueryFieldExpression && node instanceof Entity) {
                         minRange.setTypeMethods = 'setEntityAsName';
                     }
 
-                    if ((minRange.node instanceof QueryFromExpression) && (node instanceof Entity)) {
+                    if ((minRange.node instanceof QueryFromExpression || minRange.node instanceof QueryJoinExpression) && node instanceof Entity) {
                         minRange.setTypeMethods = 'setEntityName';
                     }
-                    if ((minRange.node instanceof QueryFieldExpression) && (node instanceof EntityProperty)) {
+                    if (minRange.node instanceof QueryFieldExpression && node instanceof EntityProperty) {
                         minRange.setTypeMethods = 'setPropertyName';
                     }
-                    if (minRange.node instanceof Destination && node instanceof Process) {
+                    if (minRange.node instanceof Destination && (node instanceof Process || node instanceof ProcessElement)) {
                         return null;
                     }
                     // 枚举修改枚举名，比较特殊
@@ -928,8 +946,8 @@ const naslServer = {
                     if (minRange.node instanceof Logic && node instanceof Param) {
                         return null;
                     }
-                    // 如果是修改param查找到Destination就不操作
-                    if (minRange.node instanceof Destination && node instanceof Param) {
+                    // params修改 查找bindevent不需要修改
+                    if (minRange.node instanceof BindEvent && node instanceof Param) {
                         return null;
                     }
                     // 如果是子页面修改
@@ -937,8 +955,37 @@ 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改名
+                    if (minRange.node instanceof Logic && node instanceof Process) {
+                        return null;
+                    }
+                    if (minRange.node instanceof Logic && node instanceof ProcessElement && node.type === 'UserTask') {
                         return null;
                     }
                 } else {
@@ -955,25 +1002,29 @@ const naslServer = {
     },
     _addParamsPrepare(node: BaseNode, refsList: any[]) {
         const App = node.rootNode;
-        const LogicNode = node.parentNode as Logic;
+        const parantNode = node.parentNode as Logic | View;
         // 收集修改
         App.emit('collect:start', {
             actionMsg: '增加逻辑参数',
         });
         node.create({
             index: 0,
-            parentNode: LogicNode,
+            parentNode: parantNode,
             parentKey: node.parentKey,
         });
         refsList.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.file);
             if (!fileNode)
                 return null;
-            const minRange: MinRange = this._findMinRange(record, (fileNode as FileNode));
+            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);
                 }
             }
         });
@@ -983,10 +1034,13 @@ const naslServer = {
     // 查找引用
     async findReferences(node: BaseNode) {
         let refsList = await naslServer._isHaveRef(node);
-        console.log(refsList, 'refsList');
         // 如果查找引用查到自己里面的引用不展示
-        refsList = refsList.filter((item) => !item.isDefinition);
-
+        refsList = refsList.filter((item) => {
+            // 自己引用自己的过滤掉
+            // 删除的时候过滤一把组件删除提示
+            // 展示组件自己屏蔽掉
+            return !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.'));
+        });
         // 最后返回的结果
         let result = new Map();
         // 树的构造，key： 一个file的node， 值是 [[logic, params],[logic, returns]]
@@ -998,7 +1052,7 @@ const naslServer = {
                 const fileNode = this.file2NodeMap.get(record.file);
                 if (!fileNode)
                     return;
-                const minRange = this._findMinRange(record, (fileNode as FileNode));
+                const minRange = this._findMinRange(record, fileNode as FileNode);
                 // 过滤一把不需要改的信息
                 if (minRange) {
                     // 拼装树
@@ -1034,7 +1088,9 @@ const naslServer = {
             // 排除一些不放入集合的节点
             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;
@@ -1137,6 +1193,8 @@ 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结束
@@ -1216,6 +1274,47 @@ async function handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: Re
     // console.log('filesToCheck', filesToCheck, filesToCheck.size);
     await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
 }
+BaseNode.prototype.findReadOnlyLogicUsage = function () {
+    let targetNode;
+
+    if (this.parentNode.concept === 'Namespace' || this.parentNode.parentNode.concept === 'Namespace') {
+        const sourceMap = this.parentNode.concept === 'Namespace' ? this.parentNode.parentNode.sourceMap : this.parentNode.parentNode.parentNode.sourceMap;
+        for (const item of sourceMap) {
+            const logic = item[0] as Logic;
+            if (this.concept === 'Logic') {
+                if (logic instanceof Logic)
+                    if (logic.calleewholeKey === (this as Logic).calleewholeKey) {
+                        targetNode = logic;
+                        break;
+                    }
+            } else {
+                if (logic instanceof Logic)
+                    if (logic.calleewholeKey === (this.parentNode as Logic).calleewholeKey) {
+                        targetNode = logic;
+                        break;
+                    }
+            }
+        }
+    } else if (this.parentNode.concept === 'Module') {
+        // 父级是模块的还是用它本身去查找引用
+        targetNode = this;
+    } else {
+        const sourceMap = this.parentNode.sourceMap;
+        for (const item of sourceMap) {
+            const logic = item[0] as Logic;
+            if (logic.getNamespace && logic.getNamespace() === (this as Logic).getNamespace()) {
+                targetNode = logic;
+                break;
+            }
+        }
+    }
+
+    try {
+        return naslServer.findReferences(targetNode);
+    } catch (err) {
+        console.log(err);
+    }
+};
 // 查找引用
 BaseNode.prototype.findUsage = function findUsage() {
     try {
@@ -1241,7 +1340,7 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
          */
         const res = naslServer._renamePrepare(this, refsList, newValue);
         if (res.length <= 1) {
-            (this as setNameNode).setName(newValue);
+            (this as SetNameNode).setName(newValue);
         } else {
             const callback = (value: boolean) => {
                 if (value) {
@@ -1251,7 +1350,7 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
                         actionMsg: '重命名并更新引用',
                     });
                     res.forEach((item) => {
-                        const itemNode = item.node as setNameNode;
+                        const itemNode = item.node as SetNameNode;
                         if (item.newValue) {
                             // 如果有指定的修改方法，就用那个，没有就修改名字
                             item.setTypeMethods ? itemNode[item.setTypeMethods](item.newValue) : itemNode.setName?.(item.newValue);
@@ -1262,7 +1361,7 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
                     // 结束修改 ，批量操作
                     App.emit('collect:end');
                 } else {
-                    (this as setNameNode).setName(newValue);
+                    (this as SetNameNode).setName(newValue);
                 }
             };
             const confirmParms = {
@@ -1300,8 +1399,26 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
          * 查找这个节点是不是有依赖
          */
         const node = this;
-        const refsList = await naslServer._isHaveRef(node);
-        console.log(refsList, 'refsList');
+        let refsList = await naslServer._isHaveRef(node);
+        // 删除的时候过滤一把组件删除提示
+        refsList = refsList.filter((item) => {
+            // 因为ui组件本身会多渲染一次,就先过滤一个 
+            return !(item.lineText.includes(': nasl.ui.'));
+        });
+        // 删除参数单独处理
+        if (node instanceof Param) {
+            const methodRefs: tsProtocol.ReferencesResponseItem[] = [];
+            refsList.forEach((item) => {
+                // 入参查找引用,查到logic 和自己,内容完全一样,就保留一个
+                const find = methodRefs.find((findItem) => item.lineText === findItem.lineText);
+                if (!find) {
+                    methodRefs.push(item);
+                }
+            });
+            refsList = methodRefs;
+        }
+
+        // delete的弹框展示
         const confirmParms = {
             actionType: 'delete',
             tipFlag: false,
@@ -1327,12 +1444,27 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
             // 如果有依赖就有一个查找引用提示
             confirmParms.tipFlag = true;
             const node = this;
+
+            // 删除页面或者流程
+            if (node instanceof View || node instanceof Process) {
+                /**
+                 * 查找这个页面是不是有依赖
+                 */
+                let viewPath = (this as FileNode).getEmbeddedFilePath();
+                viewPath = viewPath.slice(0, viewPath.length - 3);
+                const find = refsList.find((record) => !record.file.includes(viewPath));
+                // 如果没有别的文件的依赖，就直接delete
+                if (!find) {
+                    this.delete();
+                    return;
+                }
+            }
             callback = () => {
                 // removeParam
                 // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
                 if (node instanceof Param) {
                     const App = this.rootNode;
-                    const logicNode = this.parentNode;
+                    const parentNode = this.parentNode;
                     // 收集修改
                     App.emit('collect:start', {
                         actionMsg: '删除参数',
@@ -1342,10 +1474,13 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
                         if (!fileNode)
                             return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, (fileNode as FileNode));
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
                         if (minRange) {
                             if (minRange.node instanceof CallLogic) {
-                                minRange.node.setCalleeArgName(logicNode as Logic);
+                                minRange.node.setCalleeArgName(parentNode as Logic);
+                            }
+                            if (minRange.node instanceof Destination) {
+                                minRange.node.setViewArgument(parentNode as View);
                             }
                         }
                     });
@@ -1365,7 +1500,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
                         if (!fileNode)
                             return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, (fileNode as FileNode));
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
                         if (minRange) {
                             if (minRange.node instanceof Interface) {
                                 minRange.node.delete();
@@ -1374,6 +1509,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     });
                     // 结束修改 ，批量操作
                     App.emit('collect:end');
+                    return;
                 }
                 // 删除权限节点
                 if (node instanceof Role) {
@@ -1387,7 +1523,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
                         if (!fileNode)
                             return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, (fileNode as FileNode));
+                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
                         if (minRange) {
                             if (minRange.node instanceof View || minRange.node instanceof ViewElement) {
                                 // oldName旧的节点存的值
@@ -1404,6 +1540,10 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     return;
                 }
 
+                // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
+                if (node instanceof View || node instanceof Process) {
+                    this.delete();
+                }
                 // 其余的都直接调用删除
                 // Structure 和 Interface是内部有delete方法
                 if (node instanceof Structure || node instanceof Interface) {
@@ -1434,30 +1574,6 @@ BaseNode.prototype.addParamsPrepare = async function addParamsPrepare() {
     }
 };
 
-/**
- * 页面的删除同步他的子页面要一起删除
- */
-BaseNode.prototype.viewPrepareDelete = async function viewPrepareDelete() {
-    try {
-        /**
-         * 查找这个页面是不是有依赖
-         */
-        const refsList = await naslServer._isHaveRef(this);
-        let viewPath = (this as FileNode).getEmbeddedFilePath();
-        viewPath = viewPath.slice(0, viewPath.length - 3);
-        const find = refsList.find((record) => !record.file.includes(viewPath));
-        // 如果有别的文件的依赖
-        if (find) {
-            // 就展示弹框
-            this.prepareDelete();
-        } else {
-            this.delete();
-        }
-    } catch (err) {
-        console.log(err);
-    }
-};
-
 /**
  * 除去rename场景下的更新
  * @param fileNode 文件级别的节点
@@ -1482,14 +1598,19 @@ async function handleChange(fileNode: BaseNode, targetNode: BaseNode, result: Re
     newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
     // 唤起建立连接弹框
     // 文件级别的建立连接采取提醒
-    if (fileNode === targetNode && action === 'create' && filesToCheck.size > 1) {
-        const confirmParms = {
-            actionType: 'createEstablishConnection',
-            node: fileNode,
-            icon: 'success',
-        };
-        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, () => {});
+        }
     }
+
     // console.log('filesToCheck', filesToCheck, filesToCheck.size);
     await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
 }
@@ -1546,8 +1667,9 @@ async function handleRename(fileNode: BaseNode, targetNode: BaseNode, result: Re
                 node: fileNode,
                 icon: 'success',
             };
-            invokeCommand('tsConfirm.open', confirmParms, () => { });
+            invokeCommand('tsConfirm.open', confirmParms, () => {});
         }
+        // console.log('filesToCheck', filesToCheck, filesToCheck.size);
     } else {
         // 查一下当前属性依赖的文件
         const { currentSource, fileNode } = naslServer.getCurrentSource(targetNode);
@@ -1572,7 +1694,67 @@ async function handleRename(fileNode: BaseNode, targetNode: BaseNode, result: Re
 
     // console.log('filesToCheck', filesToCheck, filesToCheck.size);
     await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-    // outputFiles.map((file) => file.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);
+                }
+            };
+
+            // 删除模块通知更新列表
+            if (action === 'delete') {
+                try {
+                    // 如果已经
+                    invokeCommand('module.delete', true);
+                } catch (err) {
+                    console.log('module.delete', '组件销毁了,不用唤起了');
+                }
+            }
+        }
+    }
 }
 
 async function receiveHandleChange($event: EventPayload) {
@@ -1582,7 +1764,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;
     }
 
@@ -1602,25 +1788,46 @@ 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.oldObject.name));
+            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(() => {
+            if (stackList.length) {
+                next();
+            }
+        });
+    }
+
+    // 如果有长度开始执行状态机
+    if (stackList.length) {
+        next();
+    }
 });
 
 naslServer.messager.options.context = naslServer;