@lcap/nasl 2.18.0 → 2.20.0-beta.2

package/out/server/naslServer.d.ts

@@ -47,6 +47,8 @@ export declare class NaslServer {
     diagnosticManager: DiagnosticManager;
     embeddedTSEmitter: EventEmitter;
     changeStackList: Array<EventPayload>;
+    filesToCheck: Set<string>;
+    singleFileChangeIng: Boolean;
     constructor();
     start(): Promise<unknown>;
     terminate(): void;
@@ -293,7 +295,7 @@ export declare class NaslServer {
             defaultValue: any;
         };
     };
-    getCurrentTypeAnnotation(node: BaseNode): Promise<unknown>;
+    getCurrentTypeAnnotation(node: BaseNode, outTime?: number): Promise<unknown>;
     getBaseNodesTypeMap(nodes: Array<BaseNode>): Promise<Map<BaseNode, TypeAnnotation | {
         typeAnnotation: TypeAnnotation;
         option: any;

package/out/server/naslServer.js

@@ -53,10 +53,6 @@ const EmbeddedTSFileLineMap = {
 const EmbeddedTSFileOffsetMap = {
     Variable: 12,
 };
-// 要Check的文件
-const filesToCheck = new Set();
-// 单个文件正在change，不允许同时两个文件一起change
-let singleFileChangeIng = false;
 let isChangeInterface = false; //判断是否导入接口
 let actionArr = []; //用于导入接口收集更改的节点
 let timer = null; //超时器用于收集导入接口相关
@@ -104,6 +100,8 @@ class NaslServer {
     embeddedTSEmitter = undefined;
     // 需要执行修改的文件
     changeStackList = [];
+    filesToCheck;
+    singleFileChangeIng;
     constructor() {
         /// #if process.env.BUILD_TARGET === 'node'
         if (globalThis.process) // For TS build
@@ -114,6 +112,10 @@ class NaslServer {
         if (globalThis.window) // For TS build
             this.worker = new worker_threads_1.Worker('/ts-worker.js');
         /// #endif
+        // 要Check的文件
+        this.filesToCheck = new Set();
+        // 单个文件正在change，不允许同时两个文件一起change
+        this.singleFileChangeIng = false;
         this.diagnosticManager = new diagnostic_1.DiagnosticManager();
         this.messager = new Messager_1.default({
             protocol: 'ts-worker',
@@ -134,7 +136,35 @@ class NaslServer {
             // 收集到一个行为集合
             const eventValue = $event.value;
             eventValue.forEach(async (item) => {
-                this.changeStackList.push(item.originEvent);
+                /**
+                 * 多个行为进行合并
+                 * 合并规则是
+                 * 1.[a,b,c,c] 在cc的时候，在已有一个c，又来一个c的时候，如果他们不都是file级别的节点
+                 *   就可以前面的内容去掉，只保留最后一个
+                 * 2.[a,b,c,b,c] 在bc已存在，又来了bc 这就都要保留，因为可能顺序有相关性，不能去掉
+                 * 理论上只处理同时几个操作 合并，
+                 * 3.有field的也直接保留
+                 */
+                try {
+                    const changeEvent = item.originEvent;
+                    const changeNode = changeEvent.target;
+                    const { fileNode } = this.getCurrentSource(changeNode);
+                    if (changeNode !== fileNode || !changeEvent.field) {
+                        const findIndex = this.changeStackList.findIndex((changeStackItem) => {
+                            const target = changeStackItem.target;
+                            const { fileNode: targetFileNode } = this.getCurrentSource(target);
+                            return targetFileNode === fileNode;
+                        });
+                        if (findIndex === this.changeStackList.length - 1) {
+                            this.changeStackList.pop();
+                        }
+                    }
+                    this.changeStackList.push(item.originEvent);
+                }
+                catch (err) {
+                    console.log(err);
+                    this.changeStackList.push(item.originEvent);
+                }
             });
             // 如果有长度开始执行状态机
             if (this.changeStackList.length) {
@@ -177,17 +207,34 @@ class NaslServer {
             catch (err) {
             }
         });
-        module.frontendVariables?.forEach((frontendVariable) => {
+        module.frontends?.forEach((frontend) => {
             try {
-                const result = frontendVariable.toEmbeddedTSFile();
+                const result = frontend.toEmbeddedTSFile();
                 results.push(result);
                 // sourceMap都存在目录级别内容下，在页面层级下去找
-                frontendVariable.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, frontendVariable);
+                frontend.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, frontend);
             }
             catch (err) {
                 console.log(err);
             }
+            frontend.variables?.forEach((frontendVariable) => {
+                try {
+                    const result = frontendVariable.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    frontendVariable.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, frontendVariable);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            });
+            // view的生成
+            if (!config_1.config.closeViews) {
+                this.view2TSFile(frontend.views, results);
+            }
+            frontend.componentDependencies?.forEach((item) => this.contentToFile(item, results));
         });
         module.dataSources?.forEach((dataSource) => {
             // 本身dataSource也要生成一个文件用于改名
@@ -246,10 +293,6 @@ class NaslServer {
             catch (err) {
             }
         });
-        // view的生成
-        if (!config_1.config.closeViews) {
-            this.view2TSFile(module.views, results);
-        }
         module.processes.forEach((process) => {
             try {
                 const result = process.toEmbeddedTSFile();
@@ -300,7 +343,6 @@ class NaslServer {
             // 其他模块的创建内容
             app.dependencies.forEach((item) => this.contentToFile(item, results));
             app.interfaceDependencies.forEach((item) => this.contentToFile(item, results));
-            app.componentDependencies.forEach((item) => this.contentToFile(item, results));
         }
         catch (err) {
             console.log(err);
@@ -553,7 +595,7 @@ class NaslServer {
             if (!flag)
                 return;
             const types = /\<([^()]+)\>/g.exec(displayString);
-            let typeStr = types && types[1];
+            const typeStr = types && types[1];
             const app = node.app;
             if (typeStr.includes('__name: "AStructure_')) {
                 const properties = [];
@@ -571,7 +613,7 @@ class NaslServer {
                             typeKind: 'reference',
                             typeName,
                             typeNamespace,
-                        })
+                        }),
                     }));
                     return '';
                 });
@@ -723,7 +765,8 @@ class NaslServer {
             //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
             // }
             record.suggestionDiagnostics = record.suggestionDiagnostics
-                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`].includes(item.text))
+                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`,
+                `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
                 .map((diag) => this._resolveDiagnostic(diag, node, record))
                 .filter((diag) => !!diag);
             record.suggestionDiagnostics.push(...this._attachSuggestionDiagnostics(node));
@@ -747,14 +790,14 @@ class NaslServer {
             // 递归检查，防止从顶层页面开始删除影响子页面内容检查
             while (curNode instanceof concepts_1.View && !removed) {
                 if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof concepts_1.App && !curNode.parentNode.views.includes(curNode)) {
+                    || curNode.parentNode instanceof concepts_1.Frontend && !curNode.parentNode.views.includes(curNode)) {
                     removed = true;
                 }
                 curNode = curNode.parentNode;
             }
             if (removed)
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof concepts_1.Match) {
                     const { cases, expression } = node || {};
                     const typeAnnotationMap = {};
@@ -764,7 +807,7 @@ class NaslServer {
                         count: 0,
                     };
                     if (Array.isArray(cases)) {
-                        cases.forEach(async (caseItem, index) => {
+                        cases.forEach((caseItem, index) => {
                             let isDisabled = false;
                             // 是最后一项
                             if (index === cases.length - 1) {
@@ -896,14 +939,14 @@ class NaslServer {
             // 递归检查，防止从顶层页面开始删除影响子页面内容检查
             while (curNode instanceof concepts_1.View && !removed) {
                 if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof concepts_1.App && !curNode.parentNode.views.includes(curNode)) {
+                    || curNode.parentNode instanceof concepts_1.Frontend && !curNode.parentNode.views.includes(curNode)) {
                     removed = true;
                 }
                 curNode = curNode.parentNode;
             }
             if (removed)
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof concepts_1.ViewElement && node.view === fileNode) {
                     if (node.tag) {
                         node.bindAttrs.forEach((bindAttr) => {
@@ -943,6 +986,9 @@ class NaslServer {
                                 // 子页面内部逻辑过滤
                                 if (nodeIn.view !== fileNode)
                                     return;
+                                // 当局部变量、输出参数属于页面内逻辑时，需过滤同页面下不同逻辑下的同名变量
+                                if (node.logic && node.logic !== nodeIn.logic)
+                                    return;
                                 // 跟变量无关的赋值过滤
                                 const jsCode = nodeIn.toJS();
                                 if (!jsCode.includes(`${node.name} = `))
@@ -1018,6 +1064,44 @@ class NaslServer {
                             };
                             diagnostics.push(diagnostic);
                         }
+                        else if (propertyValue.value) {
+                            const dataSource = fileNode;
+                            // 数据源有连接错误
+                            let envText;
+                            if (propertyValue.env === 'dev') {
+                                if (dataSource.__devConnectError) {
+                                    envText = '开发';
+                                }
+                                else if (dataSource.__devConnectError === false) {
+                                    return;
+                                }
+                            }
+                            else if (propertyValue.env === 'online') {
+                                if (dataSource.__onlineConnectError) {
+                                    envText = '生产';
+                                }
+                                else if (dataSource.__onlineConnectError === false) {
+                                    return;
+                                }
+                            }
+                            // 手动插入报错
+                            if (envText) {
+                                const diagnostic = {
+                                    node: fileNode,
+                                    severity: 'error',
+                                    message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
+                                    // 保留原来的内容方便查询一些问题
+                                    originalDiagnostic: {
+                                        fileName: '',
+                                        start: null,
+                                        end: null,
+                                        category: 'error',
+                                        text: `DataSource connection error`,
+                                    },
+                                };
+                                return diagnostics.push(diagnostic);
+                            }
+                        }
                     });
                 }
             }
@@ -1026,17 +1110,18 @@ class NaslServer {
             // 判断逻辑是否已经删除
             if (fileNode.parentNode instanceof concepts_1.App && !fileNode.parentNode.logics.includes(fileNode))
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
+                //OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
-                if ((node instanceof concepts_1.OqlQueryComponent || node instanceof concepts_1.SqlQueryComponent) && node.getTypeBanError()) {
-                    const diagnostic = {
-                        node,
-                        severity: 'error',
-                        message: 'SQL查询：返回类型内部,不支持复杂类型。',
-                    };
-                    node.tsErrorDetail = diagnostic;
-                    diagnostics.push(diagnostic);
-                }
+                // if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
+                //     const diagnostic = {
+                //         node,
+                //         severity: 'error',
+                //         message: 'SQL查询：返回类型内部,不支持复杂类型。',
+                //     };
+                //     node.tsErrorDetail = diagnostic;
+                //     diagnostics.push(diagnostic);
+                // }
                 if (node instanceof concepts_1.Return || node instanceof concepts_1.Variable) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
@@ -1073,6 +1158,11 @@ class NaslServer {
                 this.checkNodeError(node, diagnostics);
             });
         }
+        if (fileNode instanceof concepts_1.Process) {
+            fileNode?.sourceMap.forEach((value, node) => {
+                this.checkNodeError(node, diagnostics);
+            });
+        }
         return diagnostics;
     }
     checkNodeError(node, diagnostics) {
@@ -1153,9 +1243,32 @@ class NaslServer {
                     node.tsErrorDetail = diagnostic;
                     diagnostics.push(diagnostic);
                 }
+                // 如果TypeAnnotation 还存在，但是本身已经不是union类型，就是已经从union换别的类型了就都要报错
+            }
+            else if (node instanceof concepts_1.TypeAnnotation && matchExpressionType?.typeKind !== 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择类型不存在',
+                    titleTip: '该类型已被删除',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+                // 如果可枚举变量的 ，变量 还存在，但是本身已经是union类型，就是已经从别的类型 换了union就都要报错
+            }
+            else if (!(node instanceof concepts_1.TypeAnnotation) && matchExpressionType?.typeKind === 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择值不存在',
+                    titleTip: '该值无法匹配，请重新选择类型',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
             }
             if (node.tsErrorDetail) {
-                if (matchExpressionType?.typeNamespace?.includes('enums')) {
+                // 如果父级是枚举，而且子集选的是变量，就提示枚举值已被删除
+                if (matchExpressionType?.typeNamespace?.includes('enums') && (node instanceof concepts_1.MemberExpression)) {
                     node.tsErrorDetail.titleTip = '该枚举值已被删除';
                 }
                 else if (!node.tsErrorDetail.titleTip) {
@@ -1173,6 +1286,25 @@ class NaslServer {
             node.tsErrorDetail = diagnostic;
             diagnostics.push(diagnostic);
         }
+        /**
+         * 如果节点是内置函数
+         * 穷举在线上的情况，不在线上就void报错， calllogic 和 callinterface 因为原来有报错，所以就忽略掉
+         * && 他在父级中，不在body
+         * && 也不再 if的线上
+         * && 也不再 switch的线上consequent
+         * && 也不再草稿区域
+         * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
+         * && 而且也没有类型，就说明在槽位里，就需要报错
+         */
+        if (node instanceof concepts_1.CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallLogic' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
+            const diagnostic = {
+                node,
+                severity: 'error',
+                message: `类型不一致，当前内置函数${node.calleeName || ''}无返回值。`,
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
     }
     /* 接口导入查找 */
     existStructureFix(semanticDiagnostics, node, that) {
@@ -1556,7 +1688,7 @@ class NaslServer {
                     // 因为要用下面的点位信息
                     const name = minRange.node.name;
                     // 如果name不改，那就是要改命名空间
-                    if (newValue === name) {
+                    if (node instanceof concepts_1.Frontend || newValue === name) {
                         const namespace = minRange.node.namespace;
                         // 先看下标位置
                         const lineText = record.lineText;
@@ -1679,6 +1811,24 @@ class NaslServer {
                         minRange.newValue = newTsNameSpace;
                     }
                 }
+                if (node instanceof concepts_1.Frontend && minRange.node instanceof concepts_1.Destination) {
+                    const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                    const tsName = minRange.node.tsName;
+                    const oldValue = tsCalleeNamespace + '.' + tsName;
+                    // 先看下标位置
+                    const lineText = record.lineText;
+                    const index = lineText.indexOf(oldValue);
+                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                    const start = record.start.offset - index - 1;
+                    const end = record.end.offset - index - 1;
+                    if (start <= tsCalleeNamespace.length) {
+                        // 新的完整的value
+                        let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                        minRange.setTypeMethods = 'setViewNamespace';
+                        newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                        minRange.newValue = newTsNameSpace;
+                    }
+                }
                 // 如果是事件修改
                 // 如果是view也需要加前缀
                 // logic 和 views名称修改 可能会触发bindEvent修改
@@ -1893,12 +2043,8 @@ class NaslServer {
             const minRange = this._findMinRange(record, fileNode);
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
-                if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
-                    minRange.node.setCalleeArgName(parantNode);
-                }
-                // 如果节点参数增加页面也要更新
-                if (minRange.node instanceof concepts_1.Destination && node instanceof concepts_1.Param) {
-                    minRange.node.setViewArgument(parantNode);
+                if ((minRange.node instanceof concepts_1.CallLogic || minRange.node instanceof concepts_1.Destination) && node instanceof concepts_1.Param) {
+                    minRange.node.addCalleeArg(parantNode);
                 }
             }
         });
@@ -2205,7 +2351,7 @@ class NaslServer {
             return concepts_1.TypeAnnotation.createPrimitive('Boolean');
         }
         // Convert和new都是自身携带类型的，就不进行修改
-        if (node instanceof concepts_1.CallFunction && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'Convert' || node.calleeName === 'New')) {
+        if (node instanceof concepts_1.CallFunction && node.calleeNamespace === 'nasl.util' && (['Convert', 'New', 'FromString'].includes(node.calleeName))) {
             if (node.typeArguments.length) {
                 return node.typeArguments[0];
             }
@@ -2285,6 +2431,9 @@ class NaslServer {
                 'Return',
                 'Variable',
                 'Match',
+                'NewComposite',
+                'NewList',
+                'NewMap',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2336,6 +2485,13 @@ class NaslServer {
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
                 fileDetail.offset = newCode.length + 'return '.length;
             }
+            else if (['NewComposite', 'NewList', 'NewMap'].includes(node.concept)) {
+                fileDetail.line = item.range.end.line;
+                const indexOf = item.code.indexOf('return __newComposite');
+                let newCode = item.code.substring(0, indexOf);
+                newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+                fileDetail.offset = newCode.length + 'return '.length;
+            }
             args.push(fileDetail);
         });
         console.time('请求');
@@ -2379,15 +2535,23 @@ class NaslServer {
                 }
             }
         });
-        // 重置类型状态
+        // 重置类型状态, 并且赋值
         types.forEach((value, node) => {
-            node.__isCorrectTypeAnnotation = true;
-            if (value) {
-                if (value instanceof concepts_1.TypeAnnotation) {
-                    node.__TypeAnnotation = Object.freeze(value);
+            try {
+                // 因为node可能是经过处理的TypeAnnotation
+                node.__isCorrectTypeAnnotation = true;
+                if (value) {
+                    if (value instanceof concepts_1.TypeAnnotation) {
+                        node.__TypeAnnotation = Object.freeze(value);
+                    }
+                    else if (value.typeAnnotation) {
+                        node.__TypeAnnotation = Object.freeze(value.typeAnnotation);
+                    }
                 }
-                else if (value.typeAnnotation) {
-                    node.__TypeAnnotation = Object.freeze(value.typeAnnotation);
+            }
+            catch (err) {
+                if (globalThis.window) {
+                    console.log(err);
                 }
             }
         });
@@ -2644,7 +2808,7 @@ class NaslServer {
             option: { defaultValue: param.defaultValue },
         };
     }
-    async getCurrentTypeAnnotation(node) {
+    async getCurrentTypeAnnotation(node, outTime = 600) {
         if (node.__TypeAnnotation) {
             return node.__TypeAnnotation;
         }
@@ -2659,7 +2823,7 @@ class NaslServer {
                 else {
                     resolve(null);
                 }
-            }, 600);
+            }, outTime);
             const mySetInterval = setInterval(() => {
                 if (node.__isCorrectTypeAnnotation) {
                     resolve(node.__TypeAnnotation);
@@ -2745,7 +2909,7 @@ class NaslServer {
         }
         // 更新文件之后
         await this.updateFiles({ outputFiles });
-        newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
     }
     /**
      * 除去rename场景下的更新
@@ -2764,13 +2928,13 @@ class NaslServer {
             line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
             offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
         });
-        newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
         // 唤起建立连接弹框
         // 文件级别的建立连接采取提醒
         if (action === 'create' && targetNode.__init) {
             // 清除临时状态, 完成本次创建
             delete targetNode.__init;
-            if (fileNode === targetNode && filesToCheck.size > 1) {
+            if (fileNode === targetNode && this.filesToCheck.size > 1) {
                 const confirmParms = {
                     actionType: 'createEstablishConnection',
                     node: fileNode,
@@ -2804,8 +2968,8 @@ class NaslServer {
                 line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
                 offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
             });
-            oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-            filesToCheck.delete(oldFilePath);
+            oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+            this.filesToCheck.delete(oldFilePath);
             // 更新文件之后
             await this.updateFiles({ outputFiles });
             // 查一下新函数名的依赖
@@ -2816,7 +2980,7 @@ class NaslServer {
             });
             const newRefFileList = new Set();
             newRefs.refs.forEach((ref) => {
-                filesToCheck.add(ref.file);
+                this.filesToCheck.add(ref.file);
                 newRefFileList.add(ref.file);
             });
             // 文件级别重命名，有依赖才唤起弹框
@@ -2843,7 +3007,7 @@ class NaslServer {
                 line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
                 offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
             });
-            newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+            newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
         }
         else {
             // 查一下当前属性依赖的文件
@@ -2858,7 +3022,7 @@ class NaslServer {
                     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));
+                oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
                 // 更新文件之后
                 await this.updateFiles({ outputFiles });
                 const newRefs2 = await this.references({
@@ -2866,7 +3030,7 @@ class NaslServer {
                     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));
+                newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
             }
         }
     }
@@ -2881,6 +3045,31 @@ class NaslServer {
      */
     async incidentalAction(action, fileNode, targetNode, oldpath) {
         if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
+            //删除、更改、新增端
+            if (fileNode instanceof concepts_1.Frontend && (fileNode.views?.length || fileNode.variables?.length)) {
+                const fileNodeChildren = [...fileNode.views, ...fileNode.variables];
+                for (let i = 0; i < fileNodeChildren.length; i++) {
+                    const fileNodeItem = fileNodeChildren[i];
+                    const result = fileNodeItem.toEmbeddedTSFile();
+                    fileNodeItem.sourceMap = result.sourceMap;
+                    if (action === 'create') {
+                        await this.handleChange(fileNodeItem, fileNodeItem, result, action);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'delete') {
+                        await this.handleDelete(fileNodeItem, fileNodeItem, result);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'update' && oldpath) {
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const foldName = fileNodeItem.concept === 'View' ? 'views' : 'variables';
+                        const currentOldPath = parentPath + foldName + '/' + fileNodeItem.name + '.ts';
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
+                    }
+                }
+            }
             // 删除或者新增页面
             if (fileNode instanceof concepts_1.View && fileNode.children?.length) {
                 const fileNodeChildren = fileNode.children;
@@ -2955,7 +3144,7 @@ class NaslServer {
         }
     }
     async receiveHandleChange($event) {
-        singleFileChangeIng = true;
+        this.singleFileChangeIng = true;
         // 行为
         const action = $event.action;
         const targetNode = $event.target;
@@ -3002,20 +3191,20 @@ class NaslServer {
         return true;
     }
     changeFileNext() {
-        if (!singleFileChangeIng) {
+        if (!this.singleFileChangeIng) {
             const item = this.changeStackList.shift();
             this.receiveHandleChange(item).catch((err) => {
                 console.log(err, 'receiveHandleChangeErr');
             }).finally(async () => {
                 // 每一个文件与change接触就把状态置为false，让下一个进入
-                singleFileChangeIng = false;
+                this.singleFileChangeIng = false;
                 if (this.changeStackList.length) {
                     this.changeFileNext();
                 }
                 else {
-                    console.log(Array.from(filesToCheck));
-                    await this.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-                    filesToCheck.clear();
+                    console.log(Array.from(this.filesToCheck));
+                    await this.getDiagnosticRecordsAndPushAll(Array.from(this.filesToCheck));
+                    this.filesToCheck.clear();
                 }
             });
         }