@lcap/nasl 3.8.2-beta.8 → 3.8.3-beta.1

package/src/natural/transformTS2UI.ts

@@ -1,18 +1,11 @@
 /* eslint-disable global-require */
 /* eslint-disable @typescript-eslint/no-use-before-define */
+import { babelTypes, naslTypes, generate, DEBUG, throwError, tryParseTS } from './transforms/utils';
 import { kebabCase, cloneDeep } from 'lodash';
 import * as babel from '@babel/core';
-import * as babelTypes from '@babel/types';
-import generate from '@babel/generator';
-import * as naslTypes from '../concepts';
 import { genHash } from '../generator';
 import { type ParseResult } from '@babel/parser';
-
-const DEBUG = false;
-function throwError(message: string) {
-  if (DEBUG) throw new Error(message);
-  else console.error(message);
-}
+import { transform2TypeAnnotation } from './transforms/transform2TypeAnnotation';
 
 function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
   if (node.type === 'MemberExpression')
@@ -61,83 +54,6 @@ function fixLogicNode(node: babelTypes.Node): void {
   }
 }
 
-// 处理类型
-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;
-  } else {
-    throwError(`Unhandled node ${node.type}`);
-  }
-}
-
 // 处理参数
 function transformParam(node: babelTypes.Identifier): naslTypes.Param {
   const typeAnnotation = (node.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
@@ -145,8 +61,25 @@ function transformParam(node: babelTypes.Identifier): naslTypes.Param {
   if (exclude.includes(node.name)) return null;
   return new naslTypes.Param({
     name: node.name,
-    typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
+    typeAnnotation: typeAnnotation ? transform2TypeAnnotation(typeAnnotation) : null,
+  });
+}
+
+// 处理生命周期函数
+function transformLifecycle(node: babelTypes.ObjectExpression): Array<naslTypes.BindEvent> {
+  const bindEvents: Array<naslTypes.BindEvent> = []
+  node.properties.forEach((property: any) => {
+    const eventName = property?.key?.name?.replace(/^on/, '')?.toLowerCase();
+    const bindEvent = new naslTypes.BindEvent({ name: eventName });
+    property.value.elements.forEach((element: any) => {
+      let logicName =  element?.id?.name || '';
+      logicName = bindEvent.getLogicUniqueName(logicName);
+      const curLogic: any = transformNode2Logic(element, logicName, 'view_logic');
+      bindEvent.addLogic(curLogic);
+    });
+    bindEvents.push(bindEvent);
   });
+  return bindEvents;
 }
 
 // 处理变量
@@ -158,7 +91,7 @@ function transformVariableDeclaration(node: babelTypes.VariableDeclaration): nas
     const varTypeAnnotation = ((decl.id as babelTypes.Identifier).typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
     newNode = new naslTypes.Variable({
       name: variableName,
-      typeAnnotation: varTypeAnnotation && transformTypeAnnotation(varTypeAnnotation),
+      typeAnnotation: varTypeAnnotation && transform2TypeAnnotation(varTypeAnnotation),
     });
     if (decl.init) {
       if (decl.init.type !== 'ArrayExpression' && decl.init.type !== 'ObjectExpression') {
@@ -209,7 +142,7 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
   if (calleeName === 'NewList') {
     return new naslTypes.NewList({
       typeAnnotation: naslTypes.TypeAnnotation.createGeneric('List', {
-        typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
+        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation),
       }),
       items: node?.arguments?.[0]?.elements?.map((arg: any) => transformNode2Expression(arg, type)),
     });
@@ -223,7 +156,7 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
     });
     return new naslTypes.NewMap({
       typeAnnotation: naslTypes.TypeAnnotation.createGeneric('Map', {
-        typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
+        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation),
       }),
       keys,
       values,
@@ -389,6 +322,14 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
   return node;
 }
 
+function fixExpression(arg: any, type?: string) {
+  let expression = transformNode2Expression(arg, type);
+  if (expression?.concept === 'Identifier' && expression?.name === 'undefined') {
+    expression = undefined;
+  }
+  return expression;
+}
+
 // 处理表达式
 function transformNode2Expression(node: babelTypes.Node, type?: string): any {
   if (!node) return null;
@@ -408,12 +349,12 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
         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: transformNode2Expression(arg, type),
+          expression: fixExpression(arg, type),
         })) as naslTypes.Argument[],
       });
     }
     if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
-      const entityName = callee[0].name.replace(/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,
@@ -451,7 +392,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
         arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
           expression: transformNode2Expression(arg, type),
         })) as naslTypes.Argument[],
-        typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType })),
+        typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType })),
       });
     };
     if (calleeName.startsWith('nasl.util.')) {
@@ -481,8 +422,8 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
           expression: transformNode2Expression(arg, type),
           keyword: `str${index + 1}`,
         })) as naslTypes.Argument[],
-        typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
-        // typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType, typeNamespace })),
+        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation),
+        // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
       });
       return nodeElement;
     }
@@ -492,13 +433,22 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
         const nsArr = namespace.split('.').map((item) => item.replace(/_view$/, ''));
         const pageType = nsArr.shift();
         const viewName = nsArr.pop();
+        const newArguments = node?.arguments?.slice(1);
+        let argument = [] as naslTypes.Argument[];
+        if (newArguments?.[0]?.type === 'ObjectExpression') {
+          argument = newArguments?.[0]?.properties?.map((property: any) => new naslTypes.Argument({
+            keyword: property?.key?.name,
+            expression: fixExpression(property?.value, type),
+          })) as naslTypes.Argument[];
+        } else {
+          argument = node.arguments.slice(1).map((arg) => new naslTypes.Argument({
+            expression: fixExpression(arg, type),
+          })) as naslTypes.Argument[];
+        }
         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: transformNode2Expression(arg, type),
-          })) as naslTypes.Argument[],
+          viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((item) => `.${item}.views`)?.join('')}`,
+          viewName,
+          arguments: argument,
         });
       }
       return new naslTypes.CallLogic({
@@ -545,7 +495,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
         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) => transformNode2Expression(item, type)).filter((item) => !!item),
+        body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformNode2Expression(item)).filter((item) => !!item && item?.concept !== 'Variable'),
       });
       return nodeElement;
     }
@@ -562,7 +512,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
           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) => transformNode2Expression(item, type)).filter((item) => !!item),
+          body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformNode2Expression(item)).filter((item) => !!item && item?.concept !== 'Variable'),
         });
         return nodeElement;
       }
@@ -580,7 +530,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
     } 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$/, '');
+        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,
@@ -616,7 +566,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
         });
       }
       return new naslTypes.CallLogic({
-        calleeNamespace: `app.logics`,
+        calleeNamespace: ``,
         calleeName,
         arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
           expression: transformNode2Expression(arg, type),
@@ -629,7 +579,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
         arguments: node?.arguments?.map((arg: any) => arg?.properties?.map((item: any) => new naslTypes.Argument({
           keyword: item?.key?.name,
           expression: transformNode2Expression(item?.value, type),
-        }))).flat() as naslTypes.Argument[],
+        })) || []).flat() as naslTypes.Argument[] || [],
       });
     } else if (/connector./.test(calleeName)) {
       const flatCalleeKey = generate(node?.callee as any)?.code;
@@ -697,6 +647,14 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
         return switchStatement;
       }
       throwError(`Unhandled ArrowFunctionExpression node ${node.type}`);
+    } else if (/nasl.auth./.test(calleeName)) {
+      return new naslTypes.CallLogic({
+        calleeNamespace: 'nasl.auth',
+        calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
+        arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+          expression: transformNode2Expression(arg, type),
+        })) as naslTypes.Argument[],
+      });
     } else {
       throwError(`Unhandled node ${callee.map((item: babelTypes.Identifier) => item.name).join('.')} ${node.type}`);
     }
@@ -783,6 +741,25 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
         }),
       });
     }
+    if (calleeName?.includes('nasl.auth.')) {
+      return new naslTypes.MemberExpression({
+        object: new naslTypes.Identifier({
+          namespace: 'nasl.auth',
+          name: (callee?.[2] as babelTypes.Identifier)?.name,
+        }),
+        property: new naslTypes.Identifier({
+          name: (callee?.[3] as babelTypes.Identifier)?.name,
+        }),
+      });
+    }
+    const regex = /^(app\..+?)\.variables\.(.+)$/;
+    if (regex.test(calleeName)) {
+      const [, namespace, variableName] = calleeName.match(regex);
+      return new naslTypes.Identifier({
+        name: String(variableName),
+        namespace: `${namespace}.variables`
+      });
+    }
     if (node.property.type === 'NumericLiteral') {
       return new naslTypes.CallFunction({
         calleeNamespace: 'nasl.util',
@@ -971,29 +948,55 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
 }
 
 // 处理逻辑
-function transformNode2Logic(node: babelTypes.FunctionDeclaration, name?: string): naslTypes.Logic {
+function transformNode2Logic(node: babelTypes.FunctionDeclaration, name: string, type: string): naslTypes.Logic {
   const parameters: babelTypes.Identifier[] = node.params as babelTypes.Identifier[];
   const statements: babelTypes.Statement[] = node.body.body;
 
   const curLogic: any = new naslTypes.Logic({ name: name ?? node.id.name });
-  parameters.forEach((item: babelTypes.Identifier) => {
-    const param = transformParam(item);
-    if (param && param.name !== 'event' && !curLogic.params.find((_: any) => _.name === param.name)) curLogic.addParam(param);
-  });
-  statements.forEach((item) => {
+  if (type !== 'event_logic') {
+    parameters.forEach((item: babelTypes.Identifier) => {
+      const param = transformParam(item);
+      if (param && param.name !== 'event' && !curLogic.params.find((_: any) => _.name === param.name)) curLogic.addParam(param);
+    });
+  }
+  statements?.forEach((item) => {
     if (item.type === 'ReturnStatement' && item?.argument) {
-      if (!curLogic.returns.length) {
-        curLogic.returns.push(new naslTypes.Return({
-          name: 'result',
-        }));
+      if (type === 'view_logic') {
+        if (item.argument?.type === 'Identifier') {
+          if (!curLogic.returns.length) {
+            const curVariable = curLogic?.variables?.find((it: any) => it.name === (item?.argument as any)?.name);
+            if (curVariable) {
+              curLogic.variables = curLogic?.variables?.filter((it: any) => it.name !== (item?.argument as any)?.name);
+              curLogic.addReturn(curVariable as any);
+            }
+          }
+        } else {
+          if (!curLogic.returns.length) {
+            curLogic.returns.push(new naslTypes.Return({
+              name: 'result',
+            }));
+          }
+          const logicItem = new naslTypes.Assignment({
+            left: new naslTypes.Identifier({
+              name: curLogic.returns[0].name,
+            }),
+            right: transformNode2Expression(item.argument, 'logic')
+          });
+          curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
+        }
+      } else {
+        if (item.argument?.type !== 'Identifier') {
+          curLogic.addVariable('tempVar');
+          const logicItem = new naslTypes.Assignment({
+            left: new naslTypes.Identifier({
+              name: 'tempVar',
+            }),
+            right: transformNode2Expression(item.argument, 'logic')
+          });
+          curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
+        }
       }
-      const logicItem = new naslTypes.Assignment({
-        left: new naslTypes.Identifier({
-          name: curLogic.returns[0].name,
-        }),
-        right: transformNode2Expression(item.argument, 'logic')
-      });
-      curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
+
     } else {
       let logicItem = transformNode2Expression(item, 'logic');
       if (logicItem) {
@@ -1015,6 +1018,7 @@ function transformNode2Logic(node: babelTypes.FunctionDeclaration, name?: string
 
 // 处理属性
 function transformNode2Attribute(node: any): any {
+  if (!node?.value || !node?.key) return {};
   let item = {} as any;
   let newNode = {} as any;
   if (['StringLiteral', 'NumericLiteral'].includes(node.value.type)) {
@@ -1037,8 +1041,35 @@ function transformNode2Attribute(node: any): any {
       sync: true,
       expression: transformNode2Expression(node.value.arguments[0]),
     };
-  }
-  else {
+  } else if (['destination'].includes(node.key.name)) {
+    const namespace = node?.value?.arguments?.[0]?.value;
+    const nsArr = namespace.split('.').map((it: string) => it.replace(/_view$/, ''));
+    const pageType = nsArr.shift();
+    const viewName = nsArr.pop();
+    const newArguments = node?.value?.arguments?.slice(1);
+    let argument = [] as naslTypes.Argument[];
+    if (newArguments?.[0]?.type === 'ObjectExpression') {
+      argument = newArguments?.[0]?.properties?.map((property: any) => new naslTypes.Argument({
+        keyword: property?.key?.name,
+        expression: fixExpression(property?.value),
+      })) as naslTypes.Argument[];
+    } else {
+      argument = node?.arguments?.slice(1)?.map((arg: any) => new naslTypes.Argument({
+        expression: fixExpression(arg),
+      })) as naslTypes.Argument[];
+    }
+
+    const destination = new naslTypes.Destination({
+      viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((it: any) => `.${it}.views`)?.join('')}`,
+      viewName,
+      arguments: argument,
+    });
+    item = {
+      name: node?.key?.name,
+      type: 'dynamic',
+      destination,
+    };
+  } else {
     // ['TemplateLiteral', 'BooleanLiteral', 'NullLiteral', 'CallExpression']
     item = {
       name: node.key.name,
@@ -1086,7 +1117,7 @@ function transformNode2ViewElement(node: babelTypes.NewExpression, componentName
         const bindEvent = new naslTypes.BindEvent({ name: eventName });
         prop.value.elements.forEach((element: any) => {
           const logicName = bindEvent.getLogicUniqueName();
-          const curLogic: any = transformNode2Logic(element, logicName);
+          const curLogic: any = transformNode2Logic(element, logicName, 'event_logic');
           bindEvent.addLogic(curLogic);
         });
         newViewElement.addBindEvent(bindEvent);
@@ -1095,7 +1126,7 @@ function transformNode2ViewElement(node: babelTypes.NewExpression, componentName
         const eventName = prop?.key?.name?.replace(/^on/, '')?.toLowerCase();
         const bindEvent = new naslTypes.BindEvent({ name: eventName });
         const logicName = bindEvent.getLogicUniqueName();
-        bindEvent.addLogic(transformNode2Logic(prop.value, logicName));
+        bindEvent.addLogic(transformNode2Logic(prop.value, logicName, 'event_logic'));
         newViewElement.addBindEvent(bindEvent);
       } else if (['FunctionExpression', 'ArrowFunctionExpression'].includes(prop?.value?.type) && ['ArrayExpression'].includes(prop.value.body?.type)) {
         // 子组件
@@ -1163,18 +1194,24 @@ function transformNode2ViewElement(node: babelTypes.NewExpression, componentName
 /**
  * 转换Node为View下的构件
 */
-function transformNode2ViewConstruct(node: babelTypes.Node): naslTypes.ViewElement | naslTypes.Variable | naslTypes.Logic | naslTypes.View {
+function transformNode2ViewConstruct(node: babelTypes.Node): naslTypes.ViewElement | naslTypes.Variable | naslTypes.Logic | naslTypes.View | Array<naslTypes.BindEvent> {
   // console.log("lemon ~ transformNode2ViewConstruct ~ node:", node);
 
   // 变量声明
   if (node.type === 'VariableDeclaration') {
+    const declList = node?.declarations || [];
+    const declListFirstNodde = declList[0];
+    const variableName = (declListFirstNodde as any)?.id?.name;
+    if(variableName === '$lifecycles' && declListFirstNodde.init) {
+      return transformLifecycle(declListFirstNodde.init as any);
+    }
     return transformVariableDeclaration(node);
   }
 
   // 页面逻辑
   if (node.type === 'FunctionDeclaration') {
     const logicName = node.id.name.replace(/^viewLogic_/, '');
-    return transformNode2Logic(node, logicName);
+    return transformNode2Logic(node, logicName, 'view_logic');
   }
 
   if (node.type === 'ExpressionStatement') {
@@ -1209,19 +1246,28 @@ function transformNode2ViewConstruct(node: babelTypes.Node): naslTypes.ViewEleme
       } else {
         properties?.[3].value.elements.forEach((element: any) => {
           let newNode = {} as any;
+          const propertiesMap = ['BindDirective', 'BindStyle', 'BindAttribute'];
           if (properties?.[2].value.value === 'ViewElement') {
             newNode = transformNode2ViewConstruct(element);
-          } else if (properties?.[2].value.value === 'BindAttribute') {
+          } else if (propertiesMap.includes(properties?.[2]?.value?.value)) {
             newNode = transformNode2Attribute({ key: element.left, value: element.right });
+          } else if (properties?.[2]?.value?.value === 'BindEvent') {
+            const eventName = element?.left?.name?.replace(/^on/, '')?.toLowerCase();
+            const bindEvent = new naslTypes.BindEvent({ name: eventName });
+            const logicName = bindEvent.getLogicUniqueName();
+            bindEvent.addLogic(transformNode2Logic(element?.right?.elements[0], logicName, 'event_logic'));
+            newNode = bindEvent;
+          }
+          if (newNode) {
+            const newNodeBackup = cloneDeep(newNode);
+            (newNode as any).aiParams = {
+              action: properties?.[0].value.value,
+              selectedNodeName: properties?.[1].value.value,
+              concept: properties?.[2].value.value,
+              object: newNodeBackup
+            };
+            newViewElement.push(newNode);
           }
-          const newNodeBackup = cloneDeep(newNode);
-          (newNode as any).aiParams = {
-            action: properties?.[0].value.value,
-            selectedNodeName: properties?.[1].value.value,
-            concept: properties?.[2].value.value,
-            object: newNodeBackup
-          };
-          newViewElement.push(newNode);
         });
       }
     });
@@ -1246,24 +1292,28 @@ function transformNode2View(node: babelTypes.FunctionDeclaration, root?: ParseRe
   }
 
   const view = new naslTypes.View();
-  parameters.forEach((item) => {
+  parameters?.forEach((item) => {
     const param = transformParam(item);
+    view.params = view.params || [];
     param && view.params.push(param);
   });
 
   const json: any = [];
-  statements.forEach((item) => {
+  statements?.forEach((item) => {
     const viewItem = transformNode2ViewConstruct(item) as any;
     if (item.type === 'ReturnStatement' && item?.argument?.type === 'CallExpression') {
       const action = (item.argument as any)?.callee?.name;
       const selectedNodeName = (item.argument as any).arguments?.[0]?.property?.name;
-      const newNodeBackup = cloneDeep(viewItem);
-      (viewItem as any).aiParams = { selectedNodeName, action, concept: 'ViewElement', object: newNodeBackup };
+      if (viewItem) {
+        const newNodeBackup = cloneDeep(viewItem);
+        (viewItem as any).aiParams = { selectedNodeName, action, concept: 'ViewElement', object: newNodeBackup };
+      }
     }
     if (item.type === 'ReturnStatement' && item?.argument?.type === 'ArrayExpression') {
       viewItem?.forEach((element: any) => {
         if (element.aiParams) json.push(element.aiParams);
-        view.addViewElement(element);
+        if (element?.concept === 'ViewElement')
+          view.addViewElement(element);
       });
     }
     if (viewItem?.concept === 'Variable') {
@@ -1276,6 +1326,12 @@ function transformNode2View(node: babelTypes.FunctionDeclaration, root?: ParseRe
       view.addViewElement(viewItem);
       if (viewItem.aiParams) json.push(viewItem.aiParams);
     }
+    // 生命周期函数
+    if(item.type === 'VariableDeclaration' && Array.isArray(viewItem) && viewItem[0]?.concept === 'BindEvent') {
+      viewItem.forEach((bindEvent: any) => {
+        view.addBindEvent(bindEvent);
+      });
+    }
   });
   // console.log("lemon ~ 转换出的 view:", view);
   return { view: view.toJSON(), json };
@@ -1302,8 +1358,8 @@ const transformTS2View = (tsCode: string): any => {
   return transformNode2View(func, root);
 };
 
-const handleNodeName = (curView: any, object: any) => {
-  const list = [];
+const handleNodeName = (curView: any, object: any, memory?: any) => {
+  const list = [...memory || []];
   if (object.concept === 'ViewElement') {
     const oldName = object.name;
     const newName = curView?.getViewElementUniqueNameOld(oldName);
@@ -1313,11 +1369,13 @@ const handleNodeName = (curView: any, object: any) => {
     }
     if (object?.children?.length) {
       object.children.forEach((child: any) => {
-        handleNodeName(curView, child);
+        const { list: childList } = handleNodeName(curView, child, list);
+        // 去重并合并
+        list.push(...childList?.filter((item: any) => !list?.find((it: any) => it.oldName === item.oldName)));
       });
     }
   }
-  return { object, list };
+  return { list };
 };
 
 export function tryTransformTS2UI(tsCode: string, curView?: any): any {