@lcap/nasl 1.0.0-alpha.8 → 1.0.1

package/out/server/naslServer.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateDiagnosticMessage = exports.transformType = void 0;
 /// #if process.env.NODE_ENV
 // import Worker from '../../../ts-worker/dist/bundle.js';
 /// #else
@@ -12,9 +11,8 @@ exports.translateDiagnosticMessage = exports.transformType = void 0;
 const Messager_1 = __importDefault(require("../common/Messager"));
 const concepts_1 = require("../concepts");
 const translator_1 = require("../translator");
+const storage_1 = __importDefault(require("../service/storage"));
 const translator_2 = require("./translator");
-Object.defineProperty(exports, "transformType", { enumerable: true, get: function () { return translator_2.transformType; } });
-Object.defineProperty(exports, "translateDiagnosticMessage", { enumerable: true, get: function () { return translator_2.translateDiagnosticMessage; } });
 const common_1 = require("../common");
 const diagnostic_1 = __importDefault(require("../manager/diagnostic"));
 const createUiTs_1 = __importDefault(require("./createUiTs"));
@@ -22,6 +20,8 @@ const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
 const EmbeddedTSFileLineMap = {
     Entity: 3,
 };
+// 要Check的文件
+const filesToCheck = new Set();
 const worker = new Worker('/ts-worker.js');
 const messager = new Messager_1.default({
     protocol: 'ts-worker',
@@ -49,82 +49,130 @@ const naslServer = {
         return this.messager.requestCommand('start');
     },
     async createUiTs(allComponent) {
-        const { code, elementsLogic } = await (0, createUiTs_1.default)(allComponent);
+        const { code, elementsLogic, naslStdlibMap } = await (0, createUiTs_1.default)(allComponent);
         // 放入生產的uits文件
         await naslServer.addFile({
             file: 'nasl.ui.definition.ts',
             fileContent: code,
         });
+        Object.keys(naslStdlibMap).forEach(async (libFileName) => {
+            await naslServer.addFile({
+                file: '/' + libFileName,
+                fileContent: naslStdlibMap[libFileName],
+            });
+        });
         naslServer.elementsLogic = elementsLogic;
         // 全部文件加载完毕开始初始化
         await naslServer.getDiagnosticRecordsAndPushAll();
     },
     contentToFile(module, results) {
         module.structures.forEach((structure) => {
-            const result = structure.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            structure.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, structure);
+            try {
+                const result = structure.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                structure.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, structure);
+            }
+            catch (err) {
+                console.log(err);
+            }
         });
         module.entities.forEach((entity) => {
-            const result = entity.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            entity.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, entity);
+            try {
+                const result = entity.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                entity.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, entity);
+            }
+            catch (err) {
+                console.log(err);
+            }
         });
         module.interfaces.forEach((_interface) => {
-            const result = _interface.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            _interface.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, _interface);
+            try {
+                const result = _interface.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                _interface.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, _interface);
+            }
+            catch (err) {
+                console.log(err);
+            }
         });
         module.enums.forEach((_enum) => {
-            const result = _enum.toEmbeddedTSFile();
-            results.push(result);
-            // sourceMap都存在目录级别内容下，在页面层级下去找
-            _enum.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, _enum);
+            try {
+                const result = _enum.toEmbeddedTSFile();
+                results.push(result);
+                // sourceMap都存在目录级别内容下，在页面层级下去找
+                _enum.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, _enum);
+            }
+            catch (err) {
+                console.log(err);
+            }
         });
         module.logics.forEach((logic) => {
-            if (!(logic instanceof concepts_1.Logic))
-                return;
-            const result = logic.toEmbeddedTSFile();
-            results.push(result);
-            logic.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, logic);
+            try {
+                if (!(logic instanceof concepts_1.Logic))
+                    return;
+                const result = logic.toEmbeddedTSFile();
+                results.push(result);
+                logic.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, logic);
+            }
+            catch (err) {
+                console.log(err);
+            }
         });
         // view的生成
         naslServer.view2TSFile(module.views, results);
         module.processes.forEach((process) => {
-            const result = process.toEmbeddedTSFile();
-            results.push(result);
-            process.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, process);
+            try {
+                const result = process.toEmbeddedTSFile();
+                results.push(result);
+                process.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, process);
+            }
+            catch (err) {
+                console.log(err);
+            }
         });
         if (module instanceof concepts_1.App) {
             module.roles.forEach((role) => {
-                const result = role.toEmbeddedTSFile();
-                results.push(result);
-                // sourceMap都存在目录级别内容下，在页面层级下去找
-                role.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, role);
+                try {
+                    const result = role.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    role.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, role);
+                }
+                catch (err) {
+                    console.log(err);
+                }
             });
         }
     },
     view2TSFile(viewsChildren, results) {
-        // 子页面
-        viewsChildren.forEach((view) => {
-            const result = view.toEmbeddedTSFile();
-            results.push(result);
-            view.sourceMap = result.sourceMap;
-            this.file2NodeMap.set(result.filePath, view);
-            if (view.children.length) {
-                naslServer.view2TSFile(view.children, results);
-            }
-        });
+        // 如果有子页面
+        if (viewsChildren && viewsChildren.length) {
+            viewsChildren.forEach((view) => {
+                try {
+                    const result = view.toEmbeddedTSFile();
+                    results.push(result);
+                    view.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, view);
+                    if (view.children.length) {
+                        naslServer.view2TSFile(view.children, results);
+                    }
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            });
+        }
     },
     async openApp(app) {
         const results = [];
@@ -154,20 +202,16 @@ const naslServer = {
             callback();
         });
     },
-    async importModule(module) {
-        const results = [];
-        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, files);
+    async refreshApp(app) {
+        // 清除所有问题
+        diagnostic_1.default.clear();
+        await naslServer.deleteDirectoryFiles({ directoryName: '/embedded' });
+        // 清楚check count的数量
+        await this.messager.requestCommand('_clearTimeout');
+        // 重新加载app下内容
+        await naslServer.openApp(app);
+        // 重新check一遍所有内容
+        await naslServer.getDiagnosticRecordsAndPushAll();
     },
     /**
      * 初始化之前添加文件
@@ -182,14 +226,6 @@ const naslServer = {
     writeFiles(files) {
         return this.messager.requestCommand('writeFiles', files);
     },
-    /**
-     * 新增或修改文件
-     * @param {*} files
-     * @returns
-     */
-    outputFiles(files) {
-        return this.messager.requestCommand('outputFiles', files);
-    },
     /**
      * 新增、修改
      * 删除文件 文件用修改内容为空模拟，防止报错
@@ -198,15 +234,25 @@ const naslServer = {
     updateFiles(args) {
         return this.messager.requestCommand('updateFiles', args);
     },
+    /**
+     * 清除一个目录下的所有文件
+     */
+    deleteDirectoryFiles(args) {
+        return this.messager.requestCommand('deleteDirectoryFiles', args);
+    },
     _debugInFileStorage(node, openFiles) {
-        // let app = node;
-        // if (node.concept !== 'App') {
-        //     app = (node as any).rootNode || (node as any).app;
-        // }
-        // return Promise.all(openFiles.map(async (file) => {
-        //     const res = await axios.post('/api/App/debugEmbedded?id=' + app.id, file);
-        //     return res.data;
-        // }));
+        /// #if process.env.NODE_ENV === 'development'
+        let app = node;
+        if (node.concept !== 'App') {
+            app = node.rootNode || node.app;
+        }
+        return Promise.all(openFiles.map(async (file) => {
+            const res = await storage_1.default.post('/api/App/debugEmbedded?id=' + app.id, file);
+            return res.data;
+        })).catch((e) => {
+            console.error(e);
+        });
+        /// #endif
     },
     open() {
         return this.messager.requestCommand('open');
@@ -220,7 +266,7 @@ const naslServer = {
     async references(args) {
         return (await this.messager.requestCommand('references', args))?.response;
     },
-    getValueSelectCompletion(node, value) {
+    getValueSelectCompletion(node, value, noFilterList) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         // console.log(currentSource, fileNode);
         if (currentSource && fileNode) {
@@ -231,6 +277,7 @@ const naslServer = {
                     offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
                 },
                 value,
+                noFilterList,
             });
         }
         else {
@@ -247,7 +294,10 @@ const naslServer = {
         const types = reg.exec(displayString);
         // 取出提示的类型，组成是数组
         const typeList = types[1].split(' | ').map((item) => {
-            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;
@@ -264,8 +314,7 @@ const naslServer = {
         return typeList;
     },
     async getTypeQuickinfo(node) {
-        console.log(node);
-        if (node instanceof concepts_1.Identifier) {
+        if (node && node instanceof concepts_1.BaseNode) {
             const callFunction = node.parentNode.parentNode;
             /**
              * currentSource callFunction 的节点，要去到当前节点的位置
@@ -287,23 +336,51 @@ const naslServer = {
                     if (typeAnnotation) {
                         res.push(typeAnnotation);
                     }
-                    else if (type === 'unknown') {
+                    else if (type === 'unknown' || type === 'never') {
                         return null;
                     }
                 });
                 if (!res.length) {
-                    res = coreTypeList_1.primitiveTypeList;
+                    return [];
+                }
+                else {
+                    return [{ title: '基础类型', children: res }];
                 }
-                // 调整结构
-                const dataTypeList = [{ title: '基础类型', children: res }];
-                return dataTypeList;
             }
         }
+        else {
+            // 字符串 和 inter
+            return [{ title: '基础类型', children: [coreTypeList_1.primitiveTypeList[4]] }];
+        }
+    },
+    async getDataSchemaType(node) {
+        if (!(node instanceof concepts_1.ViewElement))
+            return;
+        const { currentSource, fileNode } = naslServer.getCurrentSource(node);
+        const quickInfo = await naslServer._getTypeQuickinfo({
+            file: fileNode.getEmbeddedFilePath(),
+            line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+            offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `__elements.`.length,
+        });
+        if (quickInfo.responseRequired) {
+            const displayString = quickInfo?.response?.displayString || '';
+            const flag = displayString.includes('<') && displayString.includes('>');
+            if (flag) {
+                let str = '';
+                const types = naslServer.getDisplayString2Type(displayString);
+                if (Array.isArray(types) && types.length) {
+                    const type = types[0];
+                    str = type === 'any' || type === 'unknown' || type === 'never' ? '' : type;
+                }
+                return str;
+            }
+        }
+        return '';
     },
     _getTypeQuickinfo(args) {
         return this.messager.requestCommand('quickInfo', args);
     },
-    getSelectNextCompletion(node) {
+    getSelectNextCompletion(node, noFilterList) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         // console.log(currentSource, fileNode);
         if (currentSource && fileNode) {
@@ -313,6 +390,7 @@ const naslServer = {
                     line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
                     offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
                 },
+                noFilterList,
             });
         }
         else {
@@ -344,7 +422,7 @@ const naslServer = {
             });
             // 语义诊断
             record.semanticDiagnostics = record.semanticDiagnostics
-                .map((diag) => this._resolveDiagnostic(diag, node.sourceMap))
+                .map((diag) => this._resolveDiagnostic(diag, node))
                 .filter((diag) => !!diag);
             // 建议诊断
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
@@ -367,8 +445,8 @@ const naslServer = {
         });
         return records;
     },
-    _resolveDiagnostic(diagnostic, sourceMap) {
-        const minRange = this._findMinRange(diagnostic, sourceMap);
+    _resolveDiagnostic(diagnostic, fileNode) {
+        const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
             severity: diagnostic.category === 'error' ? 'error' : 'warning',
             message: (0, translator_2.translateDiagnosticMessage)(diagnostic.text),
@@ -376,9 +454,8 @@ const naslServer = {
             originalDiagnostic: diagnostic,
         };
         if (minRange) {
-            // let message = this.translateDiagnosticMessage(diagnostic.text);
             // 节点的error要置为true
-            return naslServer._diagnosticSpecialTreatment(minRange, tsErrorDetail);
+            return (0, translator_2.naslNodeTranslateMessage)(minRange, tsErrorDetail);
         }
         else {
             // 没找到节点， 先把问题暴露出来
@@ -388,46 +465,9 @@ const naslServer = {
             };
         }
     },
-    /**
-     * 处理一些边界情况
-     * @param minRange
-     * @param tsErrorDetail 报错具体信息
-     * @returns
-     */
-    _diagnosticSpecialTreatment(minRange, tsErrorDetail) {
-        const text = tsErrorDetail.originalDiagnostic.text;
-        // 有一些节点报错信息不向外暴露,缺失一些原生标签等等的展示
-        if (minRange.node instanceof concepts_1.View || minRange.node instanceof concepts_1.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 concepts_1.BindEvent) {
-                return null;
-            }
-            // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 callLogic上,
-            // 但是只少一个的时候就会找到准确的Argument上 需要特殊处理, ui层就可以统一处理
-            if (minRange.node instanceof concepts_1.Argument) {
-                minRange.node = minRange.node.parentNode;
-            }
-        }
-        minRange.node.tsErrorDetail = tsErrorDetail;
-        return {
-            id: minRange.node.id,
-            node: minRange.node,
-            ...tsErrorDetail,
-        };
-    },
-    _findMinRange(diagnostic, sourceMap) {
+    _findMinRange(diagnostic, fileNode) {
         let minRange;
+        const sourceMap = fileNode.sourceMap;
         for (const [node, item] of sourceMap.entries()) {
             /**
              * 当前内容的开始行 <= 诊断开始的行 &&
@@ -457,49 +497,16 @@ const naslServer = {
             }
         }
         if (!minRange) {
+            if (fileNode instanceof concepts_1.View) {
+                return { node: fileNode, item: sourceMap.get(fileNode) };
+            }
             console.log(diagnostic, 'diagnostic');
             console.log(sourceMap, 'sourceMap');
             console.log(minRange, '需要特殊看下，为什么没找到内容-------------');
         }
         return minRange;
     },
-    // 查找引用
-    async findReferences(node) {
-        console.log(node);
-        const refsList = await naslServer._isHaveRef(node, true);
-        console.log(refsList, 'refsList');
-        // refsList = refsList.filter((item) =>
-        // // 不是创建者
-        //     item.isDefinition !== true);
-        let result = {};
-        const resMap = {};
-        try {
-            refsList.forEach((record) => {
-                const fileNode = this.file2NodeMap.get(record.file);
-                if (!fileNode)
-                    return;
-                const minRange = this._findMinRange(record, fileNode.sourceMap);
-                // 过滤一把不需要改的信息
-                if (minRange) {
-                    // 如果查找引用查到自己里面的引用不展示
-                    // 因为view生成的特殊性
-                    if (minRange.node === node || (minRange.node instanceof concepts_1.View && node instanceof concepts_1.View)) {
-                        return;
-                    }
-                    // 拼装树
-                    naslServer._getTreeMap(minRange, fileNode, resMap);
-                }
-            });
-            console.log(resMap, 'resMap');
-            result = naslServer.handleTreeMap(resMap);
-        }
-        catch (err) {
-            console.log(err);
-        }
-        console.log(result);
-        return result;
-    },
-    async _isHaveRef(node, isFind = false) {
+    async _isHaveRef(node) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
         let refsList = [];
         /**
@@ -513,13 +520,34 @@ const naslServer = {
             });
             refsList = [...newRefs.refs];
         }
+        else {
+            if (node instanceof concepts_1.Module) {
+                const lists = node.logics || node.structures || node.enums;
+                const moduleName = fileNode.getEmbeddedFilePath();
+                if (lists.length) {
+                    const item = lists[0];
+                    const { fileNode } = naslServer.getCurrentSource(item);
+                    const newRefs = await naslServer.references({
+                        file: fileNode.getEmbeddedFilePath(),
+                        line: 1,
+                        offset: 22, //固定的位置，module的位置信息
+                    });
+                    refsList = newRefs.refs.filter((item) => !item.file.startsWith(moduleName));
+                    // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
+                    refsList.unshift(newRefs.refs[0]);
+                }
+            }
+        }
         // 如果是entity就需要在单独，查一边来修改名字
         if (node instanceof concepts_1.Entity) {
             // 过滤一把不需要改的信息
-            refsList = refsList.filter((item) => 
+            refsList = refsList.filter((item) => fileNode.getEmbeddedFilePath() !== item.file || item.isDefinition === true);
             // 不再当前文件里
             // 或者在当前列表但是位置小于entity的结束位置
-            fileNode.getEmbeddedFilePath() !== item.file);
+        }
+        if (node instanceof concepts_1.Return) {
+            // 过滤一下最后出去的值
+            refsList = refsList.filter((item) => !item.lineText.includes('return '));
         }
         // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
         if (node instanceof concepts_1.Param && node.parentNode instanceof concepts_1.Logic) {
@@ -532,8 +560,8 @@ const naslServer = {
             });
             refsList = [...refsList, ...parentRefs.refs];
         }
-        // 如果是参数, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来
-        if (node instanceof concepts_1.Param && node.parentNode instanceof concepts_1.View && isFind) {
+        // 如果是参数修改, 就需要把logic的引用 都查找出来就需要把他的父级的引用全部查找出来d
+        if (node instanceof concepts_1.Param && node.parentNode instanceof concepts_1.View) {
             const viewNode = node.parentNode;
             const { currentSource } = naslServer.getCurrentSource(viewNode);
             const code = currentSource.code;
@@ -547,45 +575,53 @@ const naslServer = {
             refsList = [...refsList, ...filterViewRefs];
         }
         /**
+         * 暂时不要了， 因为生成的结构发生了变化
          * view 因为不是嵌套的，所以不能用最前面的变量查找，所以要单独处理一下
          * 找到第一个 { 之前的变量 进行修改
          * 如果是VIew的查找，比较特殊，他查的是当前抛出的 {} 大括号前的
          * 最后一个，因为生成的规则不一样
          */
-        if (node instanceof concepts_1.View) {
-            const code = currentSource.code;
-            const viewIndex = code.indexOf(' {');
-            const viewRefs = await naslServer.references({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + viewIndex),
-            });
-            refsList = [...viewRefs.refs];
-        }
+        // if (node instanceof View) {
+        //     const code = currentSource.code;
+        //     const viewIndex = code.indexOf(' {');
+        //     const viewRefs = await naslServer.references({
+        //         file: (fileNode as FileNode).getEmbeddedFilePath(),
+        //         line: lsp2tspNumber(currentSource.range.start.line),
+        //         offset: lsp2tspNumber(currentSource.range.start.character + viewIndex),
+        //     });
+        //     refsList = [...viewRefs.refs];
+        // }
         /**
          * elements 需要查的是__elements.后面的那个内容,过滤两个为了生成内容的节点
          */
         if (node instanceof concepts_1.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.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.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];
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__elements.';
+                const prefixIndex = code.indexOf(prefix) !== -1 ? code.indexOf(prefix) : 0;
+                const methodsNameIndex = prefixIndex + prefix.length;
+                const methods = await naslServer.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + methodsNameIndex),
+                });
+                const methodRefs = [];
+                methods.refs.forEach((item) => {
+                    // 定义里的格式，在删除的时候留下来占位
+                    // 重命名的时候会过滤
+                    // 这里只过滤 __elements.button = new nasl.ui.Button<any>这种格式
+                    // if (item.lineText.includes('__elements.') && item.lineText.includes('new nasl.ui.'))
+                    //     return false;
+                    // 处理声明组件名可能重复的问题， 查找引用不提示
+                    const find = methodRefs.find((findItem) => item.lineText === findItem.lineText && item.lineText.includes(': nasl.ui.'));
+                    if (!find) {
+                        methodRefs.push(item);
+                    }
+                });
+                refsList = [...methodRefs];
+            }
         }
+        console.log(refsList, 'refsList');
         return refsList;
     },
     /**
@@ -603,13 +639,17 @@ const naslServer = {
             const fileNode = this.file2NodeMap.get(record.file);
             if (!fileNode)
                 return null;
-            const minRange = this._findMinRange(record, fileNode.sourceMap);
+            const minRange = this._findMinRange(record, fileNode);
             if (minRange) {
                 // 如果节点是TypeAnnotation类型,
                 // 很复杂，可能是多级嵌套结构
                 // 不一定只修改typeName
                 if (minRange.node instanceof concepts_1.TypeAnnotation) {
                     // console.log(record);
+                    // 如果是fake的逻辑，内部的重命名都不需要修改
+                    // if ((minRange.node?.parentNode as any).logic && (minRange.node?.parentNode as any).logic?.fake) {
+                    //     return null;
+                    // }
                     minRange.setTypeMethods = 'setTypeName';
                 }
                 // 如果节点是logic修改引发calllogic修改
@@ -617,11 +657,11 @@ const naslServer = {
                     minRange.setTypeMethods = 'setCalleeName';
                 }
                 if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.ViewElement) {
-                    minRange.setTypeMethods = 'setCalleeName';
+                    minRange.setTypeMethods = 'setCalleeNamespace';
                     minRange.newValue = 'elements.' + newValue + '.logics';
                 }
                 // 如果节点是实体修改引发calllogic修改
-                if (minRange.node instanceof concepts_1.CallLogic && (node instanceof concepts_1.Entity || node instanceof concepts_1.View)) {
+                if (minRange.node instanceof concepts_1.CallLogic && (node instanceof concepts_1.Entity || node instanceof concepts_1.View || node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
                     // 匹配到的内容，当前这一行的内容；
                     // 因为要用下面的点位信息
                     /**
@@ -643,27 +683,29 @@ const naslServer = {
                     const end = record.end.offset - index - 1;
                     // 新的完整的value
                     let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
-                    newTsNameSpace = newTsNameSpace.replace(/.$/g, '.');
+                    newTsNameSpace = newTsNameSpace.replace(/.\$/g, '.');
                     minRange.setTypeMethods = 'setCalleeNamespace';
                     minRange.newValue = newTsNameSpace;
                 }
                 // 如果参数修改影响了 callLogic
                 if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
+                    return null;
                     // 逻辑第几个位置发生修改，对应的calllogic对应位置的内容要进行修改
-                    const nodeArguments = minRange.node.arguments;
-                    const LogicNode = node.parentNode;
-                    const paramIndex = LogicNode.params.findIndex((param) => param === node);
-                    console.log(node, nodeArguments);
-                    if (paramIndex !== -1) {
-                        minRange.setTypeMethods = 'setArgumentName';
-                        minRange.newValue = {
-                            argument: nodeArguments[paramIndex],
-                            newKeyword: newValue,
-                        };
-                    }
-                    else {
-                        return null;
-                    }
+                    // minRange.setTypeMethods = 'setArgumentName';
+                    // const nodeArguments = minRange.node.arguments;
+                    // minRange.newValue = [...nodeArguments];
+                    // const LogicNode = node.parentNode;
+                    // const paramIndex = (LogicNode as Logic).params.findIndex((param) => param === node);
+                    // console.log(node, nodeArguments);
+                    // if (paramIndex !== -1) {
+                    //     minRange.setTypeMethods = 'setArgumentName';
+                    //     minRange.newValue = {
+                    //         argument: nodeArguments[paramIndex],
+                    //         newKeyword: newValue,
+                    //     };
+                    // } else {
+                    //     return null;
+                    // }
                 }
                 // 如果节点是Identifier表达式
                 if (minRange.node instanceof concepts_1.Identifier) {
@@ -685,6 +727,11 @@ const naslServer = {
                         minRange.newValue = newTextValue;
                     }
                 }
+                // 如果是枚举修改，枚举的值刚好在Identifier 中选了 就修改值
+                if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Enum) {
+                    minRange.newValue = newValue;
+                    minRange.setTypeMethods = 'setName';
+                }
                 // 如果修改逻辑，改到了Identifier表达式，只能说明是在属性里有使用了
                 if (minRange.node instanceof concepts_1.Identifier && node instanceof concepts_1.Logic) {
                     minRange.newValue = newValue;
@@ -692,19 +739,27 @@ const naslServer = {
                 }
                 // 如果节点是MemberExpression表达式
                 if (minRange.node instanceof concepts_1.MemberExpression) {
-                    // 匹配到的内容，当前这一行的内容；
-                    // 因为要用下面的点位信息
-                    const a = record.lineText;
-                    // 之前的内容
-                    const oldValue = minRange.node.getValue();
-                    const index = a.indexOf(oldValue);
-                    const start = record.start.offset - index - 1;
-                    const end = record.end.offset - index - 1;
-                    const newTextValue = oldValue.substring(0, start) + newValue + oldValue.substring(end, oldValue.length);
-                    // MemberExpression可能改的是多层中的某一个
-                    // 倒序， 对比看是哪里发生了修改
-                    // 比较特殊就把新匹配到的值返回内部自己看要改那个地方的值
-                    minRange.newValue = newTextValue;
+                    // 枚举key的特殊性，因为它不是原来的key+value形式的
+                    // 是加了中括号啥的，所以直接赋值新值
+                    if (node instanceof concepts_1.EnumItem) {
+                        const newTextValue = node.parentNode.name + '.' + newValue;
+                        minRange.newValue = newTextValue;
+                    }
+                    else {
+                        // 匹配到的内容，当前这一行的内容；
+                        // 因为要用下面的点位信息
+                        const a = record.lineText;
+                        // 之前的内容
+                        const oldValue = minRange.node.getValue();
+                        const index = a.indexOf(oldValue);
+                        const start = record.start.offset - index - 1;
+                        const end = record.end.offset - index - 1;
+                        const newTextValue = oldValue.substring(0, start) + newValue + oldValue.substring(end, oldValue.length);
+                        // MemberExpression可能改的是多层中的某一个
+                        // 倒序， 对比看是哪里发生了修改
+                        // 比较特殊就把新匹配到的值返回内部自己看要改那个地方的值
+                        minRange.newValue = newTextValue;
+                    }
                 }
                 // 如果是修改实体，引发节点依赖实体发生改变的
                 if (minRange.node instanceof concepts_1.EntityProperty && node instanceof concepts_1.Entity) {
@@ -763,7 +818,13 @@ const naslServer = {
                 // 如果是view也需要加前缀
                 // logic 和 views名称修改 可能会触发bindEvent修改
                 if (minRange.node instanceof concepts_1.BindEvent) {
-                    /**
+                    // 页面逻辑直接赋值就可以, 因为是相对路径
+                    if ((node instanceof concepts_1.ViewElement)) {
+                        minRange.setTypeMethods = 'setCalleeNamespace';
+                        minRange.newValue = 'elements.' + newValue + '.logics';
+                    }
+                    else {
+                        /**
                      * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
                      * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
                      * 但是505 要改名为 666 ，要存的是666
@@ -772,26 +833,44 @@ const naslServer = {
                      * 2.在匹配到的内容中取转后的namespace的位置
                      * 3.然后把namespace中的 $替换成 ''
                      */
-                    const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
-                    const tsName = minRange.node.tsName;
-                    const oldValue = tsCalleeNamespace + '.' + tsName;
-                    // 先看下标位置
-                    const lineText = record.lineText;
-                    const index = lineText.indexOf(oldValue);
-                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
-                    const start = record.start.offset - index - 1;
-                    const end = record.end.offset - index - 1;
-                    // 新的完整的value
-                    if (start > tsCalleeNamespace.length) {
-                        minRange.setTypeMethods = 'setCalleeName';
-                        minRange.newValue = newValue;
+                        const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                        const oldValue = tsCalleeNamespace;
+                        // 先看下标位置
+                        const lineText = record.lineText;
+                        const index = lineText.indexOf(oldValue);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        const start = record.start.offset - index - 1;
+                        const end = record.end.offset - index - 1;
+                        // 新的完整的value
+                        if (start > tsCalleeNamespace.length) {
+                            minRange.setTypeMethods = 'setCalleeName';
+                            minRange.newValue = newValue;
+                        }
+                        else {
+                            // 新的完整的value
+                            let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                            minRange.setTypeMethods = 'setCalleeNamespace';
+                            newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                            minRange.newValue = newTsNameSpace;
+                        }
+                    }
+                }
+                if (minRange.node instanceof concepts_1.Destination && node instanceof concepts_1.Param) {
+                    // 因为view是key value 绑定所以需要重新赋值
+                    if (node.parentNode instanceof concepts_1.View) {
+                        const nodeArguments = minRange.node.arguments;
+                        const findArgument = nodeArguments.find((item) => node.name === item.keyword);
+                        if (findArgument) {
+                            minRange.setTypeMethods = 'setArgumentsKeyWord';
+                            minRange.newValue = {
+                                findArgument,
+                                newKeyword: newValue,
+                            };
+                        }
                     }
                     else {
-                        // 新的完整的value
-                        let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
-                        minRange.setTypeMethods = 'setCalleeNamespace';
-                        newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
-                        minRange.newValue = newTsNameSpace;
+                        // 如果是修改param查找到Destination就不操作
+                        return null;
                     }
                 }
                 if (minRange.node instanceof concepts_1.Interface && node instanceof concepts_1.Logic) {
@@ -807,13 +886,33 @@ const naslServer = {
                     const newBindRoles = str.split(',');
                     minRange.newValue = newBindRoles;
                 }
+                // 修改枚举值找到了EntityProperty就说明给了默认值
+                if (minRange.node instanceof concepts_1.EntityProperty && node instanceof concepts_1.EnumItem) {
+                    minRange.setTypeMethods = 'setDefaultValue';
+                }
+                if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.Entity) {
+                    minRange.setTypeMethods = 'setEntityAsName';
+                }
+                if ((minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) && node instanceof concepts_1.Entity) {
+                    minRange.setTypeMethods = 'setEntityName';
+                }
+                if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.EntityProperty) {
+                    minRange.setTypeMethods = 'setPropertyName';
+                }
+                // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
+                if ((minRange.node instanceof concepts_1.Param || minRange.node instanceof concepts_1.Variable || minRange.node instanceof concepts_1.Return) && (node instanceof concepts_1.Entity || node instanceof concepts_1.Enum || node instanceof concepts_1.Structure)) {
+                    return null;
+                }
+                if (minRange.node instanceof concepts_1.Destination && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
+                    return null;
+                }
                 // 枚举修改枚举名，比较特殊
                 if (minRange.node instanceof concepts_1.EnumItem && node instanceof concepts_1.Enum) {
                     // 什么都不做，用来跳过修改
                     return null;
                 }
-                // 如果是修改param查找到logic就不操作
-                if (minRange.node instanceof concepts_1.Logic && node instanceof concepts_1.Param) {
+                // params修改 查找bindevent不需要修改
+                if (minRange.node instanceof concepts_1.BindEvent && node instanceof concepts_1.Param) {
                     return null;
                 }
                 // 如果是子页面修改
@@ -821,8 +920,39 @@ const naslServer = {
                 if (minRange.node instanceof concepts_1.View && node instanceof concepts_1.View && minRange.node !== node) {
                     return null;
                 }
+                /**
+                 * 屏蔽组件生成内容块中的变量或者逻辑，出现在表格选择中。在bindAttr中还会有，所以过滤一把
+                 */
+                if ((minRange.node instanceof concepts_1.Identifier || minRange.node instanceof concepts_1.MemberExpression) && node instanceof concepts_1.Param && minRange.node.parentNode instanceof concepts_1.BindAttribute) {
+                    return null;
+                }
+                // 修改element引发view改名
+                if (node instanceof concepts_1.ViewElement && minRange.node instanceof concepts_1.View) {
+                    return null;
+                }
+                // params修改 查找View不需要修改
                 // 逻辑改名，触发了在定义里面的，element定义，的值，直接掠过
-                if (minRange.node instanceof concepts_1.View && node instanceof concepts_1.Logic) {
+                if (minRange.node instanceof concepts_1.View && (node instanceof concepts_1.Logic || node instanceof concepts_1.Param)) {
+                    /**
+                     * 这里过滤一下，一些查找引用，重复的内容，直接屏蔽掉，防止操作重复
+                     * 因为在生成的时候 ，可能弄了一些副作用的引用
+                    */
+                    // 本来是想在上面过滤一把的先放到这里匹配这两个的时候 就会找到
+                    // refsList = refsList.filter((item) => {
+                    //     屏蔽组件查找查到定义这里，也过滤一下
+                    //     if (item.lineText.includes(': nasl.ui.'))
+                    //         return false;
+                    //     return true;
+                    // });
+                    return null;
+                }
+                /**
+                 * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
+                 * 流程改名不触发Logic改名
+                 * 如果是修改param查找到logic就不操作
+                 * 除非想在内部修改别的内容所以暂时屏蔽掉
+                */
+                if (minRange.node instanceof concepts_1.Logic && node !== minRange.node) {
                     return null;
                 }
             }
@@ -839,40 +969,83 @@ const naslServer = {
     },
     _addParamsPrepare(node, refsList) {
         const App = node.rootNode;
-        const LogicNode = node.parentNode;
+        const parantNode = node.parentNode;
         // 收集修改
         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 = this._findMinRange(record, fileNode.sourceMap);
+            const minRange = this._findMinRange(record, fileNode);
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
                 if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
-                    minRange.node.setCalleeArgName(LogicNode);
+                    minRange.node.setCalleeArgName((parantNode));
+                }
+                // 如果节点参数增加页面也要更新
+                if (minRange.node instanceof concepts_1.Destination && node instanceof concepts_1.Param) {
+                    minRange.node.setViewArgument((parantNode));
                 }
             }
         });
         // 结束修改 ，批量操作
         App.emit('collect:end');
     },
+    // 查找引用
+    async findReferences(node) {
+        let refsList = await naslServer._isHaveRef(node);
+        // 如果查找引用查到自己里面的引用不展示
+        refsList = refsList.filter((item) => {
+            // 自己引用自己的过滤掉
+            // 删除的时候过滤一把组件删除提示
+            // 展示组件自己屏蔽掉
+            return !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.'));
+        });
+        // 最后返回的结果
+        let result = new Map();
+        // 树的构造，key： 一个file的node， 值是 [[logic, params],[logic, returns]]
+        const resMap = new Map();
+        // 普通节点和要输出的节点做一个映射，为了引用地址一样
+        const nodeMap = new Map();
+        try {
+            refsList.forEach((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return;
+                const minRange = this._findMinRange(record, fileNode);
+                // 过滤一把不需要改的信息
+                if (minRange) {
+                    // 拼装树
+                    naslServer._getTreeMap(minRange, fileNode, resMap, nodeMap);
+                }
+            });
+            console.log(resMap, 'resMap');
+            if (resMap.size > 0) {
+                result = naslServer.handleTreeMap(resMap);
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+        console.log(result);
+        return result;
+    },
     // 获取节点的上层渲染
-    _getTreeMap(minRange, fileNode, resMap) {
+    _getTreeMap(minRange, fileNode, resMap, nodeMap) {
         const minRangeNode = minRange.node;
         let parantNode = minRangeNode;
         // 顺序队列
         const queue = [];
         // 先插入自己,如果没有在往上找,
         // 一直到file节点的父级
-        while (parantNode !== fileNode.parentNode) {
+        while (!(parantNode instanceof concepts_1.App)) {
             // 找到上一级 在map对象中构造出他的子集
             const currentNode = parantNode;
             parantNode = parantNode.parentNode;
@@ -883,7 +1056,9 @@ const naslServer = {
             // 排除一些不放入集合的节点
             let isNeedPush = true;
             // 如果不是ViewElement 或者 Assignment ， 或者如果是的话， 排除l-root
-            if (currentNode instanceof concepts_1.ViewElement && currentNode.tag !== 'l-root')
+            if (currentNode instanceof concepts_1.ViewElement && currentNode.tag === 'l-root')
+                isNeedPush = false;
+            else if (currentNode instanceof concepts_1.Argument)
                 isNeedPush = false;
             else if (currentNode instanceof concepts_1.Assignment)
                 isNeedPush = false;
@@ -893,13 +1068,11 @@ const naslServer = {
                 isNeedPush = false;
             else if (currentNode instanceof concepts_1.QueryFromExpression)
                 isNeedPush = false;
-            else if (currentNode.concept === parantNode.concept)
-                isNeedPush = false;
+            // 需要放到数组中
             if (isNeedPush) {
                 // 名称
-                let name = currentNode.name || currentNode.concept;
                 // 赋值图标
-                let icon = currentNode.concept && currentNode.concept.replace(/^./, (m) => m.toLowerCase());
+                let icon = '';
                 if (currentNode instanceof concepts_1.ViewElement)
                     icon = 'element';
                 else if (currentNode instanceof concepts_1.BindAttribute)
@@ -908,55 +1081,34 @@ const naslServer = {
                     icon = 'logicNode';
                 else if (currentNode instanceof concepts_1.CallLogic) {
                     icon = 'interface';
-                    name = '调用逻辑';
                 }
-                queue.unshift({ name, node: currentNode, expanded: true, icon });
+                // 相同节点使用一个引用
+                if (nodeMap.get(currentNode)) {
+                    queue.unshift(nodeMap.get(currentNode));
+                }
+                else {
+                    const quoteNode = { node: currentNode, expanded: true, icon };
+                    nodeMap.set(currentNode, quoteNode);
+                    queue.unshift(quoteNode);
+                }
             }
         }
-        const key = fileNode.name;
         // 一个logic 或者 view可能会有多个顺序队列
-        if (resMap[key]) {
-            // // 是否展示两个内容全等，但是两个queue的node可能不一样，但是只需要展示一个
-            // let equalFlag = false;
-            // const queues = resMap[key].queue;
-            // queues.forEach((item) => {
-            //     if (item.length === queue.length) {
-            //         let equalIndex = 0;
-            //         item.forEach((queueItem, index) => {
-            //             if (queueItem.name === queue[index].name)
-            //                 equalIndex++;
-            //         });
-            //         console.log(equalIndex)
-            //         if (equalIndex === queue.length)
-            //             equalFlag = true;
-            //     }
-            // });
-            // // 如果有值就return
-            // if (equalFlag)
-            //     return;
-            queue.length && resMap[key].queue.push(queue);
+        if (resMap.get(fileNode)) {
+            // 是否展示两个内容全等，但是两个queue的node可能不一样，但是只需要展示一个
+            resMap.get(fileNode).push(queue);
         }
         else {
-            resMap[key] = {
-                queue: queue.length ? [queue] : [],
-                concept: fileNode.concept,
-                name: fileNode.name,
-                node: fileNode,
-            };
+            resMap.set(fileNode, [queue]);
         }
     },
-    handleTreeMap(tree) {
-        const treeNodeMap = {};
-        for (const [sub, val] of Object.entries(tree)) {
+    handleTreeMap(resMap) {
+        const treeNodeMap = new Map();
+        resMap.forEach((value, fileNode) => {
             // 循环处理tree的queue
-            const treeObj = naslServer.handleTreeQueue(val.queue);
-            if (treeNodeMap[val.concept]) {
-                treeNodeMap[val.concept].push(treeObj);
-            }
-            else {
-                treeNodeMap[val.concept] = [treeObj];
-            }
-        }
+            const treeObj = naslServer.handleTreeQueue(value);
+            treeNodeMap.set(fileNode, treeObj);
+        });
         return treeNodeMap;
     },
     /**
@@ -965,30 +1117,27 @@ const naslServer = {
      * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
      * @returns 最后要使用到的节点和对应的子集
      */
-    handleTreeQueue(arr) {
-        const map = {};
+    handleTreeQueue(queueLists) {
+        const map = new Map();
         let root = null;
-        if (!arr.length)
+        if (!queueLists.length)
             return;
-        for (const sub of arr) {
+        for (const queueList of queueLists) {
             let preNode = null;
-            for (const item of sub) {
-                const node = item;
-                const key = item.name;
-                if (!map[key]) {
-                    map[key] = [];
+            for (const queueItem of queueList) {
+                if (!map.get(queueItem)) {
+                    map.set(queueItem, []);
                 }
                 if (preNode) {
-                    const preKey = preNode.name;
-                    const find = map[preKey].find((item) => node.name === item.name);
+                    const find = map.get(preNode).find((item) => item === queueItem);
                     if (!find) {
-                        map[preKey].push(node);
+                        map.get(preNode).push(queueItem);
                     }
                 }
                 else {
-                    root = node;
+                    root = queueItem;
                 }
-                preNode = node;
+                preNode = queueItem;
             }
         }
         const children = naslServer._recursionCreateResult(root, map);
@@ -1001,24 +1150,24 @@ const naslServer = {
      * @returns 当前节点，最后输出所有节点
      */
     _recursionCreateResult(root, map) {
-        const node = root;
-        const rootKey = root.name;
-        const children = map[rootKey].map((item) => naslServer._recursionCreateResult(item, map));
+        const children = map.get(root).map((item) => naslServer._recursionCreateResult(item, map));
         if (children && children.length) {
-            node.children = children;
+            root.children = children;
         }
-        return node;
+        return root;
     },
     /**
      *  获取
      *  当前this上下文 的Source 和 父级文件级别的节点
      */
     getCurrentSource(node) {
+        if (node instanceof concepts_1.App || node instanceof concepts_1.Theme)
+            return { fileNode: null };
         let sourceMap = node.sourceMap;
         let fileNode = node;
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
         // 如果 节点找到 app 或者module 停止
-        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof concepts_1.App) && !(fileNode.parentNode instanceof concepts_1.Module)) {
+        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof concepts_1.App) && !(fileNode.parentNode instanceof concepts_1.Module) && !(fileNode instanceof concepts_1.View)) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -1041,7 +1190,6 @@ const naslServer = {
     // 获取element方法的可选值
     getFieldKeySelectCompletion(node, fieldKey) {
         const { currentSource, fileNode } = naslServer.getCurrentSource(node);
-        console.log(currentSource);
         if (currentSource && fileNode) {
             return naslServer._getFieldKeySelectCompletion({
                 file: fileNode.getEmbeddedFilePath(),
@@ -1090,11 +1238,51 @@ async function handleDelete(fileNode, targetNode, result) {
     }
     // 更新文件之后
     await naslServer.updateFiles({ outputFiles });
-    const filesToCheck = new Set();
     newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-    console.log('filesToCheck', filesToCheck, filesToCheck.size);
-    await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
 }
+concepts_1.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];
+            if (this.concept === 'Logic') {
+                if (logic instanceof concepts_1.Logic)
+                    if (logic.calleewholeKey === this.calleewholeKey) {
+                        targetNode = logic;
+                        break;
+                    }
+            }
+            else {
+                if (logic instanceof concepts_1.Logic)
+                    if (logic.calleewholeKey === this.parentNode.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];
+            if (logic.getNamespace && logic.getNamespace() === this.getNamespace()) {
+                targetNode = logic;
+                break;
+            }
+        }
+    }
+    try {
+        return naslServer.findReferences(targetNode);
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
 // 查找引用
 concepts_1.BaseNode.prototype.findUsage = function findUsage() {
     try {
@@ -1151,6 +1339,7 @@ concepts_1.BaseNode.prototype.changeName = async function changeName(newValue, u
             const confirmParms = {
                 actionType: 'rename',
                 node: this,
+                newValue,
             };
             /**
              * nasl和vue的通信，回退，要触发vue的watch。
@@ -1158,11 +1347,20 @@ concepts_1.BaseNode.prototype.changeName = async function changeName(newValue, u
              * 先修改之
              */
             const closeCallBack = () => {
-                const oldValue = this.name;
-                this.name = oldValue + ' ';
-                setTimeout(() => {
-                    this.name = oldValue;
-                }, 0);
+                if (this.concept === 'EnumItem') {
+                    const oldValue = this.value;
+                    this.value = oldValue + ' ';
+                    setTimeout(() => {
+                        this.value = oldValue;
+                    }, 0);
+                }
+                else {
+                    const oldValue = this.name;
+                    this.name = oldValue + ' ';
+                    setTimeout(() => {
+                        this.name = oldValue;
+                    }, 0);
+                }
             };
             updateAll ? callback(true) : (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback, closeCallBack);
             return;
@@ -1181,15 +1379,38 @@ concepts_1.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 concepts_1.Param) {
+            const methodRefs = [];
+            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,
             node,
+            icon: 'warning',
         };
         let callback = null;
         if (refsList.length <= 1) {
+            // 页面组件直接删除然后return
+            if (node instanceof concepts_1.ViewElement) {
+                this.delete();
+                return;
+            }
             callback = () => {
                 // Structure 和 Interface是内部有delete方法
                 if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
@@ -1204,12 +1425,26 @@ concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete() {
             // 如果有依赖就有一个查找引用提示
             confirmParms.tipFlag = true;
             const node = this;
+            // 删除页面或者流程
+            if (node instanceof concepts_1.View || node instanceof concepts_1.Process) {
+                /**
+                 * 查找这个页面是不是有依赖
+                 */
+                let viewPath = this.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 concepts_1.Param) {
                     const App = this.rootNode;
-                    const logicNode = this.parentNode;
+                    const parentNode = this.parentNode;
                     // 收集修改
                     App.emit('collect:start', {
                         actionMsg: '删除参数',
@@ -1219,10 +1454,13 @@ concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete() {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
                         if (!fileNode)
                             return null;
-                        const minRange = naslServer._findMinRange(record, fileNode.sourceMap);
+                        const minRange = naslServer._findMinRange(record, fileNode);
                         if (minRange) {
                             if (minRange.node instanceof concepts_1.CallLogic) {
-                                minRange.node.setCalleeArgName(logicNode);
+                                minRange.node.setCalleeArgName(parentNode);
+                            }
+                            if (minRange.node instanceof concepts_1.Destination) {
+                                minRange.node.setViewArgument(parentNode);
                             }
                         }
                     });
@@ -1242,7 +1480,7 @@ concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete() {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
                         if (!fileNode)
                             return null;
-                        const minRange = naslServer._findMinRange(record, fileNode.sourceMap);
+                        const minRange = naslServer._findMinRange(record, fileNode);
                         if (minRange) {
                             if (minRange.node instanceof concepts_1.Interface) {
                                 minRange.node.delete();
@@ -1251,6 +1489,7 @@ concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     });
                     // 结束修改 ，批量操作
                     App.emit('collect:end');
+                    return;
                 }
                 // 删除权限节点
                 if (node instanceof concepts_1.Role) {
@@ -1264,7 +1503,7 @@ concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete() {
                         const fileNode = naslServer.file2NodeMap.get(record.file);
                         if (!fileNode)
                             return null;
-                        const minRange = naslServer._findMinRange(record, fileNode.sourceMap);
+                        const minRange = naslServer._findMinRange(record, fileNode);
                         if (minRange) {
                             if (minRange.node instanceof concepts_1.View || minRange.node instanceof concepts_1.ViewElement) {
                                 // oldName旧的节点存的值
@@ -1280,6 +1519,10 @@ concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete() {
                     App.emit('collect:end');
                     return;
                 }
+                // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
+                if (node instanceof concepts_1.View || node instanceof concepts_1.Process) {
+                    this.delete();
+                }
                 // 其余的都直接调用删除
                 // Structure 和 Interface是内部有delete方法
                 if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
@@ -1328,18 +1571,21 @@ async function handleChange(fileNode, targetNode, result, action) {
         line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
         offset: 6,
     });
-    const filesToCheck = new Set();
     newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
     // 唤起建立连接弹框
     // 文件级别的建立连接采取提醒
-    if (fileNode === targetNode && action === 'create' && filesToCheck.size > 1) {
-        const confirmParms = {
-            actionType: 'createEstablishConnection',
-            node: fileNode,
-        };
-        (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => { });
+    if (action === 'create' && targetNode.__init) {
+        // 清除临时状态, 完成本次创建
+        delete targetNode.__init;
+        if (fileNode === targetNode && filesToCheck.size > 1) {
+            const confirmParms = {
+                actionType: 'createEstablishConnection',
+                node: fileNode,
+                icon: 'success',
+            };
+            (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => { });
+        }
     }
-    await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
 }
 /**
  * 重命名的更新
@@ -1352,7 +1598,6 @@ async function handleChange(fileNode, targetNode, result, action) {
 async function handleRename(fileNode, targetNode, result, oldFilePath) {
     // rename 场景
     const outputFiles = [{ file: result.filePath, fileContent: result.code }];
-    const filesToCheck = new Set();
     // 如果是要修改顶级文件名
     // file节点和当前改得是同一节点
     if (fileNode === targetNode) {
@@ -1383,35 +1628,101 @@ async function handleRename(fileNode, targetNode, result, oldFilePath) {
         });
         // 文件级别重命名，有依赖才唤起弹框
         // 唤起重命名，提示有连接弹框
-        if (newRefFileList.size > 1) {
-            const confirmParms = {
-                actionType: 'renameEstablishConnection',
-                node: fileNode,
-            };
-            (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, () => { });
-        }
+        // 重命名建立连接先不展示弹框了
+        // if (newRefFileList.size > 1) {
+        //     const confirmParms = {
+        //         actionType: 'renameEstablishConnection',
+        //         node: fileNode,
+        //         icon: 'success',
+        //     };
+        //     invokeCommand('tsConfirm.open', confirmParms, () => {});
+        // }
     }
     else {
         // 查一下当前属性依赖的文件
         const { currentSource, fileNode } = naslServer.getCurrentSource(targetNode);
-        const oldRefs = await naslServer.references({
-            file: fileNode.getEmbeddedFilePath(),
-            line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-            offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-        });
-        oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-        // 更新文件之后
-        await naslServer.updateFiles({ outputFiles });
-        const newRefs2 = await naslServer.references({
-            file: fileNode.getEmbeddedFilePath(),
-            line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-            offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
-        });
-        newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+        if (currentSource) {
+            const oldRefs = await naslServer.references({
+                file: fileNode.getEmbeddedFilePath(),
+                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
+            });
+            oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+            // 更新文件之后
+            await naslServer.updateFiles({ outputFiles });
+            const newRefs2 = await naslServer.references({
+                file: fileNode.getEmbeddedFilePath(),
+                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
+            });
+            newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+        }
+    }
+}
+/**
+ * 处理一些节点操作，子节点需要更新并且check的场景
+ * 因为删除，新增父页面，或者重命名会一起
+ * 删除或者新增view而且他有子集 就要执行同样的操作
+ * @param action 当前操作类型
+ * @param fileNode 文件节点
+ * @param targetNode 操作节点  这里要两个相等才会走家去面对哦逻辑
+ * @param oldpath 触发内容的oldpath
+ */
+async function incidentalAction(action, fileNode, targetNode, oldpath) {
+    if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
+        // 删除或者新增页面
+        if (fileNode instanceof concepts_1.View && fileNode.children?.length) {
+            const fileNodeChildren = fileNode.children;
+            for (let i = 0; i < fileNodeChildren.length; i++) {
+                const fileNodeItem = fileNodeChildren[i];
+                const result = fileNodeItem.toEmbeddedTSFile();
+                if (action === 'create') {
+                    await handleChange(fileNodeItem, fileNodeItem, result, action);
+                    await incidentalAction(action, fileNodeItem, fileNodeItem);
+                }
+                else if (action === 'delete') {
+                    await handleDelete(fileNodeItem, fileNodeItem, result);
+                    await incidentalAction(action, fileNodeItem, fileNodeItem);
+                }
+                else if (action === 'update' && oldpath) {
+                    const parentPath = oldpath.replace('.ts', '/');
+                    const currentOldPath = parentPath + fileNodeItem.name + '.ts';
+                    // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                    await handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
+                    await incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
+                }
+            }
+            ;
+        }
+        // 删除或新增模块
+        // 需要把下面的哦内容全部都更新一遍
+        if (fileNode instanceof concepts_1.Module) {
+            const module = (targetNode);
+            const results = [];
+            naslServer.contentToFile(module, results);
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                const node = naslServer.file2NodeMap.get(result.filePath);
+                if (action === 'create') {
+                    await handleChange(node, node, result, action);
+                }
+                else {
+                    await handleDelete(node, node, result);
+                }
+            }
+            ;
+            // 删除模块通知更新列表
+            if (action === 'delete') {
+                try {
+                    // 如果已经
+                    (0, common_1.invokeCommand)('module.delete', true);
+                }
+                catch (err) {
+                    console.log('module.delete', '组件销毁了,不用唤起了');
+                }
+            }
+        }
     }
-    console.log('filesToCheck', filesToCheck, filesToCheck.size);
-    await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-    // outputFiles.map((file) => file.file));
 }
 async function receiveHandleChange($event) {
     // 行为
@@ -1420,7 +1731,11 @@ async function receiveHandleChange($event) {
     // 当前操作的文件节点
     const { fileNode } = naslServer.getCurrentSource(targetNode);
     // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
-    if (fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration) {
+    if (!fileNode || fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration) {
+        // module单独处理
+        if (fileNode instanceof concepts_1.Module) {
+            await incidentalAction(action, fileNode, targetNode);
+        }
         return;
     }
     const result = fileNode.toEmbeddedTSFile();
@@ -1438,24 +1753,49 @@ async function receiveHandleChange($event) {
     ]);
     fileNode.sourceMap = result.sourceMap;
     if (action === 'update' || action === 'create') {
-        if ($event?.field !== 'name')
+        if ($event?.field !== 'name') {
             await handleChange(fileNode, targetNode, result, action);
+            await incidentalAction(action, fileNode, targetNode);
+        }
         else {
-            await handleRename(fileNode, targetNode, result, fileNode.getEmbeddedFilePath($event.oldName));
+            const oldpath = fileNode.getEmbeddedFilePath($event.oldObject.name);
+            await handleRename(fileNode, targetNode, result, oldpath);
+            await incidentalAction(action, fileNode, targetNode, oldpath);
         }
     }
     // 删除
     if (action === 'delete') {
+        await incidentalAction(action, fileNode, targetNode);
         await handleDelete(fileNode, targetNode, result);
     }
+    return true;
 }
 // 监听所有改变操作
 translator_1.embeddedTSEmitter.on('change', ($event) => {
     // 收集到一个行为集合
     const eventValue = $event.value;
-    eventValue.forEach((item) => {
-        receiveHandleChange(item.originEvent);
+    const stackList = [];
+    eventValue.forEach(async (item) => {
+        stackList.push(item.originEvent);
     });
+    // 异步状态机,一个完成了在执行下一个
+    function next() {
+        const item = stackList.shift();
+        receiveHandleChange(item).then(async () => {
+            if (stackList.length) {
+                next();
+            }
+            else {
+                console.log('filesToCheck', filesToCheck, filesToCheck.size);
+                await naslServer.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
+                filesToCheck.clear();
+            }
+        });
+    }
+    // 如果有长度开始执行状态机
+    if (stackList.length) {
+        next();
+    }
 });
 naslServer.messager.options.context = naslServer;
 exports.default = naslServer;