@lcap/nasl 3.4.0-beta.3 → 3.4.0-beta.4

package/src/generator/genReleaseBody.ts

@@ -107,10 +107,10 @@ async function getCalllogicData(app: App, releaseData: ReleaseData) {
       return {};
     }
 
-    nasl.traverseChildren((node) => {
+    nasl.traverseStrictChildren((node) => {
       if (
-          node.concept === 'CallLogic' &&
           'uuid' in node &&
+          node.concept === 'CallLogic' &&
           node.validation &&
           map.has(node.uuid)
       ) {
@@ -157,8 +157,12 @@ async function getCalllogicData(app: App, releaseData: ReleaseData) {
     ];
 
     // 获取所有调用加密函数的调用节点 uuid
-    nasl.traverseChildren((node) => {
-      if (node.concept !== 'CallLogic' || !('uuid' in node)) {
+    nasl.traverseStrictChildren((node) => {
+      if (
+        !('uuid' in node) ||
+        !('concept' in node) ||
+        node.concept !== 'CallLogic'
+      ) {
         return;
       }
       const calledLogicPath = `${node.calleeNamespace}.${node.calleeName}`;

package/src/generator/icestark.ts

@@ -1,5 +1,5 @@
 export default `
-    if(window.ICESTARK?.root) {
+    if(window.ICESTARK && window.ICESTARK.root) {
         Object.assign(window.ICESTARK, {
             appEnter({ container, customProps  }) {
                 window.LcapMicro = window.LcapMicro || {};
@@ -34,7 +34,9 @@ export default `
             },
             appLeave({ container }) {
                 container.innerHTML = null;
-                window.appVM?.$destroy();
+                if (window.appVM) {
+                    window.appVM.$destroy();
+                }
                 document.querySelectorAll('script.lazyload').forEach((ele) => {
                     ele.active = false;
                 });

package/src/generator/qiankun.ts

@@ -37,7 +37,9 @@ export default `
             },
             unmount({ container }) {
                 window.LcapMicro.container.innerHTML = null;
-                window.appVM?.$destroy();
+                if(window.appVM){
+                    window.appVM.$destroy();
+                }
                 document.querySelectorAll('script.lazyload').forEach((ele) => {
                     ele.active = false;
                 })

package/src/natural/genNaturalTS.ts

@@ -3,13 +3,13 @@ import { shiftState, createCompilerState } from '../translator';
 
 import naslStdlibMap from './naslStdlibMap';
 
-export function genNaturalTS(app: App, currentNode?: BaseNode) {
+export function genNaturalTS(app: App, currentNode?: BaseNode, focusedNodePath?: string) {
   const logic = currentNode as Logic;
-  const code = logic?.toNaturalTS(undefined);
+  const code = logic?.toNaturalTS(createCompilerState('', { focusedNodePath }), undefined, undefined, currentNode);
   return code;
 }
 
-export function genNaturalTSContext(app: App, currentNode?: BaseNode) {
+export function genNaturalTSContext(app: App, currentNode?: BaseNode, focusedNodePath?: string) {
   let code = `### 低代码应用的 ts 上下文定义如下：\n`;
   /* 标准库 */
   code += `\`\`\`ts\n`;
@@ -81,10 +81,9 @@ export function genNaturalTSContext(app: App, currentNode?: BaseNode) {
   // code += '// 页面上下文\n';
   code += ``;
   if (view) { // 为页面中的逻辑
-    console.log("lemon ~ genNaturalTSContext ~ view:", view)
-    code += view?.toNaturalTS(undefined, currentNode);
+    code += view?.toNaturalTS(createCompilerState('', { focusedNodePath }), currentNode);
   } else if (logic) { // 为全局逻辑
-    code += logic?.toNaturalTS(undefined, undefined, undefined, currentNode);
+    code += logic?.toNaturalTS(createCompilerState('', { focusedNodePath }), undefined, undefined, currentNode);
   }
   code += `\n\`\`\`\n`;
   return code;

package/src/natural/transformTSCode.ts

@@ -223,11 +223,16 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
     return node;
   }
 
+  function isPageLogic(logicName: string) {
+    return logicName.includes('on_') || logicName.includes('viewLogic_');
+  }
+
   function transformLogicNode(node: babelTypes.Node, typeAnnotation?: naslTypes.TypeAnnotation): naslTypes.LogicItem {
     fixLogicNode(node);
     // console.log('lemon ~~~ node--1:', node);
     if (node.type === 'VariableDeclaration') { // 拆成局部变量和赋值
       const declList = node?.declarations || [];
+      let newNode;
       declList?.forEach((decl) => {
         const variableName = (decl.id as babelTypes.Identifier).name;
         if (!logic.variables.find((variable) => variable.name === variableName)) {
@@ -242,16 +247,16 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
             if (type === 'expression') {
               return transformLogicNode(decl.init);
             }
-            const item = new naslTypes.Assignment({
+            newNode = new naslTypes.Assignment({
               left: new naslTypes.Identifier({
                 name: variableName,
               }),
               right: transformLogicNode(decl.init),
             });
-            item && logic.body.push(item);
           }
         }
       });
+      if (newNode) return newNode;
     } else if (node.type === 'CallExpression') {
       const callee = flatMemberExpression(node.callee);
       const calleeName = generate(node.callee as any).code;
@@ -276,13 +281,15 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         });
       }
       if (calleeName === 'nasl.oql.query') {
-        return new naslTypes.OqlQueryComponent({
-          dataSource: 'app.dataSources.defaultDS',
-          code: generate(node.arguments[0] as any).code.trim().slice(1, -1),
-        });
+        if (!isPageLogic(contextLogicName)) {
+          return new naslTypes.OqlQueryComponent({
+            dataSource: 'app.dataSources.defaultDS',
+            code: generate(node.arguments[0] as any).code.trim().slice(1, -1),
+          });
+        }
       }
       if (calleeName === 'nasl.util.consoleLog' || calleeName === 'console.log') {
-        if (contextLogicName.includes('on_') || contextLogicName.includes('viewLogic_')) {
+        if (isPageLogic(contextLogicName)) {
           return new naslTypes.CallLogic({
             calleeNamespace: 'nasl.util',
             calleeName: 'consoleLog',
@@ -326,9 +333,9 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         }
 
         let typeNamespace: string;
-        if (argument?.[argument.length - 1]?.type === 'ObjectExpression') {
-          typeNamespace = argument.splice(-1)[0].properties[0].value.value;
-        }
+        // if (argument?.[argument.length - 1]?.type === 'ObjectExpression') {
+          // typeNamespace = argument.splice(-1)[0].properties[0].value.value;
+        // }
         const nodeElement = new naslTypes.CallFunction({
           calleeNamespace: 'nasl.util',
           calleeName: curCalleeName,
@@ -337,7 +344,6 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
             keyword: `str${index + 1}`,
           })) as naslTypes.Argument[],
           typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType, typeNamespace })),
-
         });
         // console.log('lemon ~ callFunction ~ 3:', nodeElement);
         return nodeElement;
@@ -370,6 +376,17 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           })) as naslTypes.Argument[],
         });
       }
+      if (calleeName.endsWith('.map')) {
+        return new naslTypes.CallFunction({
+          calleeNamespace: 'nasl.util',
+          calleeName: 'ListTransform',
+          arguments: [new naslTypes.Argument({
+            expression: transformLogicNode((node.callee as babelTypes.MemberExpression).object),
+          }), ...node.arguments.map((arg: any) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          }))],
+        });
+      }
       if (calleeName === 'ForEach') {
         const newCallee = node.arguments;
         const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
@@ -378,7 +395,9 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           start: transformLogicNode(newCallee[1]),
           end: transformLogicNode(newCallee[2]),
           item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
-          index: transformParam(arrowFunction.params[1] as babelTypes.Identifier),
+          index: arrowFunction.params[1] ? transformParam(arrowFunction.params[1] as babelTypes.Identifier) : new naslTypes.Param({
+            name: 'index', typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Long'),
+          }),
           body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
         });
         return nodeElement;
@@ -393,7 +412,9 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
             start: transformLogicNode(newCallee?.arguments?.[0]),
             end: transformLogicNode(newCallee?.arguments?.[1]),
             item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
-            index: transformParam(arrowFunction.params[1] as babelTypes.Identifier),
+            index: arrowFunction.params[1] ? transformParam(arrowFunction.params[1] as babelTypes.Identifier) : new naslTypes.Param({
+              name: 'index', typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Long'),
+            }),
             body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
           });
           return nodeElement;
@@ -716,6 +737,25 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       });
     } else if (node.type === 'BlockStatement') {
       return transformLogicNode(node?.body?.[0]);
+    } else if (node.type === 'ObjectExpression' && node?.properties?.length > 0) {
+      const properties: any = [];
+      const rights: any = [];
+      const structureProperties: any = [];
+      node?.properties?.forEach((arg: any) => {
+        properties.push(transformLogicNode(arg.key));
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformLogicNode(arg.value)
+        }));
+        structureProperties.push(new naslTypes.StructureProperty({
+          name: arg?.key?.name,
+          typeAnnotation: null
+        }));
+      });
+      return new naslTypes.NewComposite({
+        typeAnnotation: naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
+        properties,
+        rights,
+      });
     } else {
       console.error(node);
       if (debug) {

package/src/sentry/index.ts

@@ -142,13 +142,15 @@ export const sentryMonitor: Monitor = (key) => (SourceClass) => {
     constructor(...params: any[]) {
       super(...params);
 
-      fireListeners(key)({
+      const effect = fireListeners(key)({
         hook: CONSTRUCTOR_HOOK,
         name: 'constructor',
         instance: this,
         result: this,
         params,
       });
+
+      effect && effect();
     }
   }
 

package/src/server/extendBaseNode.ts

@@ -130,9 +130,28 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
     if (res.length <= 1) {
       if (this.concept === 'enumItem') {
         (this as any).setValue(newValue);
+      } else if (['Process', 'ProcessElement'].includes(this.concept)) {
+        const confirmParms: any = {
+          actionType: 'rename',
+          node: this,
+          newValue,
+          unReference: true,
+          icon: 'warning',
+        };
+        if (this.concept === 'Process') {
+          confirmParms.title = '重命名流程名称';
+          confirmParms.process = true;
+        } else if (this.concept === 'ProcessElement') {
+          confirmParms.title = '修改节点名称'
+          confirmParms.process = true;
+        }
+        const callback = () => {
+          (this as SetNameNode).setName(newValue);
+        }
+        invokeCommand('tsConfirm.open', confirmParms, callback)
       } else (this as SetNameNode).setName(newValue);
     } else {
-      const callback = (value: boolean) => {
+      const callback = (value: boolean, toast?: Function) => {
         if (value) {
           const App = this.rootNode;
           // 收集修改
@@ -168,15 +187,24 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
           });
           // 结束修改 ，批量操作
           App.emit('collect:end');
+          toast && toast();
         } else {
           (this as SetNameNode).setName(newValue);
         }
       };
-      const confirmParms = {
+      const confirmParms: any = {
         actionType: 'rename',
         node: this,
         newValue,
+        icon: 'warning',
       };
+      if (this.concept === 'Process') {
+        confirmParms.title = '重命名流程名称';
+        confirmParms.process = true;
+      } else if (this.concept === 'ProcessElement') {
+        confirmParms.title = '修改节点名称'
+        confirmParms.process = true;
+      }
       /**
        * nasl和vue的通信，回退，要触发vue的watch。
        * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值

package/src/server/naslServer.ts

@@ -79,11 +79,13 @@ import {
   CallAuthInterface,
   Connector,
   AuthInterface,
+  SyntaxNode,
   Connection,
   TriggerLauncher,
   CallConnector,
   DefaultValue,
   I18nInfo,
+  InterfaceFromExample,
 } from '../concepts';
 
 import { lsp2tspNumber, SourceMap, SourceMapItem, isSameRange } from '../translator';
@@ -491,8 +493,15 @@ class NaslServer {
       });
     });
 
-    module?.interfaces?.forEach((_interface) => {
+    module?.interfaces?.forEach((_itf) => {
       try {
+        // interface 接口可能为 InterfaceFromExample 类型，因此这里需要做兼容
+        let _interface: Interface;
+        if (_itf instanceof InterfaceFromExample) {
+          _interface = _itf.inter as Interface;
+        } else {
+          _interface = _itf;
+        }
         const result = _interface.toEmbeddedTSFile();
         results.push(result);
         // sourceMap都存在目录级别内容下，在页面层级下去找
@@ -666,8 +675,8 @@ class NaslServer {
     await this.writeFiles(files);
     this._debugInFileStorage(app, files);
     // 修改名称回调
-    registerCommand('tsRename.change', (value: boolean, callback: Function) => {
-      callback(value);
+    registerCommand('tsRename.change', (value: boolean, callback: Function, toast?: Function) => {
+      callback(value, toast);
     });
     // 删除回调
     registerCommand('tsDelete.change', (callback: Function) => {
@@ -2217,6 +2226,41 @@ class NaslServer {
       fileNode?.sourceMap.forEach((value, node) => {
         this.checkNodeError(node, diagnostics);
       });
+    } else if (fileNode instanceof Connection) {
+      const connectorPropertyNames = NaslServer.getPropertyNames(fileNode);
+      const connectionPropertyNames = NaslServer.getPropertyNames(fileNode?.connector);
+      const diagnostic = {
+        node: fileNode,
+        severity: 'error',
+        message: `连接器 ${fileNode.name} 参数配置缺失`,
+        // 保留原来的内容方便查询一些问题
+        originalDiagnostic: {
+          fileName: '',
+          start: <any>null,
+          end: <any>null,
+          category: 'error',
+          text: `Connection configuration is empty`,
+        },
+      };
+      // Connector Connection 配置项是否相同
+      const isSameConfig = connectorPropertyNames.filter((x) => !connectionPropertyNames.includes(x)).length === 0;
+      // Connection 配置项是否有空值
+      const hasEmptyConfig = (c: Connection) => {
+        return c.properties.findIndex((configProperty) => {
+          return configProperty.values.find((configPropertyValue) => {
+            return configPropertyValue.value === '';
+          })
+        }) > -1;
+      }
+
+      if (connectorPropertyNames.length !== connectionPropertyNames.length) {
+        diagnostics.push(diagnostic);
+      } else if (!isSameConfig) {
+        diagnostics.push(diagnostic);
+      } else if (hasEmptyConfig(fileNode)) {
+        diagnostics.push(diagnostic);
+      }
+      
     }
     return diagnostics;
   }
@@ -2663,24 +2707,70 @@ class NaslServer {
         offset: lsp2tspNumber(currentSource.start.character),
       });
       refsList = [...newRefs.refs];
-    } else if (node instanceof Module) {
-        const lists = node.logics || node.structures || node.enums;
-        const moduleName = (fileNode as FileNode).getEmbeddedFilePath();
-        if (lists.length) {
-          const item = lists[0];
-          const { fileNode } = this.getCurrentSource(item);
-          if (fileNode) {
-            const newRefs = await this.references({
-              file: (fileNode as FileNode).getEmbeddedFilePath(),
-              line: 1,
-              offset: 22, // 固定的位置，module的位置信息
-            });
-            refsList = newRefs.refs.filter((item) => !item.file.startsWith(moduleName));
-            // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
-            refsList.unshift(newRefs.refs[0]);
-          }
+    } else if (node instanceof Module && !(node instanceof Connector)) {
+      const lists = node.logics || node.structures || node.enums;
+      const moduleName = (fileNode as FileNode).getEmbeddedFilePath();
+      if (lists.length) {
+        const item = lists[0];
+        const { fileNode } = this.getCurrentSource(item);
+        if (fileNode) {
+          const newRefs = await this.references({
+            file: (fileNode as FileNode).getEmbeddedFilePath(),
+            line: 1,
+            offset: 22, // 固定的位置，module的位置信息
+          });
+          refsList = newRefs.refs.filter((item) => !item.file.startsWith(moduleName));
+          // 多塞一个 ，删除的时候就有值了， 上面过滤了之后可能是空的
+          refsList.unshift(newRefs.refs[0]);
+        }
+      }
+    } else if (node instanceof Connector) { 
+      // Conenctor 虽为 Module 的子类，但是具体引用逻辑与Module 并不一致，因此这边单独处理
+      // 由于 在与后端定义 Connector Namespace 前缀时， Logics 相关定义为 connector,
+      // 其余定义为 extension, 因此这边查找引用时，需要分别查找并去重复
+      // 这里选择 logic 与 interface 作为 查找源，因为一个 Connector 必定至少含有一个 logic 和 interface  
+      const logicList = node.namespaces.find((ns) => ns.logics.length > 0)?.logics || [];
+      const interfaceList = node.interfaces;
+      const moduleName = (fileNode as FileNode).getEmbeddedFilePath();
+      const appName = node.rootNode.name; // 获取rootNode的name，用于过滤引用
+      if (logicList.length) {
+        const item = logicList[0];
+        const { fileNode } = this.getCurrentSource(item);
+        if (fileNode) {
+          const newRefs = await this.references({
+            file: (fileNode as FileNode).getEmbeddedFilePath(),
+            line: 1,
+            offset: 21, // 固定的位置， connector 前缀下 Connector 的位置信息
+          });
+          refsList = [...newRefs.refs];
+        }
+      }
+      if (interfaceList.length) {
+        const item = interfaceList[0];
+        const { fileNode } = this.getCurrentSource(item);
+        if (fileNode) {
+          const newRefs = await this.references({
+            file: (fileNode as FileNode).getEmbeddedFilePath(),
+            line: 1,
+            offset: 22, // 固定的位置， extension 前缀下 Connector 的位置信息
+          });
+          refsList = [...refsList, ...newRefs.refs];
         }
       }
+      // 根据 moduleName 中是否存在 dependencies 来判断是否为稳定态的Connector
+      const isStable = moduleName.includes(`/embedded/${appName}/dependencies`);
+      // 根据 item 的 file 去重
+      refsList = refsList.filter((item, index, arr) => {
+        const tempStable = item.file.includes(`/embedded/${appName}/dependencies`); // 约定
+        const isGlobalLogic = item.file.includes(`/embedded/${appName}/logics`); // 约定
+        // 关于 isGlobalLogic 单独判断的说明：
+        // 全局逻辑与Connector 有直接关联的只有两种情况
+        // 1. 全局逻辑通过 CallConnector 调用 Connector 中的方法，此时被 logicList 处查找的引用所检索
+        // 2. 全局逻辑中参类型赋值为 Connector 中某一 structure ，此时被 interfaceList 处查找的引用所检索
+        // 综上所述，检索到的全局逻辑相关一定是唯一的，且不重复的
+        return isGlobalLogic || (isStable ? tempStable : !tempStable) // 稳定态的Connector 只能引用稳定态的Connector
+      });
+    }
 
     // 如果是DataSource就需要在单独，查一边来修改名字
     if (node instanceof DataSource) {
@@ -3686,10 +3776,12 @@ class NaslServer {
       !sourceMap &&
       fileNode &&
       !(fileNode.parentNode instanceof App) &&
+      !(fileNode.parentNode instanceof Integration) &&
       !(fileNode.parentNode instanceof Module) &&
       !(fileNode.parentNode instanceof DataSource) &&
       !(fileNode.parentNode instanceof Frontend) &&
       !(fileNode.parentNode instanceof Backend) &&
+      !(fileNode.parentNode instanceof Namespace) &&
       !(fileNode instanceof View) &&
       !(fileNode instanceof ConfigProperty)
     ) {
@@ -3989,9 +4081,22 @@ class NaslServer {
           newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
           fileDetail.offset = newCode.length + 'return '.length;
         } else if (['NewComposite', 'NewList', 'NewMap'].includes(node.concept)) {
+          let type;
+          switch (node.concept) {
+            case 'NewComposite':
+              type = '__newComposite';
+              break;
+            case 'NewList':
+              type = '__newList';
+              break;
+            case 'NewMap':
+              type = '__newMap';
+              break;
+            default:
+          }
           const code = getCode(item);
           fileDetail.line = item.end.line;
-          const indexOf = code.indexOf('return __newComposite');
+          const indexOf = code.indexOf(`return ${type}`);
           let newCode = code.substring(0, indexOf);
           newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
           fileDetail.offset = newCode.length + 'return '.length;
@@ -4086,7 +4191,7 @@ class NaslServer {
     const nodes: QuickInfoNodes = [];
     this.file2NodeMap.forEach((fileNode, filePath) => {
       // 先不排除view，传递给后端的时候，去除views下的标注
-      if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
+      if (!['DataSource','Enum', 'Role'].includes(fileNode.concept)) {
         fileNode.sourceMap.forEach((item, node) => {
           nodes.push({
             filePath,
@@ -4691,7 +4796,8 @@ class NaslServer {
     if (process.env.NODE_ENV === 'development') {
       console.time('重新生成 TS 文件');
     }
-    const result = (fileNode as FileNode).toEmbeddedTSFile();
+    // 部分节点如 Namespace 可能不存在对应的方法
+    const result = (fileNode as FileNode)?.toEmbeddedTSFile();
     if (process.env.NODE_ENV === 'development') {
       console.timeEnd('重新生成 TS 文件');
       console.log('重新生成 TS 文件', (fileNode as FileNode).getEmbeddedFilePath());
@@ -4752,6 +4858,20 @@ class NaslServer {
     }
   }
 
+  /**
+   * 获取 Connector 对应 Connector 的properties
+   */
+  static getPropertyNames(fileNode: Connection|Connector) {
+    const names: string[] = [];
+    // TODO 如果不存在对应的 Connector 时，应该提示错误
+    if (fileNode) {
+      fileNode.properties.forEach((property) => {
+        names.push(property.name);
+      });
+    }
+    return names;
+  }
+
   private getNodeCode(fileNode: BaseNode, range: SourceMapItem) {
     return (this.tsFiles.get((fileNode as any).getEmbeddedFilePath()) ?? '').slice(range.start.offset, range.end.offset)
   }

package/src/server/translator.ts

@@ -33,7 +33,6 @@ import {
   CallInterface,
   Return,
   ProcessElement,
-  NullLiteral,
   SwitchCase,
   WhileStatement,
   IfStatement,
@@ -41,6 +40,7 @@ import {
   ForEachStatement,
   CallFunction,
   ProcessOutcome,
+  ProcessOutcomes,
   Function,
   Anchor,
   BatchAssignment,
@@ -573,6 +573,15 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
       }
     } else if (node.parentNode instanceof NewList && text.includes(`parameter of type 'never'`)) {
       tsErrorDetail.message = '自动推导不出类型！newList中有未知类型';
+    } else if (node instanceof ProcessOutcome || node instanceof ProcessOutcomes) {
+      const cap = /Argument of type '(.+?)' is not assignable to parameter of type '(.+?)'/.exec(text);
+      const selectComes = cap[1].split(' | ');
+      const currentComes = cap[2].split(' | ');
+      if (node instanceof ProcessOutcome) {
+        tsErrorDetail.message = `流向出口不存在，${selectComes.map((item) => item).join(',')}出口流不属于[${currentComes.map((item) => item).join(',')}]当中的某个流`
+      } else {
+        tsErrorDetail.message = `流向出口不存在，${selectComes.map((item) => item).join(',')}有错误的出口流`
+      }
     }
   }
   if (node instanceof Argument || node instanceof Anchor) {
@@ -806,6 +815,9 @@ export function checkAStructure_(errorText: string) {
     ) {
       const x = sortTsString(transformType(cap[1]));
       const y = sortTsString(transformType(cap[2]));
+      if (x === null || y === null) {
+        return;
+      }
       if (x === y) {
         return true;
       } else if (mapAstString.get(x) === y || mapAstString.get(y) === x) {

package/src/service/storage/jsoner.ts

@@ -69,9 +69,9 @@ export async function batchQuery(json: any, queryList: Array<Query>) {
         if (node) {
             if (Array.isArray(node)) {
                 return node.map((nodeItem) => excludeProperties(nodeItem, excludes));
-            } else {
+            } 
                 return excludeProperties(node, excludes);
-            }
+            
         }
         return null;
     });

package/src/translator/types.ts

@@ -37,4 +37,5 @@ export interface TranslatorState {
   preferQuote?: 'single' | 'double' | 'backtick';
   sourceMap?: SourceMap;
   finalCode?: boolean;
+  focusedNodePath?: string;
 }

package/src/translator/utils.ts

@@ -59,6 +59,7 @@ export function isSameRange(rangeA: Range, rangeB : Range) {
 export function withSourceMap() {
   return function handleAction(target: any, key: string | number | symbol, descriptor: PropertyDescriptor) {
     const oldMethod = descriptor.value;
+    const isNatural = oldMethod.name === 'toNaturalTS';
 
     descriptor.value = function (this: BaseNode, state?: TranslatorState, ...args: any[]) {
       // 重新生成ts代码就先把类型清除掉
@@ -85,6 +86,20 @@ export function withSourceMap() {
           });
         }
 
+        if (isNatural && state.focusedNodePath) {
+          const needAddComment = this.nodePath === state.focusedNodePath;
+          // if (!needAddComment) {
+          //   const parts = state.focusedNodePath.split('.');
+          //   const lastPart = parts.pop();
+          // }
+          if (needAddComment) {
+            const beforeComment = `// 当前位置\n${before}`;
+            before += beforeComment;
+            state = shiftState(state, beforeComment);
+          }
+
+        }
+
         // 调用真实方法, 可能有剩余参数
         const code = oldMethod.call(this, state, ...args);
 

package/src/utils/sortTsString.ts

@@ -5,10 +5,15 @@ const t = require('@babel/types');
 
 export function sortTsString(tsString: string): string {
   const str = `type a = ${tsString}`;
-  const ast = babel.parseSync(str, {
-    filename: 'result.ts',
-    presets: [require('@babel/preset-typescript')],
-  });
+  let ast;
+  try {
+    ast = babel.parseSync(str, {
+      filename: 'result.ts',
+      presets: [require('@babel/preset-typescript')],
+    });
+  } catch (error) {
+    return null
+  }
   const visitor = {
     TSTypeLiteral(path: any) {
       path.node.members.sort((a: any, b: any) => {