@lcap/nasl 3.8.2-beta.9 → 3.8.3-beta.2

package/src/natural/transformTSCode.ts

@@ -1,1050 +1,29 @@
 /* eslint-disable global-require */
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import * as babel from '@babel/core';
-import * as babelTypes from '@babel/types';
-import generate from '@babel/generator';
-import * as naslTypes from '../concepts';
+import { babelTypes, naslTypes, generate, DEBUG, throwError, tryParseTS } from './transforms/utils';
+import { transform2LogicItem, transform2Param } from './transforms/transform2LogicItem';
 
-const DEBUG = false;
-function throwError(message: string) {
-  if (DEBUG) throw new Error(message);
-  else console.error(message);
+function isPageLogic(logicName: string) {
+  return logicName.includes('on_') || logicName.includes('viewLogic_') || logicName.includes('businessLogic_');
 }
 
-export function tryParseTS(tsCode: string) {
-  try {
-    const root = babel.parseSync(tsCode, {
-      filename: 'result.ts',
-      presets: [require('@babel/preset-typescript')],
-    });
-    // console.log((root as any).program.body[0].body.body.map((item) => item.trailingComments));
-    return root;
-  } catch (e) {
-    return null;
-  }
-}
-
-function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
-  if (node.type === 'MemberExpression')
-    return [...flatMemberExpression(node.object), node.property];
-  return [node];
-}
-
-function flatMembers(node: naslTypes.MemberExpression): Array<naslTypes.MemberExpression> {
-  if (node.concept === 'MemberExpression')
-    return [...flatMembers(((node as any)?.object)), node];
-  return [];
-}
-
-function flatMatchPatternsExpression(node: any): Array<babelTypes.Node> {
-  if (node.concept === 'BinaryExpression') {
-    if (node.operator === '||') {
-      return [...flatMatchPatternsExpression(node.left), ...flatMatchPatternsExpression(node.right)];
-    }
-    if (node.operator === '==') {
-      return [node.right];
-    }
-    return [node];
-  }
-  return [node];
-}
-
-function flatIfStatement(node: any): Array<babelTypes.Node> {
-  if (node.alternate.type === 'IfStatement') {
-    return [...flatIfStatement(node.alternate), node];
-  }
-  return [node];
-}
-
-/**
- * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
- * @param node
- * @returns
- */
-function fixLogicNode(node: babelTypes.Node): void {
-  if (node?.type === 'CallExpression') {
-    const calleeName = generate(node.callee as any).code;
-    if (calleeName === 'nasl.util.ForEach') {
-      const callee = flatMemberExpression(node.callee);
-      node.callee = callee[2] as babelTypes.Identifier;
-    }
-  }
-}
-
-
-export function transformTSCode(tsCode: string, contextLogicName: string, type?: string) {
-  const logic = new naslTypes.Logic();
-  logic.body = [];
-
-  function transformTypeAnnotation(node: babelTypes.TSType): naslTypes.TypeAnnotation {
-    if (!node) return null;
-    if (node.type === 'TSTypeReference') {
-      const typeName = (node.typeName as babelTypes.Identifier).name;
-      const primitiveType = naslTypes.primitiveTypeList.find((ta) => ta.typeName === typeName);
-      if ((node as any)?.typeNamespace) {
-        return naslTypes.TypeAnnotation.createReference(typeName, {
-          typeNamespace: (node as any).typeNamespace,
-        });
-      }
-
-      if (['ValidateResult', 'ValidateEvent'].includes(typeName)) {
-        return naslTypes.TypeAnnotation.createReference(typeName, {
-          typeNamespace: 'nasl.ui'
-        });
-      }
-
-      if (typeName === 'Any' || typeName === 'any') {
-        return undefined;
-      }
-      if (typeName === 'Integer') {
-        return naslTypes.TypeAnnotation.createPrimitive('Long');
-      }
-      if (primitiveType) {
-        return naslTypes.TypeAnnotation.createPrimitive(typeName);
-      }
-      if (['List', 'Map', 'Current'].includes(typeName) && node?.typeParameters) {
-        return naslTypes.TypeAnnotation.createGeneric(typeName, {
-          typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
-        });
-      }
-      if (node?.typeName?.type === 'TSQualifiedName' && node?.typeParameters) {
-        const curTypeName = (node?.typeName as any)?.right?.name;
-        return naslTypes.TypeAnnotation.createGeneric(curTypeName, {
-          typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
-        });
-      }
-      if (!node.typeParameters) {
-        if (node?.typeName?.type === 'TSQualifiedName') {
-          const allTypeName = generate(node?.typeName?.left as any)?.code;
-          // 实体、枚举、结构体
-          if (/^app.dataSources|.enums|.structures|nasl.ui/.test(allTypeName)) {
-            const curTypeName = (node?.typeName as any)?.right?.name;
-            return naslTypes.TypeAnnotation.createReference(curTypeName, {
-              typeNamespace: allTypeName,
-            });
-          }
-        }
-        return naslTypes.TypeAnnotation.createReference(typeName, {
-          typeNamespace: null,
-        });
-      }
-      throwError(`Unhandled node ${node.type}`);
-    } else if (node.type === 'TSTypeLiteral') {
-      return naslTypes.TypeAnnotation.createTypeAnonymousStructure(node.members.map((member: babelTypes.TSPropertySignature) => new naslTypes.StructureProperty({
-        name: (member.key as babelTypes.Identifier).name,
-        typeAnnotation: transformTypeAnnotation(member.typeAnnotation.typeAnnotation),
-      })));
-    } else if (node.type === 'TSBooleanKeyword') {
-      return naslTypes.TypeAnnotation.createPrimitive('Boolean');
-    } else if (node.type === 'TSStringKeyword') {
-      return naslTypes.TypeAnnotation.createPrimitive('String');
-    } else if (node.type === 'TSNumberKeyword') {
-      return naslTypes.TypeAnnotation.createPrimitive('Double');
-    } else if (node.type === 'TSUnionType') {
-      const union = naslTypes.TypeAnnotation.createPrimitive('Union');
-      union.typeArguments = [];
-      node.types.forEach((curType) => {
-        union.typeArguments.push(transformTypeAnnotation(curType));
-      });
-      return union;
+export function transformTSCode(tsCode: string, contextLogicName?: string) {
+  if (!contextLogicName) {
+    const functionRE = /function\s+(\w+)\s*\(/;
+    const cap = tsCode.match(functionRE);
+    if (cap) {
+      contextLogicName = cap[1];
     } else {
-      throwError(`Unhandled node ${node.type}`);
+      throwError('无法解析函数名');
     }
   }
-  function transformParam(node: babelTypes.Identifier): naslTypes.Param {
-    const typeAnnotation = (node.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
-    const exclude = ['event'];
-    if (exclude.includes(node.name)) return null;
-    return new naslTypes.Param({
-      name: node.name,
-      typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
-    });
-  }
-  function pushElseIf(ifNode: babelTypes.IfStatement, switchStatement: naslTypes.SwitchStatement) {
-    switchStatement.cases.push(new naslTypes.SwitchCase({
-      test: transformLogicNode(ifNode.test),
-      consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-    }));
-    if (ifNode.alternate && ifNode.alternate.type === 'IfStatement') {
-      pushElseIf(ifNode.alternate, switchStatement);
-    } else {
-      switchStatement.cases.push(new naslTypes.SwitchCase({
-        test: undefined,
-        consequent: !ifNode?.alternate ? [] : (ifNode?.alternate as babelTypes.BlockStatement)?.body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-      }));
-    }
-  }
-
-  function handleBinaryExpression(calleeName: String, argument: any) {
-    const map: Record<'plus' | 'minus' | 'multiply' | 'divide' | 'remainder', '+' | '-' | '*' | '/' | '%'> = {
-      plus: '+',
-      minus: '-',
-      multiply: '*',
-      divide: '/',
-      remainder: '%',
-    };
-    return new naslTypes.BinaryExpression({
-      operator: map?.[calleeName as keyof typeof map],
-      left: transformLogicNode(argument?.[0]),
-      right: transformLogicNode(argument?.[1]),
-    });
-  }
-
-  function handleNewExpression(calleeName: String, node: any) {
-    if (calleeName === 'NewList') {
-      return new naslTypes.NewList({
-        typeAnnotation: naslTypes.TypeAnnotation.createGeneric('List', {
-          typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
-        }),
-        items: node?.arguments?.[0]?.elements?.map((arg: any) => transformLogicNode(arg)),
-      });
-    }
-    if (calleeName === 'NewMap') {
-      const keys: any = [];
-      const values: any = [];
-      node?.arguments?.[0]?.properties.forEach((arg: any) => {
-        keys.push(transformLogicNode(arg.key));
-        values.push(transformLogicNode(arg.value));
-      });
-      return new naslTypes.NewMap({
-        typeAnnotation: naslTypes.TypeAnnotation.createGeneric('Map', {
-          typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
-        }),
-        keys,
-        values,
-      });
-    }
-    if (calleeName === 'NewEntity') {
-      const properties: any = [];
-      const rights: any = [];
-      const assignmentLines: any = [];
-      node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
-        properties.push(transformLogicNode(arg.key));
-        if (arg.value.type === 'MemberExpression') {
-          const expression = flatMemberExpression(arg.value);
-          const members = flatMembers(transformLogicNode(arg.value) as any);
-          rights.push(new naslTypes.SelectMembers({
-            expression: transformLogicNode(expression[0]),
-            members,
-          }));
-          if (arg?.value) {
-            assignmentLines.push(new naslTypes.AssignmentLine({
-              leftIndex: [0, index],
-              rightIndex: [index, members.length - 1],
-            }));
-          }
-        } else {
-          rights.push(new naslTypes.SelectMembers({
-            expression: transformLogicNode(arg.value)
-          }));
-          if (arg?.value) {
-            assignmentLines.push(new naslTypes.AssignmentLine({
-              leftIndex: [0, index],
-              rightIndex: [index],
-            }));
-          }
-        }
-      });
-      const parameters = node?.typeParameters?.params?.[0] || {};
-      if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
-        const { left, right } = parameters?.typeName || {};
-        const typeNamespace = generate(left as any)?.code;
-        const typeName = right?.name;
-        return new naslTypes.NewComposite({
-          typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
-            typeNamespace,
-            typeName
-          }),
-          properties,
-          rights,
-          assignmentLines
-        });
-      }
-      const typeName = parameters?.typeName?.name;
-      return new naslTypes.NewComposite({
-        typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
-          typeNamespace: 'app.dataSources.defaultDS.entities',
-          typeName
-        }),
-        properties,
-        rights,
-        assignmentLines
-      });
-    }
-    if (calleeName === 'NewStructure') {
-      const properties: any = [];
-      const rights: any = [];
-      const assignmentLines: any = [];
-      node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
-        properties.push(transformLogicNode(arg.key));
-        if (arg.value.type === 'MemberExpression') {
-          const expression = flatMemberExpression(arg.value);
-          const members = flatMembers(transformLogicNode(arg.value) as any);
-          rights.push(new naslTypes.SelectMembers({
-            expression: transformLogicNode(expression[0]),
-            members,
-          }));
-          if (arg?.value) {
-            assignmentLines.push(new naslTypes.AssignmentLine({
-              leftIndex: [0, index],
-              rightIndex: [index, members.length - 1],
-            }));
-          }
-        } else {
-          rights.push(new naslTypes.SelectMembers({
-            expression: transformLogicNode(arg.value)
-          }));
-          if (arg?.value) {
-            assignmentLines.push(new naslTypes.AssignmentLine({
-              leftIndex: [0, index],
-              rightIndex: [index],
-            }));
-          }
-        }
-      });
-      const parameters = node?.typeParameters?.params?.[0] || {};
-      if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
-        const { left, right } = parameters?.typeName || {};
-        const typeNamespace = generate(left as any)?.code;
-        const typeName = right?.name;
-        return new naslTypes.NewComposite({
-          typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
-            typeNamespace,
-            typeName
-          }),
-          properties,
-          rights,
-          assignmentLines
-        });
-      }
-      const typeName = parameters?.typeName?.name;
-      return new naslTypes.NewComposite({
-        typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
-          typeNamespace: 'app.structures',
-          typeName
-        }),
-        properties,
-        rights,
-        assignmentLines
-      });
-    }
-    if (calleeName === 'NewAnonymousStructure') {
-      const properties: any = [];
-      const rights: any = [];
-      const structureProperties: any = [];
-      const assignmentLines: any = [];
-      node?.arguments?.[0]?.properties?.forEach((arg: any, index: number) => {
-        properties.push(transformLogicNode(arg.key));
-        if (arg.value.type === 'MemberExpression') {
-          const expression = flatMemberExpression(arg.value);
-          const members = flatMembers(transformLogicNode(arg.value) as any);
-          rights.push(new naslTypes.SelectMembers({
-            expression: transformLogicNode(expression[0]),
-            members,
-          }));
-          if (arg?.value) {
-            assignmentLines.push(new naslTypes.AssignmentLine({
-              leftIndex: [0, index],
-              rightIndex: [index, members.length - 1],
-            }));
-          }
-        } else {
-          rights.push(new naslTypes.SelectMembers({
-            expression: transformLogicNode(arg.value)
-          }));
-          if (arg?.value) {
-            assignmentLines.push(new naslTypes.AssignmentLine({
-              leftIndex: [0, index],
-              rightIndex: [index],
-            }));
-          }
-        }
-        structureProperties.push(new naslTypes.StructureProperty({
-          name: arg?.key?.name,
-          typeAnnotation: null
-        }));
-      });
-      return new naslTypes.NewComposite({
-        typeAnnotation: naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
-        properties,
-        rights,
-        assignmentLines
-      });
-    }
-    return node;
-  }
-
-  function isPageLogic(logicName: string) {
-    return logicName.includes('on_') || logicName.includes('viewLogic_') || logicName.includes('businessLogic_');
-  }
 
-  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)) {
-          const varTypeAnnotation = ((decl.id as babelTypes.Identifier).typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
-          logic.variables.push(new naslTypes.Variable({
-            name: variableName,
-            typeAnnotation: varTypeAnnotation && transformTypeAnnotation(varTypeAnnotation),
-          }));
-        }
-        if (decl.init) {
-          if (decl.init.type !== 'ArrayExpression' && decl.init.type !== 'ObjectExpression') {
-            const calleeName = generate((decl?.init as any)?.callee).code;
-            if (type === 'expression') {
-              return transformLogicNode(decl.init);
-            }
-            const varTypeAnnotation = ((decl?.id as babelTypes.Identifier)?.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
-            if (calleeName === 'nasl.oql.query' && varTypeAnnotation) {
-              (decl.init as any).typeAnnotations = varTypeAnnotation;
-            }
-            newNode = new naslTypes.Assignment({
-              left: new naslTypes.Identifier({
-                name: variableName,
-              }),
-              right: transformLogicNode(decl.init),
-            });
-          }
-        }
-      });
-      if (newNode) return newNode;
-    } else if (node.type === 'CallExpression' && node.callee.type === 'CallExpression') {
-      // (function match() {})(...) 的情况
-    } else if (node.type === 'CallExpression') {
-      const callee = flatMemberExpression(node.callee);
-      const calleeName = generate(node.callee as any).code;
-      // console.log('lemon ~~~ node--2', node, callee, calleeName);
-      if (/^\$refs\./.test(calleeName)) {
-        return new naslTypes.CallLogic({
-          calleeNamespace: `elements.${(callee[1] as babelTypes.Identifier).name}.logics`,
-          calleeName: (callee[2] as babelTypes.Identifier).name,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      }
-      if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
-        const entityName = callee[0].name.replace(/Entity$/, '');
-        return new naslTypes.CallLogic({
-          calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
-          calleeName: (callee[1] as babelTypes.Identifier).name,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      }
-      if (calleeName === 'nasl.oql.query') {
-        if (!isPageLogic(contextLogicName)) {
-          // const _typeAnnotation = node?.typeParameters?.params?.length > 0 ? naslTypes.TypeAnnotation.createGeneric('List', {
-          //   typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType })),
-          // }) : null;
-          let code = generate(node.arguments[0] as any).code.trim().slice(1, -1);
-          code = code?.replace(/app\.enums\.(\w+)\[(\d+)\]/g, "app.enums.$1.$2").replace(/app\.enums\.(\w+)\['(\w+)'\]/g, "app.enums.$1.$2");
-          return new naslTypes.OqlQueryComponent({
-            dataSource: 'app.dataSources.defaultDS',
-            code,
-            typeAnnotation: transformTypeAnnotation((node as any)?.typeAnnotations)
-          });
-        }
-      }
-      if (calleeName === 'nasl.util.consoleLog' || calleeName === 'console.log') {
-        if (isPageLogic(contextLogicName)) {
-          return new naslTypes.CallLogic({
-            calleeNamespace: 'nasl.util',
-            calleeName: 'consoleLog',
-            shortcut: true,
-            arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-              expression: transformLogicNode(arg),
-            })) as naslTypes.Argument[],
-          });
-        }
-        return new naslTypes.CallLogic({
-          calleeNamespace: 'nasl.logging',
-          calleeName: 'INFO',
-          shortcut: true,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      }
-      if (calleeName.startsWith('nasl.logging.')) {
-        return new naslTypes.CallLogic({
-          calleeNamespace: 'nasl.logging',
-          calleeName: (callee[2] as babelTypes.Identifier).name,
-          shortcut: true,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      }
-      if (calleeName === 'nasl.util.jsonSerialize' || calleeName === 'nasl.util.jsonDeserialize') {
-        const curCalleeName = (node.callee as any).property.name;
-        return new naslTypes.CallLogic({
-          calleeNamespace: 'nasl.util',
-          calleeName: curCalleeName,
-          shortcut: true,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-          typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType })),
-        });
-      };
-      if (calleeName.startsWith('nasl.util.')) {
-        let curCalleeName: string;
-        if (callee.length === 3)
-          curCalleeName = (callee[callee.length - 1] as babelTypes.Identifier).name;
-        else {
-          let _callee = (callee[0] as any).callee;
-          while (_callee.type === 'CallExpression')
-            _callee = _callee.callee;
-          curCalleeName = _callee.property.name;
-        }
-        const argument = callee.length === 3 ? node.arguments : (callee[0] as any).arguments as any;
-
-        if (['plus', 'minus', 'multiply', 'divide', 'remainder'].includes(curCalleeName)) {
-          return handleBinaryExpression(curCalleeName, argument);
-        };
-
-        if (['NewList', 'NewMap', 'NewEntity', 'NewStructure', 'NewAnonymousStructure'].includes(curCalleeName)) {
-          return handleNewExpression(curCalleeName, node);
-        }
-
-        // let typeNamespace: string;
-        // 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,
-          arguments: argument.map((arg: any, index: number) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-            keyword: `str${index + 1}`,
-          })) as naslTypes.Argument[],
-          typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
-          // typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType, typeNamespace })),
-        });
-        // console.log('lemon ~ callFunction ~ 3:', nodeElement);
-        return nodeElement;
-      }
-      if (callee.length === 3 && calleeName.startsWith('nasl.ui.')) {
-        if ((callee[2] as babelTypes.Identifier).name === 'destination') {
-          const namespace = (node.arguments[0] as babelTypes.StringLiteral).value;
-          const nsArr = namespace.split('.').map((item) => item.replace(/_view$/, ''));
-          const pageType = nsArr.shift();
-          const viewName = nsArr.pop();
-          return new naslTypes.Destination({
-            viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((item) => `.${item}.views`)?.join('')}`, // viewNamespace
-            viewName, // viewName
-
-            arguments: node.arguments.slice(1).map((arg) => new naslTypes.Argument({
-              expression: transformLogicNode(arg),
-            })) as naslTypes.Argument[],
-          });
-        }
-        return new naslTypes.CallLogic({
-          calleeNamespace: 'nasl.ui',
-          calleeName: (callee[2] as babelTypes.Identifier).name,
-          shortcut: true,
-          /**
-           * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
-           * @param node
-           * @returns
-           */
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) 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 === 'PAGINATE') {
-        const newCallee = node?.arguments || [];
-        return new naslTypes.Paginate({
-          list: newCallee?.[0] && transformLogicNode(newCallee?.[0]),
-          page: newCallee?.[1] && transformLogicNode(newCallee?.[1]),
-          size: newCallee?.[2] && transformLogicNode(newCallee?.[2]),
-        });
-      }
-      if (calleeName === 'ForEach') {
-        const newCallee = node.arguments;
-        const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
-        const nodeElement = new naslTypes.ForEachStatement({
-          each: transformLogicNode(newCallee[0]),
-          start: transformLogicNode(newCallee[1]),
-          end: transformLogicNode(newCallee[2]),
-          item: transformParam(arrowFunction.params[0] 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;
-      }
-      if (callee.length === 2) {
-        const curCalleeName = (node.callee as any).property.name;
-        if (curCalleeName === 'forEach') {
-          const newCallee = (node.callee as any).object;
-          const arrowFunction = node.arguments[0] as babelTypes.ArrowFunctionExpression;
-          const nodeElement = new naslTypes.ForEachStatement({
-            each: transformLogicNode(newCallee.callee.object),
-            start: transformLogicNode(newCallee?.arguments?.[0]),
-            end: transformLogicNode(newCallee?.arguments?.[1]),
-            item: transformParam(arrowFunction.params[0] 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;
-        }
-      } else if (['plus', 'minus', 'multiply', 'divide', 'remainder'].includes(calleeName)) {
-        return handleBinaryExpression(calleeName, node?.arguments);
-      } else if (calleeName === 'alert') {
-        return new naslTypes.CallLogic({
-          calleeNamespace: 'nasl.ui',
-          calleeName: 'showMessage',
-          shortcut: true,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      } else if (/^app.dataSources|app.logics/.test(calleeName)) {
-        if (calleeName?.includes('.entities.')) {
-          const calleeNamespace = generate((node?.callee as any)?.object?.object)?.code;
-          const entityName = (node?.callee as any)?.object?.property?.name?.replace(/Entity$/, '');
-          return new naslTypes.CallLogic({
-            calleeNamespace: `${calleeNamespace}.${entityName}.logics`,
-            calleeName: (node?.callee as any)?.property?.name,
-            arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-              expression: transformLogicNode(arg),
-            })) as naslTypes.Argument[],
-          });
-        }
-
-        return new naslTypes.CallLogic({
-          calleeNamespace: generate((node.callee as any).object).code,
-          calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      } else if (callee.length === 1) {
-        if (calleeName.startsWith('viewLogic_')) {
-          return new naslTypes.CallLogic({
-            calleeNamespace: '',
-            calleeName: calleeName.slice('viewLogic_'.length),
-            arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-              expression: transformLogicNode(arg),
-            })) as naslTypes.Argument[],
-          });
-        }
-        if (calleeName === 'FROM') {
-          // TODO
-          return new naslTypes.CallLogic({
-            calleeNamespace: `app.logics`,
-            calleeName,
-            arguments: [],
-          });
-        }
-        return new naslTypes.CallLogic({
-          calleeNamespace: `app.logics`,
-          calleeName,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      } else if (/interfaces/.test(calleeName)) {
-        return new naslTypes.CallInterface({
-          calleeNamespace: generate((node.callee as any).object).code,
-          calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-          arguments: node?.arguments?.map((arg: any) => arg?.properties?.map((item: any) => new naslTypes.Argument({
-            keyword: item?.key?.name,
-            expression: transformLogicNode(item?.value),
-          }))).flat() as naslTypes.Argument[],
-        });
-      } else if (/connector./.test(calleeName)) {
-        let flatCalleeKey = generate(node?.callee as any)?.code;
-        if (flatCalleeKey?.startsWith('connector.')) {
-          flatCalleeKey = flatCalleeKey?.replace('connector.', '');
-        }
-        const [, calleeConnectionName, calleeNamespace, calleeFunName] = flatCalleeKey?.match(/^(\w+)\.([\w.]+)\.(\w+)$/);
-        return new naslTypes.CallConnector({
-          calleeConnectionName,
-          calleeNamespace,
-          calleeName: calleeFunName,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      } else if (/extensions./.test(calleeName)) {
-        return new naslTypes.CallLogic({
-          calleeNamespace: generate((node?.callee as any)?.object)?.code,
-          calleeName: (callee?.[callee?.length - 1] as babelTypes.Identifier)?.name,
-          handleError: true,
-          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-            expression: transformLogicNode(arg),
-          })) as naslTypes.Argument[],
-        });
-      }
-      // else if (/destination/.test(calleeName)) {
-      //   const newCallee = flatMemberExpression((node.callee as any).object);
-      //   return new naslTypes.Destination({
-      //     viewNamespace: generate((node.callee as any).object.object).code,
-      //     viewName: (newCallee[newCallee.length - 1] as babelTypes.Identifier).name,
-      //     target: (node.arguments[0] as any).properties[1].value.value,
-      //     anchor: new naslTypes.Anchor({
-      //       expression: transformLogicNode((node.arguments[0] as any).properties[0].value),
-      //     }),
-      //   });
-      // }
-      else if (node.callee.type === 'ArrowFunctionExpression') {
-        // NOTE: 适用于 if else
-        const newCallee = (node.callee.body as any).body;
-        if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFuntion') {
-          const match = new naslTypes.Match({
-            expression: transformLogicNode(newCallee[0]),
-            isExpression: type === 'expression',
-            cases: flatIfStatement(newCallee[1].body.body[0]).map((_case: any) => new naslTypes.MatchCase({
-              patterns: !_case.test ? [] : flatMatchPatternsExpression(transformLogicNode(_case.test)) as any,
-              body: _case.consequent.body.filter((item: any) => item.type !== 'BreakStatement').map((item: any) => transformLogicNode(item)).filter((item: any) => !!item),
-            })),
-          });
-          if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
-            match.cases.push(new naslTypes.MatchCase({
-              patterns: [],
-              body: [],
-            }));
-          }
-          match.cases.forEach((case_: any) => {
-            if (case_.body.length && (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
-              case_.isMatchedTypeEnumable = true;
-            }
-            if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
-              case_.isMatchedTypeEnumable = true;
-              case_.patterns[0] = new naslTypes.MemberExpression({
-                object: {
-                  concept: 'Identifier',
-                  name: case_.patterns[0].object.property.name,
-                  folded: false,
-                  namespace: 'app.enums'
-                } as any,
-                property: {
-                  concept: 'Identifier',
-                  name: case_.patterns[0].property.value,
-                  folded: false,
-                } as any,
-              });
-            }
-          });
-          return match;
-        }
-        if (newCallee[newCallee.length - 1].argument?.callee?.name === '__SwitchExpressionFuntion') {
-          const switchStatement = transformLogicNode(newCallee[0].body.body[0]);
-          return switchStatement;
-        }
-        throwError(`Unhandled ArrowFunctionExpression node ${node.type}`);
-      } else {
-        throwError(`Unhandled node ${callee.map((item: babelTypes.Identifier) => item.name).join('.')} ${node.type}`);
-      }
-    } else if (node.type === 'IfStatement') {
-      if (node.alternate && node.alternate.type === 'IfStatement') {
-        const switchStatement = new naslTypes.SwitchStatement({
-          cases: [],
-        });
-        pushElseIf(node, switchStatement);
-        return switchStatement;
-      }
-      let consequentIndex: number;
-      let alternateIndex: number;
-      const naslNode = new naslTypes.IfStatement({
-        test: transformLogicNode(node.test),
-        consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map((item: any, index: number) => {
-          if (item?.type === 'ReturnStatement') {
-            item.ends = true;
-            if (item?.argument) {
-              consequentIndex = index;
-            }
-          }
-          return transformLogicNode(item);
-        }).filter((item) => !!item),
-        alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item: any, index: number) => {
-          if (item?.type === 'ReturnStatement') {
-            item.ends = true;
-            if (item?.argument) {
-              alternateIndex = index;
-            }
-          }
-          return transformLogicNode(item);
-        }).filter((item) => !!item),
-      }) as any;
-      if (consequentIndex !== undefined) {
-        naslNode?.consequent?.splice(consequentIndex + 1, 0, new naslTypes.End());
-      }
-      if (alternateIndex !== undefined) {
-        naslNode?.alternate?.splice(alternateIndex + 1, 0, new naslTypes.End());
-      }
-      return naslNode;
-    } else if (node.type === 'WhileStatement') {
-      return new naslTypes.WhileStatement({
-        test: transformLogicNode(node.test),
-        body: (node.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-      });
-    } else if (node.type === 'SwitchStatement') {
-      const match = new naslTypes.Match({
-        expression: transformLogicNode(node.discriminant),
-        isExpression: type === 'expression',
-        cases: node.cases.map((_case) => new naslTypes.MatchCase({
-          patterns: !_case.test ? [] : [transformLogicNode(_case.test)],
-          body: _case.consequent.filter((item) => item.type !== 'BreakStatement').map((item) => transformLogicNode(item)).filter((item) => !!item),
-        })),
-      });
-      if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
-        match.cases.push(new naslTypes.MatchCase({
-          patterns: [],
-          body: [],
-        }));
-      }
-      match.cases.forEach((case_: any) => {
-        if (case_.body.length && (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
-          case_.isMatchedTypeEnumable = true;
-        }
-        if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
-          case_.isMatchedTypeEnumable = true;
-          case_.patterns[0].object.namespace = 'app.enums';
-        }
-      });
-      return match;
-    } else if (node.type === 'MemberExpression') {
-      const callee = flatMemberExpression(node);
-      const calleeName = generate(node)?.code;
-      if (calleeName?.includes('app.enums')) {
-        const name = (callee?.[3] as babelTypes.StringLiteral)?.value || (callee?.[3] as babelTypes.Identifier)?.name || (callee?.[3] as babelTypes.NumericLiteral)?.value;
-        return new naslTypes.MemberExpression({
-          object: new naslTypes.Identifier({
-            namespace: 'app.enums',
-            name: (callee?.[2] as babelTypes.Identifier)?.name,
-          }),
-          property: new naslTypes.Identifier({
-            name: String(name),
-          }),
-        });
-      }
-      if (node.property.type === 'NumericLiteral') {
-        return new naslTypes.CallFunction({
-          calleeNamespace: 'nasl.util',
-          calleeName: 'Get',
-          arguments: [
-            new naslTypes.Argument({
-              expression: transformLogicNode(node.object),
-            }),
-            new naslTypes.Argument({
-              expression: transformLogicNode(node.property),
-            }),
-          ],
-        });
-      }
-      return new naslTypes.MemberExpression({
-        object: transformLogicNode(node.object),
-        property: transformLogicNode(node.property),
-      });
-    } else if (node.type === 'Identifier') {
-      return new naslTypes.Identifier({
-        name: node.name,
-      });
-    } else if (node.type === 'ExpressionStatement') {
-      return transformLogicNode(node.expression);
-    } else if (node.type === 'AssignmentExpression') {
-      if (node.operator === '+=' || node.operator === '-=') {
-        if (type === 'expression') {
-          return new naslTypes.BinaryExpression({
-            operator: node.operator[0] as '+' | '-',
-            left: transformLogicNode(node.left),
-            right: transformLogicNode(node.right),
-          });
-        }
-        return new naslTypes.Assignment({
-          left: transformLogicNode(node.left),
-          right: new naslTypes.BinaryExpression({
-            operator: node.operator[0] as '+' | '-',
-            left: transformLogicNode(node.left),
-            right: transformLogicNode(node.right),
-          }),
-        });
-      }
-      if (type === 'expression') {
-        return transformLogicNode(node.right);
-      }
-      return new naslTypes.Assignment({
-        left: transformLogicNode(node.left),
-        right: transformLogicNode(node.right),
-      });
-    } else if (node.type === 'NewExpression') {
-      const calleeName = generate(node.callee as any).code;
-      if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
-        return transformLogicNode(node.arguments[0], naslTypes.TypeAnnotation.createPrimitive(calleeName));
-      }
-      throwError(`Unhandled node ${node.type}`);
-    } else if (node.type === 'ArrowFunctionExpression') {
-      return new naslTypes.AnonymousFunction({
-        params: node.params.map((param: babelTypes.Identifier) => transformParam(param)),
-        body: transformLogicNode(node.body),
-      }) as any as naslTypes.LogicItem;
-    } else if (node.type === 'BooleanLiteral') {
-      return new naslTypes.BooleanLiteral({
-        value: String(node.value),
-      });
-    } else if (node.type === 'StringLiteral') {
-      return new naslTypes.StringLiteral({
-        value: node.value,
-      });
-    } else if (node.type === 'NumericLiteral') {
-      const literal = new naslTypes.NumericLiteral({
-        value: String(node.value),
-        typeAnnotation: typeAnnotation || naslTypes.TypeAnnotation.createPrimitive('Integer'),
-      });
-      literal.typeAnnotation.typeName = literal.changeType(String(node.value));
-      return literal;
-    } else if (node.type === 'NullLiteral') {
-      return new naslTypes.NullLiteral();
-    } else if (node.type === 'TemplateLiteral') {
-      const expressions = [...node.expressions as babelTypes.Expression[], ...node.quasis.map((element) => ({
-        type: 'StringLiteral',
-        value: element.value.raw,
-        start: element.start,
-        end: element.end,
-      })) as babelTypes.StringLiteral[]];
-      expressions.sort((a, b) => a.start - b.start);
-
-      return new naslTypes.StringInterpolation({
-        expressions: expressions.map((item) => transformLogicNode(item)),
-      });
-    } else if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
-      if (node.operator === '===')
-        node.operator = '==';
-      if (node.operator === '!==')
-        node.operator = '!=';
-      if (['+', '-', '*', '/', '%', '==', '!=', '>', '<', '>=', '<=', '&&', '||', 'startwith', 'endwith', 'like', 'in'].includes(node.operator)) {
-        return new naslTypes.BinaryExpression({
-          operator: node.operator as any,
-          left: transformLogicNode(node.left),
-          right: transformLogicNode(node.right),
-        });
-      }
-      throwError(`Unhandled node ${node.type}`);
-    } else if (node.type === 'UnaryExpression') {
-      if (['!'].includes(node.operator)) {
-        return new naslTypes.UnaryExpression({
-          operator: node.operator as any,
-          argument: transformLogicNode(node.argument),
-        });
-      }
-      if (['-'].includes(node.operator) && node.argument.type === 'NumericLiteral') {
-        return transformLogicNode({
-          type: 'NumericLiteral',
-          value: -node.argument.value,
-        } as babelTypes.NumericLiteral);
-      }
-      throwError(`Unhandled node ${node.type}`);
-    } else if (node.type === 'UpdateExpression') {
-      if (node.operator === '++' || node.operator === '--') {
-        return new naslTypes.Assignment({
-          left: transformLogicNode(node.argument),
-          right: new naslTypes.BinaryExpression({
-            operator: node.operator[0] as '+' | '-',
-            left: transformLogicNode(node.argument),
-            right: new naslTypes.NumericLiteral({
-              value: '1',
-              typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Integer'),
-            }),
-          }),
-        });
-      }
-    } else if (node.type === 'ReturnStatement') {
-      if (node.argument) {
-        if (type === 'expression') {
-          return transformLogicNode(node.argument);
-        }
-        if (!logic.returns.length) {
-          logic.returns.push(new naslTypes.Return({
-            name: 'result',
-          }));
-        }
-        return new naslTypes.Assignment({
-          left: new naslTypes.Identifier({
-            name: logic.returns[0].name,
-          }),
-          right: transformLogicNode(node.argument),
-        });
-      }
-      if ((node as any)?.ends) {
-        return new naslTypes.End();
-      }
-    } else if (node.type === 'EmptyStatement') {
-      return node.leadingComments && new naslTypes.Comment({
-        value: String(node.leadingComments[0].value),
-      });
-    } 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 = [];
-      const assignmentLines: any = [];
-      node?.properties?.forEach((arg: any, index: number) => {
-        properties.push(transformLogicNode(arg.key));
-        if (arg.value.type === 'MemberExpression') {
-          const expression = flatMemberExpression(arg.value);
-          const members = flatMembers(transformLogicNode(arg.value) as any);
-          rights.push(new naslTypes.SelectMembers({
-            expression: transformLogicNode(expression[0]),
-            members,
-          }));
-          if (arg?.value) {
-            assignmentLines.push(new naslTypes.AssignmentLine({
-              leftIndex: [0, index],
-              rightIndex: [index, members.length - 1],
-            }));
-          }
-        } else {
-          rights.push(new naslTypes.SelectMembers({
-            expression: transformLogicNode(arg?.value)
-          }));
-          if (arg?.value) {
-            assignmentLines.push(new naslTypes.AssignmentLine({
-              leftIndex: [0, index],
-              rightIndex: [index],
-            }));
-          }
-        }
-        structureProperties.push(new naslTypes.StructureProperty({
-          name: arg?.key?.name,
-          typeAnnotation: null
-        }));
-      });
-      return new naslTypes.NewComposite({
-        typeAnnotation: naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
-        properties,
-        rights,
-        assignmentLines
-      });
-    } else {
-      throwError(`Unhandled node ${node.type}`);
-    }
-  }
+  const logic = new naslTypes.Logic();
+  logic.name = contextLogicName;
+  logic.body = [
+    new naslTypes.Start(),
+  ];
 
   const root = babel.parseSync(tsCode, {
     filename: 'result.ts',
@@ -1073,28 +52,23 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
     statements = statements.filter((stat) => stat.start > currentPositionComment.start);
   }
 
-  // traverse<babelTypes.Node>((current) => {
-  //     if (!current.node.type)
-  //         console.log(current.key, current.node);
-  //     // console.log(current.node.type);
-  // }, { node: {
-  //     type: 'BlockStatement',
-  //     body: statements,
-  // } as babelTypes.BlockStatement }, {
-  //     mode: 'anyObject',
-  //     depthFirst: true,
-  //     excludedKeySet: new Set(['loc']),
-  // });
-
   parameters.forEach((node) => {
-    const param = transformParam(node);
+    const param = transform2Param(node);
     param && logic.params.push(param);
   });
   statements.forEach((node) => {
-    const item = transformLogicNode(node);
+    const item = transform2LogicItem(node, {
+      logic,
+      isPageLogic: isPageLogic(contextLogicName),
+    });
     item && logic.body.push(item);
   });
 
+  if (logic.returns[0]?.name) {
+    const index = logic.variables.findIndex((variable) => variable.name === logic.returns[0].name);
+    if (index >= 0)
+      logic.variables.splice(index, 1);
+  }
   // console.log(JSON.stringify(logic));
   // try {
   //     console.log(logic.toNaturalTS());
@@ -1105,14 +79,14 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
   return logic;
 }
 
-export function tryTransformTSCode(tsCode: string, contextLogicName: string, type?: string): naslTypes.Logic {
+export function tryTransformTSCode(tsCode: string, contextLogicName: string): naslTypes.Logic {
   if (tsCode.includes('```')) {
     const cap = tsCode.match(/```.*\n([\s\S]+?)```/);
     if (cap)
       tsCode = cap[1].trim();
   }
 
-  return transformTSCode(tsCode, contextLogicName, type);
+  return transformTSCode(tsCode, contextLogicName);
 }
 
 export function transformTSCodeEx(answer: any, activeLogic: any, context: any) {
@@ -1148,7 +122,7 @@ export function transformTSCodeEx(answer: any, activeLogic: any, context: any) {
 export function transformTSCodeToExpression(answer: any, context: any) {
   let logic;
   try {
-    logic = tryTransformTSCode(answer, '', 'expression');
+    logic = tryTransformTSCode(answer, '');
   } catch (error) {
     throw new Error(error);
   }