@lcap/nasl 1.0.2 → 2.12.0

package/src/server/getProcesses.ts

@@ -527,3 +527,71 @@ export function getProcessVariableSuggestionsAll(node: ProcessElement) {
     }
     return processVariables;
 }
+
+
+export function getFlowAfterElements(el: ProcessElement) {
+    const process = el.process;
+    const processname = el.name;
+    const elems = process.elements;
+    const links = elems.filter(e => e.type === 'SequenceFlow' && e.sourceRef === processname);
+    return links;
+}
+export function getFlowBeforeElements(el: ProcessElement) {
+    const process = el.process;
+    const processname = el.name;
+    const elems = process.elements;
+    const links = elems.filter(e => e.type === 'SequenceFlow' && e.targetRef === processname);
+    return links;
+}
+
+export function isFromStartNode(el: ProcessElement) {
+    const process = el.process;
+    // const processname = el.name;
+    const elems = process.elements;
+    const set = new WeakSet();
+    const stack = [el];
+    while(stack.length){
+        let t = stack.shift();
+        let name = t.name;
+        if(t.type === 'StartNoneEvent') {
+            return true;
+        }
+        elems.forEach(e => {
+            if(e.type === 'SequenceFlow' 
+                && e.targetRef === name 
+                && !set.has(e)) {
+                set.add(e);
+                const sourcename = e.sourceRef;
+                const source = elems.find(e => e.name === sourcename);
+                stack.push(source);
+            }
+        });
+    }
+    return false;
+}
+
+export function findNodeAfterNodeInFlow(el: ProcessElement) {
+    const process = el.process;
+    const elems = process.elements;
+    const set = new WeakSet();
+    const nodeSet = new Set();
+    const stack = [el];
+    while(stack.length){
+        let t = stack.shift();
+        if(el !== t) {
+            nodeSet.add(t);
+        }
+        const name = t.name;
+        elems.forEach(e => {
+            if(e.type === 'SequenceFlow' 
+                && e.sourceRef === name 
+                && !set.has(e)) {
+                set.add(e);
+                const targetname = e.targetRef;
+                const source = elems.find(e => e.name === targetname);
+                stack.push(source);
+            }
+        });
+    }
+    return Array.from(nodeSet);
+}

package/src/server/naslServer.ts

@@ -44,7 +44,9 @@ import {
     Namespace,
     Theme,
     Variable,
+    DataSource,
     Assignee,
+    SqlQueryComponent,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem, embeddedTSEmitter } from '../translator';
 import axios from '../service/storage';
@@ -100,6 +102,10 @@ interface QuoteNode {
     expanded: boolean;
     children?: QuoteNode[];
 }
+let isChangeInterface = false; //判断是否导入接口
+type ActionNode = { target: Variable; typeannotation: TypeAnnotation };
+let actionArr: Array<ActionNode> = []; //用于导入接口收集更改的节点
+let timer: number = null; //超时器用于收集导入接口相关
 const naslServer = {
     messager,
     worker,
@@ -142,17 +148,30 @@ const naslServer = {
                 console.log(err);
             }
         });
-        module.entities.forEach((entity) => {
+        (module as App).dataSources?.forEach((dataSource) => {
+            // 本身dataSource也要生成一个文件用于改名
             try {
-                const result = entity.toEmbeddedTSFile();
+                const result = dataSource.toEmbeddedTSFile();
                 results.push(result);
                 // sourceMap都存在目录级别内容下，在页面层级下去找
-                entity.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, entity);
+                dataSource.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, dataSource);
             } catch (err) {
                 console.log(err);
             }
+            dataSource.entities.forEach((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) => {
             try {
                 const result = _interface.toEmbeddedTSFile();
@@ -481,8 +500,10 @@ const naslServer = {
             oldRecord?.semanticDiagnostics.forEach((item) => {
                 item.node ? (item.node.tsErrorDetail = undefined) : '';
             });
-
             // 语义诊断
+            if (isChangeInterface) {
+                this.existStructureFix(record.semanticDiagnostics, node as FileNode, this);
+            }
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode))
                 .filter((diag) => !!diag);
@@ -507,6 +528,7 @@ const naslServer = {
             record.suggestionDiagnostics = [];
             // 语法诊断暂时不需要
         });
+
         return records;
     },
     _attachDiagnostics(fileNode: BaseNode): Diagnostic[] {
@@ -515,8 +537,7 @@ const naslServer = {
             traverse((current) => {
                 if (current.node.tag) {
                     current.node.bindAttrs.forEach((bindAttr) => {
-                        if ((bindAttr.model || bindAttr.sync)
-                            && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
+                        if ((bindAttr.model || bindAttr.sync) && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
                             const diagnostic = {
                                 node: bindAttr,
                                 severity: 'error',
@@ -529,9 +550,91 @@ const naslServer = {
                 }
             }, { node: { children: fileNode.elements } as ViewElement });
         }
+        if (fileNode instanceof DataSource) {
+            const dataSourceGroup = (fileNode.rootNode as App).configuration?.getGroup('dataSource');
+            if (dataSourceGroup) {
+                const property = dataSourceGroup.getProperty(fileNode.name);
+                if (property && property.values) {
+                    property.values.forEach((propertyValue) => {
+                        if (!propertyValue.value && fileNode.name !== 'defaultDS') {
+                            const diagnostic = {
+                                node: fileNode,
+                                severity: 'error',
+                                message: `数据源配置：数据源${property.name}${propertyValue.env === 'dev' ? '开发环境' : '生产环境'}未配置数据信息`,
+                                // 保留原来的内容方便查询一些问题
+                                originalDiagnostic: {
+                                    fileName: '',
+                                    start: <any>null,
+                                    end: <any>null,
+                                    category: 'error',
+                                    text: `Data Source is not config`,
+                                },
+                            };
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
+            }
+        }
 
         return diagnostics;
     },
+    /* 接口导入查找 */
+    existStructureFix(semanticDiagnostics: Diagnostic[], node: FileNode, that: any) {
+        let module: Module;
+        semanticDiagnostics.map((diag) => {
+            const minRange = this._findMinRange(diag as unknown as tsProtocol.DiagnosticWithFileName, node);
+            if (diag.text?.includes('has no exported member named')) {
+                if (minRange.node instanceof Logic) {
+                    return null;
+                }
+                const typeAnnotation = minRange.node instanceof TypeAnnotation ? (minRange.node.upperNode as Variable).typeAnnotation : (minRange.node as Variable).typeAnnotation;
+                const regNamespace = /<(\S*)>/;
+                const typeKey = (typeAnnotation.typeKey.match(regNamespace) && typeAnnotation.typeKey.match(regNamespace)[1]) || typeAnnotation.typeKey;
+                const typeKeyArr = typeKey.split('.');
+                if (typeKeyArr[0] === 'apis') {
+                    const structureName = typeKeyArr[3];
+                    const moduleName = typeKeyArr[1];
+                    const app = (typeAnnotation.upperNode as Variable).app;
+                    if (!app) {
+                        return null;
+                    }
+                    module = app.interfaceDependencies?.find((item) => item.name === moduleName);
+                    let existStructure = module?.structures?.find((item) => item.name.toUpperCase() === structureName.toUpperCase());
+                    if (!existStructure) {
+                        const realName = structureName.replace(/\d*$/, (m) => String(''));
+                        existStructure = module?.structures?.find((item) => item.name.toUpperCase() === realName.toUpperCase());
+                    }
+                    if (existStructure) {
+                        const editTypeAnnotation = JSON.parse(JSON.stringify(typeAnnotation).replace(new RegExp(structureName, 'g'), existStructure.name));
+                        actionArr.push({ target: typeAnnotation.parentNode as Variable, typeannotation: editTypeAnnotation });
+                    }
+                }
+                return null;
+            } else {
+                return diag;
+            }
+        });
+        if (actionArr.length) {
+            if (timer)
+                return;
+            timer = window.setTimeout(() => {
+                const app = actionArr[0].target.app;
+                app.emit('collect:start', {
+                    actionMsg: '设置导入接口数据类型错误',
+                });
+                module.isAdd && module.setIsAdd(false);
+                actionArr.forEach((item) => {
+                    item.target.setDataType(TypeAnnotation.from(item.typeannotation));
+                });
+                app.emit('collect:end');
+                actionArr = [];
+                isChangeInterface = false;
+                clearTimeout(timer);
+                timer = null;
+            }, 2000);
+        }
+    },
     _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode): Diagnostic {
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
@@ -625,6 +728,33 @@ const naslServer = {
             }
         }
 
+        // 如果是DataSource就需要在单独，查一边来修改名字
+        if (node instanceof DataSource) {
+            // 过滤一把不需要改的信息
+            refsList = refsList.filter((item) => {
+                const dataSourceFile = (fileNode as FileNode).getEmbeddedFilePath();
+                const entityFilePrefix = dataSourceFile.replace('.ts', '');
+                /**
+                 * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
+                 * 所以全部过滤掉了,
+                 * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了8个函数之外的引用
+                 * 所以底部内容是8个函数,所以这里就 用entity的行数 减去8个函数的行数,然后其余的在进行处理
+                 * 进行过滤
+                 */
+                // 不要数据源下面的实体里的引用 ,保留原始的节点内容
+                let flag = false;
+                if (item.file.includes(entityFilePrefix)) {
+                    const entity = this.file2NodeMap.get(item.file);
+                    const { currentSource } = naslServer.getCurrentSource(entity);
+                    // 32 8个函数的总行数
+                    if (item.end.line < currentSource.range.end.line - 32 && item.start.line > 1) {
+                        flag = true;
+                    }
+                }
+                // 属于实体而且需要修改和查到  ||  不是实体前缀的 || 他本身
+                return flag || !item.file.includes(entityFilePrefix) || dataSourceFile === item.file;
+            });
+        }
         // 如果是entity就需要在单独，查一边来修改名字
         if (node instanceof Entity) {
             // 过滤一把不需要改的信息
@@ -909,19 +1039,19 @@ const naslServer = {
                     // logic 和 views名称修改 可能会触发bindEvent修改
                     if (minRange.node instanceof BindEvent) {
                         // 页面逻辑直接赋值就可以, 因为是相对路径
-                        if ((node instanceof ViewElement)) {
+                        if (node instanceof ViewElement) {
                             minRange.setTypeMethods = 'setCalleeNamespace';
                             minRange.newValue = 'elements.' + newValue + '.logics';
                         } else {
                             /**
-                         * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
-                         * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
-                         * 但是505 要改名为 666 ，要存的是666
-                         * 'app.views.Student.views.404.views.666.views.update'
-                         * 1.取到转后的
-                         * 2.在匹配到的内容中取转后的namespace的位置
-                         * 3.然后把namespace中的 $替换成 ''
-                         */
+                             * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
+                             * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
+                             * 但是505 要改名为 666 ，要存的是666
+                             * 'app.views.Student.views.404.views.666.views.update'
+                             * 1.取到转后的
+                             * 2.在匹配到的内容中取转后的namespace的位置
+                             * 3.然后把namespace中的 $替换成 ''
+                             */
                             const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
                             const oldValue = tsCalleeNamespace;
 
@@ -983,6 +1113,42 @@ const naslServer = {
                     if (minRange.node instanceof QueryFieldExpression && node instanceof Entity) {
                         minRange.setTypeMethods = 'setEntityAsName';
                     }
+                    // 如果修改的是dataSource字段
+                    if (node instanceof DataSource) {
+                        const setTypeNamespace = (typeNamespace: string, record: any) => {
+                            // 先看下标位置
+                            const lineText = record.lineText;
+                            const index = lineText.indexOf(typeNamespace);
+                            // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                            const start = record.start.offset - index - 1;
+                            const end = record.end.offset - index - 1;
+                            // 新的完整的value
+                            const newTextValue = typeNamespace.substring(0, start) + newValue + typeNamespace.substring(end, typeNamespace.length);
+                            minRange.newValue = newTextValue;
+                            return newTextValue;
+                        };
+                        if (minRange.node instanceof TypeAnnotation) {
+                            minRange.setTypeMethods = 'setTypeNamespace';
+                            const newValue = setTypeNamespace(minRange.node.typeNamespace, record);
+                            minRange.newValue = newValue;
+                        } else if (minRange.node instanceof QueryFromExpression || minRange.node instanceof QueryJoinExpression) {
+                            minRange.setTypeMethods = 'setEntityNamespace';
+                            const newValue = setTypeNamespace(minRange.node.entityNamespace, record);
+                            minRange.newValue = newValue;
+                        } else if (minRange.node instanceof QueryFieldExpression) {
+                            return null;
+                        } else if (minRange.node instanceof CallLogic) {
+                            minRange.setTypeMethods = 'setCalleeNamespace';
+                            const newValue = setTypeNamespace(minRange.node.calleeNamespace, record);
+                            minRange.newValue = newValue;
+                        } else if (minRange.node instanceof EntityProperty) {
+                            minRange.setTypeMethods = 'setRelationNamespace';
+                            const newValue = setTypeNamespace(minRange.node.relationNamespace, record);
+                            minRange.newValue = newValue;
+                        } else if (minRange.node instanceof SqlQueryComponent) {
+                            minRange.setTypeMethods = 'setDataSource';
+                        }
+                    }
                     if (minRange.node instanceof QueryGroupByExpression && node instanceof Entity) {
                         minRange.setTypeMethods = 'setEntityAsName';
                     }
@@ -998,7 +1164,10 @@ const naslServer = {
                     }
 
                     // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
-                    if ((minRange.node instanceof Param || minRange.node instanceof Variable || minRange.node instanceof Return) && (node instanceof Entity || node instanceof Enum || node instanceof Structure)) {
+                    if (
+                        (minRange.node instanceof Param || minRange.node instanceof Variable || minRange.node instanceof Return)
+                        && (node instanceof Entity || node instanceof Enum || node instanceof Structure)
+                    ) {
                         return null;
                     }
                     if (minRange.node instanceof Destination && (node instanceof Process || node instanceof ProcessElement)) {
@@ -1037,7 +1206,7 @@ const naslServer = {
                         /**
                          * 这里过滤一下，一些查找引用，重复的内容，直接屏蔽掉，防止操作重复
                          * 因为在生成的时候 ，可能弄了一些副作用的引用
-                        */
+                         */
                         // 本来是想在上面过滤一把的先放到这里匹配这两个的时候 就会找到
                         // refsList = refsList.filter((item) => {
                         //     屏蔽组件查找查到定义这里，也过滤一下
@@ -1052,7 +1221,7 @@ const naslServer = {
                      * 流程改名不触发Logic改名
                      * 如果是修改param查找到logic就不操作
                      * 除非想在内部修改别的内容所以暂时屏蔽掉
-                    */
+                     */
                     if (minRange.node instanceof Logic && node !== minRange.node) {
                         return null;
                     }
@@ -1079,11 +1248,11 @@ const naslServer = {
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
                 if (minRange.node instanceof CallLogic && node instanceof Param) {
-                    minRange.node.setCalleeArgName((parantNode) as Logic);
+                    minRange.node.setCalleeArgName(parantNode as Logic);
                 }
                 // 如果节点参数增加页面也要更新
                 if (minRange.node instanceof Destination && node instanceof Param) {
-                    minRange.node.setViewArgument((parantNode) as View);
+                    minRange.node.setViewArgument(parantNode as View);
                 }
             }
         });
@@ -1101,12 +1270,12 @@ const naslServer = {
                 parentNode: parantNode,
                 parentKey: node.parentKey,
             });
-            naslServer._addParamsEffect(refsList, (node) as Param);
+            naslServer._addParamsEffect(refsList, node as Param);
             // 结束修改 ，批量操作
             App.emit('collect:end');
             return node;
         }
-        naslServer._addParamsEffect(refsList, (node) as Param);
+        naslServer._addParamsEffect(refsList, node as Param);
         return node;
     },
     // 查找引用
@@ -1114,10 +1283,10 @@ const naslServer = {
         let refsList = await naslServer._isHaveRef(node);
         // 如果查找引用查到自己里面的引用不展示
         refsList = refsList.filter((item) =>
-            // 自己引用自己的过滤掉
-            // 删除的时候过滤一把组件删除提示
-            // 展示组件自己屏蔽掉
-            !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.')));
+        // 自己引用自己的过滤掉
+        // 删除的时候过滤一把组件删除提示
+        // 展示组件自己屏蔽掉
+            !item.isDefinition && !item.lineText.includes(' = new nasl.ui.'));
         // 最后返回的结果
         let result = new Map();
         // 树的构造，key： 一个file的node， 值是 [[logic, params],[logic, returns]]
@@ -1276,8 +1445,16 @@ const naslServer = {
         let sourceMap = node.sourceMap;
         let fileNode = node;
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
-        // 如果 节点找到 app 或者module 停止
-        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof App) && !(fileNode.parentNode instanceof Module) && !(fileNode instanceof View)) {
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是view就不要向上查找了
+        while (
+            !sourceMap
+            && fileNode
+            && !(fileNode.parentNode instanceof App)
+            && !(fileNode.parentNode instanceof Module)
+            && !(fileNode.parentNode instanceof DataSource)
+            && !(fileNode instanceof View)
+        ) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -1482,6 +1659,7 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
             for (let i = 0; i < fileNodeChildren.length; i++) {
                 const fileNodeItem = fileNodeChildren[i];
                 const result = (fileNodeItem as FileNode).toEmbeddedTSFile();
+                fileNodeItem.sourceMap = result.sourceMap;
                 if (action === 'create') {
                     await handleChange(fileNodeItem, fileNodeItem, result, action);
                     await incidentalAction(action, fileNodeItem, fileNodeItem);
@@ -1500,7 +1678,10 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
         // 删除或新增模块
         // 需要把下面的哦内容全部都更新一遍
         if (fileNode instanceof Module) {
-            const module: Module = (targetNode) as Module;
+            if (fileNode.type === 'interface' && fileNode.isAdd && action === 'create') {
+                isChangeInterface = true;
+            }
+            const module: Module = targetNode as Module;
             const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
             naslServer.contentToFile(module, results);
             for (let i = 0; i < results.length; i++) {
@@ -1523,6 +1704,22 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
                 }
             }
         }
+        /**
+         * DataSource只会重命名时候，需要把子集全部重新生成一下
+         */
+        if (fileNode instanceof DataSource) {
+            (fileNode as DataSource).entities.forEach(async (entity) => {
+                try {
+                    const result = entity.toEmbeddedTSFile();
+                    const parentPath = oldpath.replace('.ts', '/');
+                    const currentOldPath = parentPath + '/entities/' + entity.name + '.ts';
+                    // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                    await handleRename(entity, entity, result, currentOldPath);
+                } catch (err) {
+                    console.log(err);
+                }
+            });
+        }
     }
 }
 

package/src/server/process2LogicNamespace.ts

@@ -3,8 +3,8 @@ import { genLaunchProcess, genUserTaskLogic } from './getProcesses';
 
 /**
  * 给调用逻辑用
- * @param process 
- * @returns 
+ * @param process
+ * @returns
  */
 export function process2LogicNamespace(process: Process) {
     const children: Array<Namespace> = [];
@@ -18,13 +18,13 @@ export function process2LogicNamespace(process: Process) {
             });
             // 与process 中 toEmbededTS 所设置的 namespace 相关
             const path = `app.processes.${process.name}.elements.${e.name}.logics`;
-            l.getNamespace = function() {
+            l.getNamespace = function () {
                 return path;
-            }
+            };
             const api = `/api/${process.name}/${e.name}/${l.name}`;
-            l.getPath = function() {
+            l.getPath = function () {
                 return api;
-            }
+            };
             children.push(ns);
             ns.path = `app.processes.${process.name}.elements.${e.name}`;
             ns.expanded = true;
@@ -38,12 +38,12 @@ export function process2LogicNamespace(process: Process) {
     });
     ns.path = `app.processes.${process.name}.logics`;
     const api = `/api/${process.name}/${launchLogic.name}`;
-    launchLogic.getNamespace = function() {
+    launchLogic.getNamespace = function () {
         return ns.path;
-    }
-    launchLogic.getPath = function() {
+    };
+    launchLogic.getPath = function () {
         return api;
-    }
+    };
     return ns;
 }
 
@@ -61,8 +61,8 @@ interface processTreeFragment {
 }
 /**
  * 给侧边栏树形用
- * @param process 
- * @returns 
+ * @param process
+ * @returns
  */
 export function processToTreeFragment(process: Process) {
     const fragment: processTreeFragment = {
@@ -71,28 +71,38 @@ export function processToTreeFragment(process: Process) {
         id: process.id,
         logics: [],
         elements: [],
-    }
+    };
     process.elements.forEach((e) => {
         if (e.type === 'UserTask') {
             const l = genUserTaskLogic(e);
-            l.parentKey = 'readonly'
-            l.params.forEach(p => {
+            l.parentKey = 'readonly';
+            l.params.forEach((p) => {
                 p.readonly = true;
-            })
+            });
             l.parentNode = process;
+            // 与process 中 toEmbededTS 所设置的 namespace 相关
+            const path = `app.processes.${process.name}.elements.${e.name}.logics`;
+            l.getNamespace = function () {
+                return path;
+            };
             fragment.elements.push({
                 level: 'processTreeElementFragment',
                 id: e.id,
                 name: e.name,
                 logics: [l],
-            })
+            });
         }
     });
 
     const launchLogic = genLaunchProcess(process);
     launchLogic.parentNode = process;
-    
+
+    const path = `app.processes.${process.name}.logics`;
+    launchLogic.getNamespace = function () {
+        return path;
+    };
+
     fragment.logics.push(launchLogic);
-    launchLogic.parentKey = 'readonly'
+    launchLogic.parentKey = 'readonly';
     return fragment;
 }

package/src/server/translator.ts

@@ -41,6 +41,7 @@ import {
     ForEachStatement,
     CallFunction,
     ProcessOutcome,
+    Function,
 } from '../concepts';
 import { SourceMapItem } from '../translator';
 import { Diagnostic } from '../manager/diagnostic';
@@ -226,6 +227,10 @@ const TS_RULES: Array<{
         re: /No value exists in scope for the shorthand property '__(?:IDENTIFIER|LEFT|RIGHT)__'. Either declare one or provide an initializer./,
         result: '用户任务未关联页面',
     },
+    {
+        re: /No value exists in scope for the shorthand property '__(?:outOfProcess)__'. Either declare one or provide an initializer./,
+        result: '节点未关联到流程图',
+    },
     {
         re: /'(.+?)' is declared but its value is never read/,
         result: "已添加'$1'，但从来没有使用过。",
@@ -355,6 +360,8 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             return null;
         } else if (text.startsWith(`Namespace 'nasl.ui' has no exported member `)) {
             return null;
+        } else if (text.startsWith(`Function expression, which lacks return-type annotation, implicitly has an 'any[]' return type.`)) {
+            return null;
         }
     }
     // 处理bindevent参数没传递的报错
@@ -363,6 +370,37 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
         if (node instanceof BindEvent) {
             return null;
         }
+
+        if (node instanceof ProcessElement && (node.type === 'UserTask' || node.type === 'AutoTask' || node.type === 'StartNoneEvent')) {
+            const reg = /Expected (.+?) arguments, but got (.+?)./.exec(text);
+            let u = '用户任务';
+            if(node.type === 'AutoTask') {
+                u = '自动任务';
+            }
+            if(reg[2] === '0') {
+                tsErrorDetail.message = `${u}出口顺序流个数不能是0`;
+            } else {
+                tsErrorDetail.message = `${u}出口顺序流个数不能大于1`;
+            }
+           
+            if(node.type === 'StartNoneEvent') {
+                tsErrorDetail.message = `开始节点只能有一个出口顺序流`;
+            }
+        }
+
+        if (node instanceof ProcessElement && (node.type === 'ExclusiveGateway' || node.type === 'ParallelGateway')) {
+            const reg = /Expected (.+?) arguments, but got (.+?)./.exec(text);
+            let u = '排他网关';
+            if(node.type === 'ParallelGateway') {
+                u = '并行网关';
+            }
+            if(reg[2] === '0') {
+                tsErrorDetail.message = `${u}出口顺序流和入口顺序流个数不能等于0`;
+            } else {
+                tsErrorDetail.message = `${u}出口顺序流和入口顺序流个数同时等于1，该${u}没有意义`;
+            }
+            
+        }
     }
 
     // 因为缺少参数时候有可能有特殊情况,因为原本少的多了就会找到 callLogic上,
@@ -427,7 +465,7 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             tsErrorDetail.message = '调用函数：参数不能为空！';
         } else if ((node instanceof Argument && node.parentNode instanceof CallLogic) || node instanceof CallLogic) {
             tsErrorDetail.message = '调用逻辑：参数不能为空！';
-        } else if (node instanceof ProcessOutcome) {
+        } else if (node instanceof ProcessOutcome || node instanceof Function) {
             tsErrorDetail.message = (node as any).constructor.nodeTitle + '：不能为空！';
         } else if (node instanceof Argument || node instanceof TypeAnnotation) {
             let str = tsErrorDetail.message;