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

package/out/natural/transformTS2UI.js

@@ -22,25 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryTransformTS2UI = void 0;
 /* eslint-disable global-require */
 /* eslint-disable @typescript-eslint/no-use-before-define */
+const utils_1 = require("./transforms/utils");
 const lodash_1 = require("lodash");
 const babel = __importStar(require("@babel/core"));
-const generator_1 = __importDefault(require("@babel/generator"));
-const naslTypes = __importStar(require("../concepts"));
-const generator_2 = require("../generator");
-const DEBUG = false;
-function throwError(message) {
-    if (DEBUG)
-        throw new Error(message);
-    else
-        console.error(message);
-}
+const generator_1 = require("../generator");
+const transform2TypeAnnotation_1 = require("./transforms/transform2TypeAnnotation");
 function flatMemberExpression(node) {
     if (node.type === 'MemberExpression')
         return [...flatMemberExpression(node.object), node.property];
@@ -76,105 +66,40 @@ function flatIfStatement(node) {
  */
 function fixLogicNode(node) {
     if (node?.type === 'CallExpression') {
-        const calleeName = (0, generator_1.default)(node.callee).code;
+        const calleeName = (0, utils_1.generate)(node.callee).code;
         if (calleeName === 'nasl.util.ForEach') {
             const callee = flatMemberExpression(node.callee);
             node.callee = callee[2];
         }
     }
 }
-// 处理类型
-function transformTypeAnnotation(node) {
-    if (!node)
-        return null;
-    if (node.type === 'TSTypeReference') {
-        const typeName = node.typeName.name;
-        const primitiveType = naslTypes.primitiveTypeList.find((ta) => ta.typeName === typeName);
-        if (node?.typeNamespace) {
-            return naslTypes.TypeAnnotation.createReference(typeName, {
-                typeNamespace: node.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?.right?.name;
-            return naslTypes.TypeAnnotation.createGeneric(curTypeName, {
-                typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
-            });
-        }
-        if (!node.typeParameters) {
-            if (node?.typeName?.type === 'TSQualifiedName') {
-                const allTypeName = (0, generator_1.default)(node?.typeName?.left)?.code;
-                // 实体、枚举、结构体
-                if (/^app.dataSources|.enums|.structures|nasl.ui/.test(allTypeName)) {
-                    const curTypeName = node?.typeName?.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) => new naslTypes.StructureProperty({
-            name: member.key.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) {
     const typeAnnotation = node.typeAnnotation?.typeAnnotation;
     const exclude = ['event'];
     if (exclude.includes(node.name))
         return null;
-    return new naslTypes.Param({
+    return new utils_1.naslTypes.Param({
         name: node.name,
-        typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
+        typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
     });
 }
+// 处理生命周期函数
+function transformLifecycle(node) {
+    const bindEvents = [];
+    node.properties.forEach((property) => {
+        const eventName = property?.key?.name?.replace(/^on/, '')?.toLowerCase();
+        const bindEvent = new utils_1.naslTypes.BindEvent({ name: eventName });
+        property.value.elements.forEach((element) => {
+            let logicName = element?.id?.name || '';
+            logicName = bindEvent.getLogicUniqueName(logicName);
+            const curLogic = transformNode2Logic(element, logicName, 'view_logic');
+            bindEvent.addLogic(curLogic);
+        });
+        bindEvents.push(bindEvent);
+    });
+    return bindEvents;
+}
 // 处理变量
 function transformVariableDeclaration(node) {
     const declList = node?.declarations || [];
@@ -182,14 +107,14 @@ function transformVariableDeclaration(node) {
     declList?.forEach((decl) => {
         const variableName = decl.id.name;
         const varTypeAnnotation = decl.id.typeAnnotation?.typeAnnotation;
-        newNode = new naslTypes.Variable({
+        newNode = new utils_1.naslTypes.Variable({
             name: variableName,
-            typeAnnotation: varTypeAnnotation && transformTypeAnnotation(varTypeAnnotation),
+            typeAnnotation: varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation),
         });
         if (decl.init) {
             if (decl.init.type !== 'ArrayExpression' && decl.init.type !== 'ObjectExpression') {
                 // 变量值需要默认值还是赋值，在使用的地方处理
-                newNode.defaultValue = new naslTypes.DefaultValue({
+                newNode.defaultValue = new utils_1.naslTypes.DefaultValue({
                     expression: transformNode2Expression(decl.init),
                 });
             }
@@ -199,7 +124,7 @@ function transformVariableDeclaration(node) {
 }
 // 处理 if
 function pushElseIf(ifNode, switchStatement) {
-    switchStatement.cases.push(new naslTypes.SwitchCase({
+    switchStatement.cases.push(new utils_1.naslTypes.SwitchCase({
         test: transformNode2Expression(ifNode.test),
         consequent: !ifNode.consequent ? [] : ifNode.consequent.body.map((item) => transformNode2Expression(item)).filter((item) => !!item),
     }));
@@ -207,7 +132,7 @@ function pushElseIf(ifNode, switchStatement) {
         pushElseIf(ifNode.alternate, switchStatement);
     }
     else {
-        switchStatement.cases.push(new naslTypes.SwitchCase({
+        switchStatement.cases.push(new utils_1.naslTypes.SwitchCase({
             test: undefined,
             consequent: !ifNode?.alternate ? [] : ifNode?.alternate?.body.map((item) => transformNode2Expression(item)).filter((item) => !!item),
         }));
@@ -222,7 +147,7 @@ function handleBinaryExpression(calleeName, argument) {
         divide: '/',
         remainder: '%',
     };
-    return new naslTypes.BinaryExpression({
+    return new utils_1.naslTypes.BinaryExpression({
         operator: map?.[calleeName],
         left: transformNode2Expression(argument?.[0]),
         right: transformNode2Expression(argument?.[1]),
@@ -231,9 +156,9 @@ function handleBinaryExpression(calleeName, argument) {
 // 处理数据结构
 function handleNewExpression(calleeName, node, type) {
     if (calleeName === 'NewList') {
-        return new naslTypes.NewList({
-            typeAnnotation: naslTypes.TypeAnnotation.createGeneric('List', {
-                typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
+        return new utils_1.naslTypes.NewList({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createGeneric('List', {
+                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
             }),
             items: node?.arguments?.[0]?.elements?.map((arg) => transformNode2Expression(arg, type)),
         });
@@ -245,9 +170,9 @@ function handleNewExpression(calleeName, node, type) {
             keys.push(transformNode2Expression(arg.key));
             values.push(transformNode2Expression(arg.value));
         });
-        return new naslTypes.NewMap({
-            typeAnnotation: naslTypes.TypeAnnotation.createGeneric('Map', {
-                typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
+        return new utils_1.naslTypes.NewMap({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createGeneric('Map', {
+                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
             }),
             keys,
             values,
@@ -262,23 +187,23 @@ function handleNewExpression(calleeName, node, type) {
             if (arg.value.type === 'MemberExpression') {
                 const expression = flatMemberExpression(arg.value);
                 const members = flatMembers(transformNode2Expression(arg.value));
-                rights.push(new naslTypes.SelectMembers({
+                rights.push(new utils_1.naslTypes.SelectMembers({
                     expression: transformNode2Expression(expression[0]),
                     members,
                 }));
                 if (arg?.value) {
-                    assignmentLines.push(new naslTypes.AssignmentLine({
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
                         leftIndex: [0, index],
                         rightIndex: [index, members.length - 1],
                     }));
                 }
             }
             else {
-                rights.push(new naslTypes.SelectMembers({
+                rights.push(new utils_1.naslTypes.SelectMembers({
                     expression: transformNode2Expression(arg.value)
                 }));
                 if (arg?.value) {
-                    assignmentLines.push(new naslTypes.AssignmentLine({
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
                         leftIndex: [0, index],
                         rightIndex: [index],
                     }));
@@ -288,10 +213,10 @@ function handleNewExpression(calleeName, node, type) {
         const parameters = node?.typeParameters?.params?.[0] || {};
         if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
             const { left, right } = parameters?.typeName || {};
-            const typeNamespace = (0, generator_1.default)(left)?.code;
+            const typeNamespace = (0, utils_1.generate)(left)?.code;
             const typeName = right?.name;
-            return new naslTypes.NewComposite({
-                typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+            return new utils_1.naslTypes.NewComposite({
+                typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(typeName, {
                     typeNamespace,
                     typeName
                 }),
@@ -301,8 +226,8 @@ function handleNewExpression(calleeName, node, type) {
             });
         }
         const typeName = parameters?.typeName?.name;
-        return new naslTypes.NewComposite({
-            typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+        return new utils_1.naslTypes.NewComposite({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(typeName, {
                 typeNamespace: 'app.dataSources.defaultDS.entities',
                 typeName
             }),
@@ -320,23 +245,23 @@ function handleNewExpression(calleeName, node, type) {
             if (arg.value.type === 'MemberExpression') {
                 const expression = flatMemberExpression(arg.value);
                 const members = flatMembers(transformNode2Expression(arg.value));
-                rights.push(new naslTypes.SelectMembers({
+                rights.push(new utils_1.naslTypes.SelectMembers({
                     expression: transformNode2Expression(expression[0]),
                     members,
                 }));
                 if (arg?.value) {
-                    assignmentLines.push(new naslTypes.AssignmentLine({
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
                         leftIndex: [0, index],
                         rightIndex: [index, members.length - 1],
                     }));
                 }
             }
             else {
-                rights.push(new naslTypes.SelectMembers({
+                rights.push(new utils_1.naslTypes.SelectMembers({
                     expression: transformNode2Expression(arg.value)
                 }));
                 if (arg?.value) {
-                    assignmentLines.push(new naslTypes.AssignmentLine({
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
                         leftIndex: [0, index],
                         rightIndex: [index],
                     }));
@@ -346,10 +271,10 @@ function handleNewExpression(calleeName, node, type) {
         const parameters = node?.typeParameters?.params?.[0] || {};
         if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
             const { left, right } = parameters?.typeName || {};
-            const typeNamespace = (0, generator_1.default)(left)?.code;
+            const typeNamespace = (0, utils_1.generate)(left)?.code;
             const typeName = right?.name;
-            return new naslTypes.NewComposite({
-                typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+            return new utils_1.naslTypes.NewComposite({
+                typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(typeName, {
                     typeNamespace,
                     typeName
                 }),
@@ -359,8 +284,8 @@ function handleNewExpression(calleeName, node, type) {
             });
         }
         const typeName = parameters?.typeName?.name;
-        return new naslTypes.NewComposite({
-            typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+        return new utils_1.naslTypes.NewComposite({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(typeName, {
                 typeNamespace: 'app.structures',
                 typeName
             }),
@@ -379,35 +304,35 @@ function handleNewExpression(calleeName, node, type) {
             if (arg.value.type === 'MemberExpression') {
                 const expression = flatMemberExpression(arg.value);
                 const members = flatMembers(transformNode2Expression(arg.value));
-                rights.push(new naslTypes.SelectMembers({
+                rights.push(new utils_1.naslTypes.SelectMembers({
                     expression: transformNode2Expression(expression[0]),
                     members,
                 }));
                 if (arg?.value) {
-                    assignmentLines.push(new naslTypes.AssignmentLine({
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
                         leftIndex: [0, index],
                         rightIndex: [index, members.length - 1],
                     }));
                 }
             }
             else {
-                rights.push(new naslTypes.SelectMembers({
+                rights.push(new utils_1.naslTypes.SelectMembers({
                     expression: transformNode2Expression(arg.value)
                 }));
                 if (arg?.value) {
-                    assignmentLines.push(new naslTypes.AssignmentLine({
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
                         leftIndex: [0, index],
                         rightIndex: [index],
                     }));
                 }
             }
-            structureProperties.push(new naslTypes.StructureProperty({
+            structureProperties.push(new utils_1.naslTypes.StructureProperty({
                 name: arg?.key?.name,
                 typeAnnotation: null
             }));
         });
-        return new naslTypes.NewComposite({
-            typeAnnotation: naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
+        return new utils_1.naslTypes.NewComposite({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
             properties,
             rights,
             assignmentLines
@@ -415,6 +340,13 @@ function handleNewExpression(calleeName, node, type) {
     }
     return node;
 }
+function fixExpression(arg, type) {
+    let expression = transformNode2Expression(arg, type);
+    if (expression?.concept === 'Identifier' && expression?.name === 'undefined') {
+        expression = undefined;
+    }
+    return expression;
+}
 // 处理表达式
 function transformNode2Expression(node, type) {
     if (!node)
@@ -429,57 +361,57 @@ function transformNode2Expression(node, type) {
     }
     else if (node.type === 'CallExpression') {
         const callee = flatMemberExpression(node.callee);
-        const calleeName = (0, generator_1.default)(node.callee).code;
+        const calleeName = (0, utils_1.generate)(node.callee).code;
         // console.log('lemon ~~~ CallExpression', node, callee, calleeName);
         if (/^\$refs\./.test(calleeName)) {
-            return new naslTypes.CallLogic({
+            return new utils_1.naslTypes.CallLogic({
                 calleeNamespace: `elements.${callee[1].name}.logics`,
                 calleeName: callee[2].name,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
-                    expression: transformNode2Expression(arg, type),
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+                    expression: fixExpression(arg, type),
                 })),
             });
         }
         if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
-            const entityName = callee[0].name.replace(/Entity$/, '');
-            return new naslTypes.CallLogic({
+            const entityName = callee[0].name.replace(/Entity/, '');
+            return new utils_1.naslTypes.CallLogic({
                 calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
                 calleeName: callee[1].name,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
         }
         if (calleeName === 'nasl.util.consoleLog' || calleeName === 'console.log') {
-            return new naslTypes.CallLogic({
+            return new utils_1.naslTypes.CallLogic({
                 calleeNamespace: 'nasl.util',
                 calleeName: 'consoleLog',
                 shortcut: true,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
         }
         if (calleeName.startsWith('nasl.logging.')) {
-            return new naslTypes.CallLogic({
+            return new utils_1.naslTypes.CallLogic({
                 calleeNamespace: 'nasl.logging',
                 calleeName: callee[2].name,
                 shortcut: true,
-                arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                arguments: node.arguments.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
         }
         if (calleeName === 'nasl.util.jsonSerialize' || calleeName === 'nasl.util.jsonDeserialize') {
             const curCalleeName = node.callee.property.name;
-            return new naslTypes.CallLogic({
+            return new utils_1.naslTypes.CallLogic({
                 calleeNamespace: 'nasl.util',
                 calleeName: curCalleeName,
                 shortcut: true,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
-                typeArguments: node?.typeParameters?.params.map((curType) => transformTypeAnnotation({ ...curType })),
+                typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType })),
             });
         }
         ;
@@ -501,15 +433,15 @@ function transformNode2Expression(node, type) {
             if (['NewList', 'NewMap', 'NewEntity', 'NewStructure', 'NewAnonymousStructure'].includes(curCalleeName)) {
                 return handleNewExpression(curCalleeName, node, type);
             }
-            const nodeElement = new naslTypes.CallFunction({
+            const nodeElement = new utils_1.naslTypes.CallFunction({
                 calleeNamespace: 'nasl.util',
                 calleeName: curCalleeName,
-                arguments: argument.map((arg, index) => new naslTypes.Argument({
+                arguments: argument.map((arg, index) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                     keyword: `str${index + 1}`,
                 })),
-                typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
-                // typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType, typeNamespace })),
+                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+                // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
             });
             return nodeElement;
         }
@@ -519,15 +451,26 @@ function transformNode2Expression(node, type) {
                 const nsArr = namespace.split('.').map((item) => item.replace(/_view$/, ''));
                 const pageType = nsArr.shift();
                 const viewName = nsArr.pop();
-                return new naslTypes.Destination({
+                const newArguments = node?.arguments?.slice(1);
+                let argument = [];
+                if (newArguments?.[0]?.type === 'ObjectExpression') {
+                    argument = newArguments?.[0]?.properties?.map((property) => new utils_1.naslTypes.Argument({
+                        keyword: property?.key?.name,
+                        expression: fixExpression(property?.value, type),
+                    }));
+                }
+                else {
+                    argument = node.arguments.slice(1).map((arg) => new utils_1.naslTypes.Argument({
+                        expression: fixExpression(arg, type),
+                    }));
+                }
+                return new utils_1.naslTypes.Destination({
                     viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((item) => `.${item}.views`)?.join('')}`,
                     viewName,
-                    arguments: node.arguments.slice(1).map((arg) => new naslTypes.Argument({
-                        expression: transformNode2Expression(arg, type),
-                    })),
+                    arguments: argument,
                 });
             }
-            return new naslTypes.CallLogic({
+            return new utils_1.naslTypes.CallLogic({
                 calleeNamespace: 'nasl.ui',
                 calleeName: callee[2].name,
                 shortcut: true,
@@ -536,25 +479,25 @@ function transformNode2Expression(node, type) {
                  * @param node
                  * @returns
                  */
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
         }
         if (calleeName.endsWith('.map')) {
-            return new naslTypes.CallFunction({
+            return new utils_1.naslTypes.CallFunction({
                 calleeNamespace: 'nasl.util',
                 calleeName: 'ListTransform',
-                arguments: [new naslTypes.Argument({
+                arguments: [new utils_1.naslTypes.Argument({
                         expression: transformNode2Expression(node.callee.object, type),
-                    }), ...node?.arguments?.map((arg) => new naslTypes.Argument({
+                    }), ...node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                         expression: transformNode2Expression(arg, type),
                     }))],
             });
         }
         if (calleeName === 'PAGINATE') {
             const newCallee = node?.arguments || [];
-            return new naslTypes.Paginate({
+            return new utils_1.naslTypes.Paginate({
                 list: newCallee?.[0] && transformNode2Expression(newCallee?.[0], type),
                 page: newCallee?.[1] && transformNode2Expression(newCallee?.[1], type),
                 size: newCallee?.[2] && transformNode2Expression(newCallee?.[2], type),
@@ -563,15 +506,15 @@ function transformNode2Expression(node, type) {
         if (calleeName === 'ForEach') {
             const newCallee = node.arguments;
             const arrowFunction = node.arguments[3];
-            const nodeElement = new naslTypes.ForEachStatement({
+            const nodeElement = new utils_1.naslTypes.ForEachStatement({
                 each: transformNode2Expression(newCallee[0], type),
                 start: transformNode2Expression(newCallee[1], type),
                 end: transformNode2Expression(newCallee[2], type),
                 item: transformParam(arrowFunction.params[0]),
-                index: arrowFunction.params[1] ? transformParam(arrowFunction.params[1]) : new naslTypes.Param({
-                    name: 'index', typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Long'),
+                index: arrowFunction.params[1] ? transformParam(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
+                    name: 'index', typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
                 }),
-                body: arrowFunction.body.body.map((item) => transformNode2Expression(item, type)).filter((item) => !!item),
+                body: arrowFunction.body.body.map((item) => transformNode2Expression(item)).filter((item) => !!item && item?.concept !== 'Variable'),
             });
             return nodeElement;
         }
@@ -580,15 +523,15 @@ function transformNode2Expression(node, type) {
             if (curCalleeName === 'forEach') {
                 const newCallee = node.callee.object;
                 const arrowFunction = node.arguments[0];
-                const nodeElement = new naslTypes.ForEachStatement({
+                const nodeElement = new utils_1.naslTypes.ForEachStatement({
                     each: transformNode2Expression(newCallee.callee.object, type),
                     start: transformNode2Expression(newCallee?.arguments?.[0], type),
                     end: transformNode2Expression(newCallee?.arguments?.[1], type),
                     item: transformParam(arrowFunction.params[0]),
-                    index: arrowFunction.params[1] ? transformParam(arrowFunction.params[1]) : new naslTypes.Param({
-                        name: 'index', typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Long'),
+                    index: arrowFunction.params[1] ? transformParam(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
+                        name: 'index', typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
                     }),
-                    body: arrowFunction.body.body.map((item) => transformNode2Expression(item, type)).filter((item) => !!item),
+                    body: arrowFunction.body.body.map((item) => transformNode2Expression(item)).filter((item) => !!item && item?.concept !== 'Variable'),
                 });
                 return nodeElement;
             }
@@ -597,89 +540,89 @@ function transformNode2Expression(node, type) {
             return handleBinaryExpression(calleeName, node?.arguments);
         }
         else if (calleeName === 'alert') {
-            return new naslTypes.CallLogic({
+            return new utils_1.naslTypes.CallLogic({
                 calleeNamespace: 'nasl.ui',
                 calleeName: 'showMessage',
                 shortcut: true,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
         }
         else if (/^app.dataSources|app.logics/.test(calleeName)) {
             if (calleeName?.includes('.entities.')) {
-                const calleeNamespace = (0, generator_1.default)(node?.callee?.object?.object)?.code;
-                const entityName = node?.callee?.object?.property?.name?.replace(/Entity$/, '');
-                return new naslTypes.CallLogic({
+                const calleeNamespace = (0, utils_1.generate)(node?.callee?.object?.object)?.code;
+                const entityName = node?.callee?.object?.property?.name?.replace(/Entity/, '');
+                return new utils_1.naslTypes.CallLogic({
                     calleeNamespace: `${calleeNamespace}.${entityName}.logics`,
                     calleeName: node?.callee?.property?.name,
-                    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                    arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                         expression: transformNode2Expression(arg, type),
                     })),
                 });
             }
-            return new naslTypes.CallLogic({
-                calleeNamespace: (0, generator_1.default)(node.callee.object).code,
+            return new utils_1.naslTypes.CallLogic({
+                calleeNamespace: (0, utils_1.generate)(node.callee.object).code,
                 calleeName: callee[callee.length - 1].name,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
         }
         else if (callee.length === 1) {
             if (calleeName.startsWith('viewLogic_')) {
-                return new naslTypes.CallLogic({
+                return new utils_1.naslTypes.CallLogic({
                     calleeNamespace: '',
                     calleeName: calleeName.slice('viewLogic_'.length),
-                    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                    arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                         expression: transformNode2Expression(arg, type),
                     })),
                 });
             }
             if (calleeName === 'FROM') {
                 // TODO
-                return new naslTypes.CallLogic({
+                return new utils_1.naslTypes.CallLogic({
                     calleeNamespace: `app.logics`,
                     calleeName,
                     arguments: [],
                 });
             }
-            return new naslTypes.CallLogic({
-                calleeNamespace: `app.logics`,
+            return new utils_1.naslTypes.CallLogic({
+                calleeNamespace: ``,
                 calleeName,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
         }
         else if (/interfaces/.test(calleeName)) {
-            return new naslTypes.CallInterface({
-                calleeNamespace: (0, generator_1.default)(node.callee.object).code,
+            return new utils_1.naslTypes.CallInterface({
+                calleeNamespace: (0, utils_1.generate)(node.callee.object).code,
                 calleeName: callee[callee.length - 1].name,
-                arguments: node?.arguments?.map((arg) => arg?.properties?.map((item) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => arg?.properties?.map((item) => new utils_1.naslTypes.Argument({
                     keyword: item?.key?.name,
                     expression: transformNode2Expression(item?.value, type),
-                }))).flat(),
+                })) || []).flat() || [],
             });
         }
         else if (/connector./.test(calleeName)) {
-            const flatCalleeKey = (0, generator_1.default)(node?.callee)?.code;
+            const flatCalleeKey = (0, utils_1.generate)(node?.callee)?.code;
             const [, calleeConnectionName, calleeNamespace, calleeFunName] = flatCalleeKey?.match(/^(\w+)\.([\w.]+)\.(\w+)$/);
-            return new naslTypes.CallConnector({
+            return new utils_1.naslTypes.CallConnector({
                 calleeConnectionName,
                 calleeNamespace,
                 calleeName: calleeFunName,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
         }
         else if (/extensions./.test(calleeName)) {
-            return new naslTypes.CallLogic({
-                calleeNamespace: (0, generator_1.default)(node?.callee?.object)?.code,
+            return new utils_1.naslTypes.CallLogic({
+                calleeNamespace: (0, utils_1.generate)(node?.callee?.object)?.code,
                 calleeName: callee?.[callee?.length - 1]?.name,
                 handleError: true,
-                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
                     expression: transformNode2Expression(arg, type),
                 })),
             });
@@ -688,16 +631,16 @@ function transformNode2Expression(node, type) {
             // NOTE: 适用于 if else
             const newCallee = node.callee.body.body;
             if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFuntion') {
-                const match = new naslTypes.Match({
+                const match = new utils_1.naslTypes.Match({
                     expression: transformNode2Expression(newCallee[0], type),
                     isExpression: type !== 'logic',
-                    cases: flatIfStatement(newCallee[1].body.body[0]).map((_case) => new naslTypes.MatchCase({
+                    cases: flatIfStatement(newCallee[1].body.body[0]).map((_case) => new utils_1.naslTypes.MatchCase({
                         patterns: !_case.test ? [] : flatMatchPatternsExpression(transformNode2Expression(_case.test, type)),
                         body: _case.consequent.body.filter((item) => item.type !== 'BreakStatement').map((item) => transformNode2Expression(item, type)).filter((item) => !!item),
                     })),
                 });
                 if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
-                    match.cases.push(new naslTypes.MatchCase({
+                    match.cases.push(new utils_1.naslTypes.MatchCase({
                         patterns: [],
                         body: [],
                     }));
@@ -708,7 +651,7 @@ function transformNode2Expression(node, type) {
                     }
                     if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
                         case_.isMatchedTypeEnumable = true;
-                        case_.patterns[0] = new naslTypes.MemberExpression({
+                        case_.patterns[0] = new utils_1.naslTypes.MemberExpression({
                             object: {
                                 concept: 'Identifier',
                                 name: case_.patterns[0].object.property.name,
@@ -729,15 +672,24 @@ function transformNode2Expression(node, type) {
                 const switchStatement = transformNode2Expression(newCallee[0].body.body[0], type);
                 return switchStatement;
             }
-            throwError(`Unhandled ArrowFunctionExpression node ${node.type}`);
+            (0, utils_1.throwError)(`Unhandled ArrowFunctionExpression node ${node.type}`);
+        }
+        else if (/nasl.auth./.test(calleeName)) {
+            return new utils_1.naslTypes.CallLogic({
+                calleeNamespace: 'nasl.auth',
+                calleeName: callee[callee.length - 1].name,
+                arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+                    expression: transformNode2Expression(arg, type),
+                })),
+            });
         }
         else {
-            throwError(`Unhandled node ${callee.map((item) => item.name).join('.')} ${node.type}`);
+            (0, utils_1.throwError)(`Unhandled node ${callee.map((item) => item.name).join('.')} ${node.type}`);
         }
     }
     else if (node.type === 'IfStatement') {
         if (node.alternate && node.alternate.type === 'IfStatement') {
-            const switchStatement = new naslTypes.SwitchStatement({
+            const switchStatement = new utils_1.naslTypes.SwitchStatement({
                 cases: [],
             });
             pushElseIf(node, switchStatement);
@@ -745,7 +697,7 @@ function transformNode2Expression(node, type) {
         }
         let consequentIndex;
         let alternateIndex;
-        const naslNode = new naslTypes.IfStatement({
+        const naslNode = new utils_1.naslTypes.IfStatement({
             test: transformNode2Expression(node.test, type),
             consequent: !node.consequent ? [] : node.consequent.body.map((item, index) => {
                 if (item?.type === 'ReturnStatement') {
@@ -767,30 +719,30 @@ function transformNode2Expression(node, type) {
             }).filter((item) => !!item),
         });
         if (consequentIndex !== undefined) {
-            naslNode?.consequent?.splice(consequentIndex + 1, 0, new naslTypes.End());
+            naslNode?.consequent?.splice(consequentIndex + 1, 0, new utils_1.naslTypes.End());
         }
         if (alternateIndex !== undefined) {
-            naslNode?.alternate?.splice(alternateIndex + 1, 0, new naslTypes.End());
+            naslNode?.alternate?.splice(alternateIndex + 1, 0, new utils_1.naslTypes.End());
         }
         return naslNode;
     }
     else if (node.type === 'WhileStatement') {
-        return new naslTypes.WhileStatement({
+        return new utils_1.naslTypes.WhileStatement({
             test: transformNode2Expression(node.test, type),
             body: node.body.body.map((item) => transformNode2Expression(item, type)).filter((item) => !!item),
         });
     }
     else if (node.type === 'SwitchStatement') {
-        const match = new naslTypes.Match({
+        const match = new utils_1.naslTypes.Match({
             expression: transformNode2Expression(node.discriminant, type),
             isExpression: type !== 'logic',
-            cases: node.cases.map((_case) => new naslTypes.MatchCase({
+            cases: node.cases.map((_case) => new utils_1.naslTypes.MatchCase({
                 patterns: !_case.test ? [] : [transformNode2Expression(_case.test, type)],
                 body: _case.consequent.filter((item) => item.type !== 'BreakStatement').map((item) => transformNode2Expression(item, type)).filter((item) => !!item),
             })),
         });
         if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
-            match.cases.push(new naslTypes.MatchCase({
+            match.cases.push(new utils_1.naslTypes.MatchCase({
                 patterns: [],
                 body: [],
             }));
@@ -808,40 +760,59 @@ function transformNode2Expression(node, type) {
     }
     else if (node.type === 'MemberExpression') {
         const callee = flatMemberExpression(node);
-        const calleeName = (0, generator_1.default)(node)?.code;
+        const calleeName = (0, utils_1.generate)(node)?.code;
         if (calleeName?.includes('app.enums')) {
             const name = callee?.[3]?.value || callee?.[3]?.name || callee?.[3]?.value;
-            return new naslTypes.MemberExpression({
-                object: new naslTypes.Identifier({
+            return new utils_1.naslTypes.MemberExpression({
+                object: new utils_1.naslTypes.Identifier({
                     namespace: 'app.enums',
                     name: callee?.[2]?.name,
                 }),
-                property: new naslTypes.Identifier({
+                property: new utils_1.naslTypes.Identifier({
                     name: String(name),
                 }),
             });
         }
+        if (calleeName?.includes('nasl.auth.')) {
+            return new utils_1.naslTypes.MemberExpression({
+                object: new utils_1.naslTypes.Identifier({
+                    namespace: 'nasl.auth',
+                    name: callee?.[2]?.name,
+                }),
+                property: new utils_1.naslTypes.Identifier({
+                    name: callee?.[3]?.name,
+                }),
+            });
+        }
+        const regex = /^(app\..+?)\.variables\.(.+)$/;
+        if (regex.test(calleeName)) {
+            const [, namespace, variableName] = calleeName.match(regex);
+            return new utils_1.naslTypes.Identifier({
+                name: String(variableName),
+                namespace: `${namespace}.variables`
+            });
+        }
         if (node.property.type === 'NumericLiteral') {
-            return new naslTypes.CallFunction({
+            return new utils_1.naslTypes.CallFunction({
                 calleeNamespace: 'nasl.util',
                 calleeName: 'Get',
                 arguments: [
-                    new naslTypes.Argument({
+                    new utils_1.naslTypes.Argument({
                         expression: transformNode2Expression(node.object, type),
                     }),
-                    new naslTypes.Argument({
+                    new utils_1.naslTypes.Argument({
                         expression: transformNode2Expression(node.property, type),
                     }),
                 ],
             });
         }
-        return new naslTypes.MemberExpression({
+        return new utils_1.naslTypes.MemberExpression({
             object: transformNode2Expression(node.object, type),
             property: transformNode2Expression(node.property, type),
         });
     }
     else if (node.type === 'Identifier') {
-        return new naslTypes.Identifier({
+        return new utils_1.naslTypes.Identifier({
             name: node.name,
         });
     }
@@ -851,16 +822,16 @@ function transformNode2Expression(node, type) {
     else if (node.type === 'AssignmentExpression') {
         if (node.operator === '+=' || node.operator === '-=') {
             if (type === 'logic') {
-                return new naslTypes.Assignment({
+                return new utils_1.naslTypes.Assignment({
                     left: transformNode2Expression(node.left, type),
-                    right: new naslTypes.BinaryExpression({
+                    right: new utils_1.naslTypes.BinaryExpression({
                         operator: node.operator[0],
                         left: transformNode2Expression(node.left, type),
                         right: transformNode2Expression(node.right, type),
                     }),
                 });
             }
-            return new naslTypes.BinaryExpression({
+            return new utils_1.naslTypes.BinaryExpression({
                 operator: node.operator[0],
                 left: transformNode2Expression(node.left, type),
                 right: transformNode2Expression(node.right, type),
@@ -869,44 +840,44 @@ function transformNode2Expression(node, type) {
         if (type !== 'logic') {
             return transformNode2Expression(node.right, type);
         }
-        return new naslTypes.Assignment({
+        return new utils_1.naslTypes.Assignment({
             left: transformNode2Expression(node.left, type),
             right: transformNode2Expression(node.right, type),
         });
     }
     else if (node.type === 'NewExpression') {
-        const calleeName = (0, generator_1.default)(node.callee).code;
+        const calleeName = (0, utils_1.generate)(node.callee).code;
         if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
             return transformNode2Expression(node.arguments[0], type);
         }
-        throwError(`Unhandled node ${node.type}`);
+        (0, utils_1.throwError)(`Unhandled node ${node.type}`);
     }
     else if (node.type === 'ArrowFunctionExpression') {
-        return new naslTypes.AnonymousFunction({
+        return new utils_1.naslTypes.AnonymousFunction({
             params: node.params.map((param) => transformParam(param)),
             body: transformNode2Expression(node.body, type),
         });
     }
     else if (node.type === 'BooleanLiteral') {
-        return new naslTypes.BooleanLiteral({
+        return new utils_1.naslTypes.BooleanLiteral({
             value: String(node.value),
         });
     }
     else if (node.type === 'StringLiteral') {
-        return new naslTypes.StringLiteral({
+        return new utils_1.naslTypes.StringLiteral({
             value: node.value,
         });
     }
     else if (node.type === 'NumericLiteral') {
-        const literal = new naslTypes.NumericLiteral({
+        const literal = new utils_1.naslTypes.NumericLiteral({
             value: String(node.value),
-            typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Integer'),
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Integer'),
         });
         literal.typeAnnotation.typeName = literal.changeType(String(node.value));
         return literal;
     }
     else if (node.type === 'NullLiteral') {
-        return new naslTypes.NullLiteral();
+        return new utils_1.naslTypes.NullLiteral();
     }
     else if (node.type === 'TemplateLiteral') {
         const expressions = [...node.expressions, ...node.quasis.map((element) => ({
@@ -916,7 +887,7 @@ function transformNode2Expression(node, type) {
                 end: element.end,
             }))];
         expressions.sort((a, b) => a.start - b.start);
-        return new naslTypes.StringInterpolation({
+        return new utils_1.naslTypes.StringInterpolation({
             expressions: expressions.map((item) => transformNode2Expression(item, type)),
         });
     }
@@ -926,17 +897,17 @@ function transformNode2Expression(node, type) {
         if (node.operator === '!==')
             node.operator = '!=';
         if (['+', '-', '*', '/', '%', '==', '!=', '>', '<', '>=', '<=', '&&', '||', 'startwith', 'endwith', 'like', 'in'].includes(node.operator)) {
-            return new naslTypes.BinaryExpression({
+            return new utils_1.naslTypes.BinaryExpression({
                 operator: node.operator,
                 left: transformNode2Expression(node.left, type),
                 right: transformNode2Expression(node.right, type),
             });
         }
-        throwError(`Unhandled node ${node.type}`);
+        (0, utils_1.throwError)(`Unhandled node ${node.type}`);
     }
     else if (node.type === 'UnaryExpression') {
         if (['!'].includes(node.operator)) {
-            return new naslTypes.UnaryExpression({
+            return new utils_1.naslTypes.UnaryExpression({
                 operator: node.operator,
                 argument: transformNode2Expression(node.argument, type),
             });
@@ -947,18 +918,18 @@ function transformNode2Expression(node, type) {
                 value: -node.argument.value,
             }, type);
         }
-        throwError(`Unhandled node ${node.type}`);
+        (0, utils_1.throwError)(`Unhandled node ${node.type}`);
     }
     else if (node.type === 'UpdateExpression') {
         if (node.operator === '++' || node.operator === '--') {
-            return new naslTypes.Assignment({
+            return new utils_1.naslTypes.Assignment({
                 left: transformNode2Expression(node.argument, type),
-                right: new naslTypes.BinaryExpression({
+                right: new utils_1.naslTypes.BinaryExpression({
                     operator: node.operator[0],
                     left: transformNode2Expression(node.argument, type),
-                    right: new naslTypes.NumericLiteral({
+                    right: new utils_1.naslTypes.NumericLiteral({
                         value: '1',
-                        typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Integer'),
+                        typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Integer'),
                     }),
                 }),
             });
@@ -966,11 +937,11 @@ function transformNode2Expression(node, type) {
     }
     else if (node.type === 'ReturnStatement') {
         if (node?.ends) {
-            return new naslTypes.End();
+            return new utils_1.naslTypes.End();
         }
     }
     else if (node.type === 'EmptyStatement') {
-        return node.leadingComments && new naslTypes.Comment({
+        return node.leadingComments && new utils_1.naslTypes.Comment({
             value: String(node.leadingComments[0].value),
         });
     }
@@ -987,68 +958,95 @@ function transformNode2Expression(node, type) {
             if (arg.value.type === 'MemberExpression') {
                 const expression = flatMemberExpression(arg.value);
                 const members = flatMembers(transformNode2Expression(arg.value, type));
-                rights.push(new naslTypes.SelectMembers({
+                rights.push(new utils_1.naslTypes.SelectMembers({
                     expression: transformNode2Expression(expression[0]),
                     members,
                 }));
                 if (arg?.value) {
-                    assignmentLines.push(new naslTypes.AssignmentLine({
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
                         leftIndex: [0, index],
                         rightIndex: [index, members.length - 1],
                     }));
                 }
             }
             else {
-                rights.push(new naslTypes.SelectMembers({
+                rights.push(new utils_1.naslTypes.SelectMembers({
                     expression: transformNode2Expression(arg?.value, type)
                 }));
                 if (arg?.value) {
-                    assignmentLines.push(new naslTypes.AssignmentLine({
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
                         leftIndex: [0, index],
                         rightIndex: [index],
                     }));
                 }
             }
-            structureProperties.push(new naslTypes.StructureProperty({
+            structureProperties.push(new utils_1.naslTypes.StructureProperty({
                 name: arg?.key?.name,
                 typeAnnotation: null
             }));
         });
-        return new naslTypes.NewComposite({
-            typeAnnotation: naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
+        return new utils_1.naslTypes.NewComposite({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
             properties,
             rights,
             assignmentLines
         });
     }
     else {
-        throwError(`Unhandled node ${node.type}`);
+        (0, utils_1.throwError)(`Unhandled node ${node.type}`);
     }
 }
 // 处理逻辑
-function transformNode2Logic(node, name) {
+function transformNode2Logic(node, name, type) {
     const parameters = node.params;
     const statements = node.body.body;
-    const curLogic = new naslTypes.Logic({ name: name ?? node.id.name });
-    parameters.forEach((item) => {
-        const param = transformParam(item);
-        if (param && param.name !== 'event' && !curLogic.params.find((_) => _.name === param.name))
-            curLogic.addParam(param);
-    });
-    statements.forEach((item) => {
+    const curLogic = new utils_1.naslTypes.Logic({ name: name ?? node.id.name });
+    if (type !== 'event_logic') {
+        parameters.forEach((item) => {
+            const param = transformParam(item);
+            if (param && param.name !== 'event' && !curLogic.params.find((_) => _.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) => it.name === item?.argument?.name);
+                        if (curVariable) {
+                            curLogic.variables = curLogic?.variables?.filter((it) => it.name !== item?.argument?.name);
+                            curLogic.addReturn(curVariable);
+                        }
+                    }
+                }
+                else {
+                    if (!curLogic.returns.length) {
+                        curLogic.returns.push(new utils_1.naslTypes.Return({
+                            name: 'result',
+                        }));
+                    }
+                    const logicItem = new utils_1.naslTypes.Assignment({
+                        left: new utils_1.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 utils_1.naslTypes.Assignment({
+                        left: new utils_1.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');
@@ -1056,8 +1054,8 @@ function transformNode2Logic(node, name) {
                 if (logicItem.concept === 'Variable') {
                     if (!curLogic.variables.find((_) => _.name === logicItem.name))
                         curLogic.addVariable(logicItem);
-                    logicItem = new naslTypes.Assignment({
-                        left: new naslTypes.Identifier({ name: logicItem?.name }),
+                    logicItem = new utils_1.naslTypes.Assignment({
+                        left: new utils_1.naslTypes.Identifier({ name: logicItem?.name }),
                         right: logicItem.defaultValue?.expression || '',
                     });
                     if (logicItem.right)
@@ -1073,6 +1071,8 @@ function transformNode2Logic(node, name) {
 }
 // 处理属性
 function transformNode2Attribute(node) {
+    if (!node?.value || !node?.key)
+        return {};
     let item = {};
     let newNode = {};
     if (['StringLiteral', 'NumericLiteral'].includes(node.value.type)) {
@@ -1087,7 +1087,7 @@ function transformNode2Attribute(node) {
         item = {
             name: node.key.name,
             type: 'string',
-            value: (0, generator_1.default)(node.value.body).code,
+            value: (0, utils_1.generate)(node.value.body).code,
         };
     }
     else if (['CallExpression'].includes(node.value.type) && node.value?.callee?.name === 'sync') {
@@ -1098,6 +1098,35 @@ function transformNode2Attribute(node) {
             expression: transformNode2Expression(node.value.arguments[0]),
         };
     }
+    else if (['destination'].includes(node.key.name)) {
+        const namespace = node?.value?.arguments?.[0]?.value;
+        const nsArr = namespace.split('.').map((it) => it.replace(/_view$/, ''));
+        const pageType = nsArr.shift();
+        const viewName = nsArr.pop();
+        const newArguments = node?.value?.arguments?.slice(1);
+        let argument = [];
+        if (newArguments?.[0]?.type === 'ObjectExpression') {
+            argument = newArguments?.[0]?.properties?.map((property) => new utils_1.naslTypes.Argument({
+                keyword: property?.key?.name,
+                expression: fixExpression(property?.value),
+            }));
+        }
+        else {
+            argument = node?.arguments?.slice(1)?.map((arg) => new utils_1.naslTypes.Argument({
+                expression: fixExpression(arg),
+            }));
+        }
+        const destination = new utils_1.naslTypes.Destination({
+            viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((it) => `.${it}.views`)?.join('')}`,
+            viewName,
+            arguments: argument,
+        });
+        item = {
+            name: node?.key?.name,
+            type: 'dynamic',
+            destination,
+        };
+    }
     else {
         // ['TemplateLiteral', 'BooleanLiteral', 'NullLiteral', 'CallExpression']
         item = {
@@ -1112,7 +1141,7 @@ function transformNode2Attribute(node) {
         if (propertyName === 'tooltip') {
             item.rawName = 'v-tooltip';
         }
-        newNode = new naslTypes.BindDirective({ ...item, name: propertyName });
+        newNode = new utils_1.naslTypes.BindDirective({ ...item, name: propertyName });
     }
     else if (['_staticStyle'].includes(node.key.name)) {
         newNode = {
@@ -1124,11 +1153,11 @@ function transformNode2Attribute(node) {
     else if (['_color', '_backgroundColor', '_backgroundImage'].includes(node.key.name)) {
         // 样式属性
         const propertyName = node.key?.name?.replace(/^_/, '').replace(/([A-Z])/g, '-$1').toLowerCase();
-        newNode = new naslTypes.BindStyle({ ...item, name: propertyName });
+        newNode = new utils_1.naslTypes.BindStyle({ ...item, name: propertyName });
     }
     else {
         // 组件属性
-        newNode = new naslTypes.BindAttribute(item);
+        newNode = new utils_1.naslTypes.BindAttribute(item);
     }
     return newNode;
 }
@@ -1137,7 +1166,7 @@ function transformNode2ViewElement(node, componentName) {
     if (viewNode.type === 'ObjectExpression') {
         const tag = (0, lodash_1.kebabCase)(node?.callee.name);
         const name = componentName?.replace(/-/g, '_');
-        const newViewElement = new naslTypes.ViewElement({
+        const newViewElement = new utils_1.naslTypes.ViewElement({
             tag,
             name,
         });
@@ -1145,10 +1174,10 @@ function transformNode2ViewElement(node, componentName) {
             if (prop?.value?.type === 'ArrayExpression' && ['FunctionExpression', 'ArrowFunctionExpression'].includes(prop?.value?.elements?.[0]?.type)) {
                 // 事件逻辑
                 const eventName = prop?.key?.name?.replace(/^on/, '')?.toLowerCase();
-                const bindEvent = new naslTypes.BindEvent({ name: eventName });
+                const bindEvent = new utils_1.naslTypes.BindEvent({ name: eventName });
                 prop.value.elements.forEach((element) => {
                     const logicName = bindEvent.getLogicUniqueName();
-                    const curLogic = transformNode2Logic(element, logicName);
+                    const curLogic = transformNode2Logic(element, logicName, 'event_logic');
                     bindEvent.addLogic(curLogic);
                 });
                 newViewElement.addBindEvent(bindEvent);
@@ -1156,9 +1185,9 @@ function transformNode2ViewElement(node, componentName) {
             else if (['FunctionExpression', 'ArrowFunctionExpression'].includes(prop?.value?.type) && /^on/.test(prop.key.name)) {
                 // 事件逻辑
                 const eventName = prop?.key?.name?.replace(/^on/, '')?.toLowerCase();
-                const bindEvent = new naslTypes.BindEvent({ name: eventName });
+                const bindEvent = new utils_1.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)) {
@@ -1184,7 +1213,7 @@ function transformNode2ViewElement(node, componentName) {
                 }
                 else {
                     const slotScope = prop.value?.params[0]?.name || '';
-                    const newTemplateElement = new naslTypes.ViewElement({
+                    const newTemplateElement = new utils_1.naslTypes.ViewElement({
                         tag: 'template',
                         slotTarget,
                         slotScope,
@@ -1193,13 +1222,13 @@ function transformNode2ViewElement(node, componentName) {
                         prop.value.body.elements.forEach((element, index) => {
                             // $ref.componentName = new xxx({}) 形式，这种是标准的
                             if (element.type === 'AssignmentExpression' && element.right?.type === 'NewExpression') {
-                                newTemplateElement.name = `template_${(0, generator_2.genHash)(`${slotTarget}_template_${propIndex}_${name}`)}`;
+                                newTemplateElement.name = `template_${(0, generator_1.genHash)(`${slotTarget}_template_${propIndex}_${name}`)}`;
                                 const elementName = element?.left?.property?.name;
                                 newTemplateElement.addViewElement(transformNode2ViewElement(element.right, elementName));
                             }
                             // new xxx({}) 形式，这种是没有组件名称，为了兼容，自己建一个
                             if (element.type === 'NewExpression') {
-                                newTemplateElement.name = `template_${(0, generator_2.genHash)(`${slotTarget}_template_${propIndex}_${name}`)}`;
+                                newTemplateElement.name = `template_${(0, generator_1.genHash)(`${slotTarget}_template_${propIndex}_${name}`)}`;
                                 const eleTag = (0, lodash_1.kebabCase)(element?.callee.name);
                                 const eleName = `${eleTag}_${index}_${newTemplateElement.name}`;
                                 newTemplateElement.addViewElement(transformNode2ViewElement(element, eleName));
@@ -1235,12 +1264,18 @@ function transformNode2ViewConstruct(node) {
     // console.log("lemon ~ transformNode2ViewConstruct ~ node:", node);
     // 变量声明
     if (node.type === 'VariableDeclaration') {
+        const declList = node?.declarations || [];
+        const declListFirstNodde = declList[0];
+        const variableName = declListFirstNodde?.id?.name;
+        if (variableName === '$lifecycles' && declListFirstNodde.init) {
+            return transformLifecycle(declListFirstNodde.init);
+        }
         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') {
         return transformNode2ViewConstruct(node.expression);
@@ -1273,20 +1308,30 @@ function transformNode2ViewConstruct(node) {
             else {
                 properties?.[3].value.elements.forEach((element) => {
                     let newNode = {};
+                    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 });
                     }
-                    const newNodeBackup = (0, lodash_1.cloneDeep)(newNode);
-                    newNode.aiParams = {
-                        action: properties?.[0].value.value,
-                        selectedNodeName: properties?.[1].value.value,
-                        concept: properties?.[2].value.value,
-                        object: newNodeBackup
-                    };
-                    newViewElement.push(newNode);
+                    else if (properties?.[2]?.value?.value === 'BindEvent') {
+                        const eventName = element?.left?.name?.replace(/^on/, '')?.toLowerCase();
+                        const bindEvent = new utils_1.naslTypes.BindEvent({ name: eventName });
+                        const logicName = bindEvent.getLogicUniqueName();
+                        bindEvent.addLogic(transformNode2Logic(element?.right?.elements[0], logicName, 'event_logic'));
+                        newNode = bindEvent;
+                    }
+                    if (newNode) {
+                        const newNodeBackup = (0, lodash_1.cloneDeep)(newNode);
+                        newNode.aiParams = {
+                            action: properties?.[0].value.value,
+                            selectedNodeName: properties?.[1].value.value,
+                            concept: properties?.[2].value.value,
+                            object: newNodeBackup
+                        };
+                        newViewElement.push(newNode);
+                    }
                 });
             }
         });
@@ -1306,25 +1351,29 @@ function transformNode2View(node, root) {
     if (currentPositionComment) {
         statements = statements.filter((stat) => stat.start > currentPositionComment.start);
     }
-    const view = new naslTypes.View();
-    parameters.forEach((item) => {
+    const view = new utils_1.naslTypes.View();
+    parameters?.forEach((item) => {
         const param = transformParam(item);
+        view.params = view.params || [];
         param && view.params.push(param);
     });
     const json = [];
-    statements.forEach((item) => {
+    statements?.forEach((item) => {
         const viewItem = transformNode2ViewConstruct(item);
         if (item.type === 'ReturnStatement' && item?.argument?.type === 'CallExpression') {
             const action = item.argument?.callee?.name;
             const selectedNodeName = item.argument.arguments?.[0]?.property?.name;
-            const newNodeBackup = (0, lodash_1.cloneDeep)(viewItem);
-            viewItem.aiParams = { selectedNodeName, action, concept: 'ViewElement', object: newNodeBackup };
+            if (viewItem) {
+                const newNodeBackup = (0, lodash_1.cloneDeep)(viewItem);
+                viewItem.aiParams = { selectedNodeName, action, concept: 'ViewElement', object: newNodeBackup };
+            }
         }
         if (item.type === 'ReturnStatement' && item?.argument?.type === 'ArrayExpression') {
             viewItem?.forEach((element) => {
                 if (element.aiParams)
                     json.push(element.aiParams);
-                view.addViewElement(element);
+                if (element?.concept === 'ViewElement')
+                    view.addViewElement(element);
             });
         }
         if (viewItem?.concept === 'Variable') {
@@ -1340,6 +1389,12 @@ function transformNode2View(node, root) {
             if (viewItem.aiParams)
                 json.push(viewItem.aiParams);
         }
+        // 生命周期函数
+        if (item.type === 'VariableDeclaration' && Array.isArray(viewItem) && viewItem[0]?.concept === 'BindEvent') {
+            viewItem.forEach((bindEvent) => {
+                view.addBindEvent(bindEvent);
+            });
+        }
     });
     // console.log("lemon ~ 转换出的 view:", view);
     return { view: view.toJSON(), json };
@@ -1362,22 +1417,24 @@ const transformTS2View = (tsCode) => {
     // console.log("lemon ~ 初始 node", func);
     return transformNode2View(func, root);
 };
-const handleNodeName = (curView, object) => {
-    const list = [];
+const handleNodeName = (curView, object, memory) => {
+    const list = [...memory || []];
     if (object.concept === 'ViewElement') {
         const oldName = object.name;
         const newName = curView?.getViewElementUniqueNameOld(oldName);
         if (oldName !== newName) {
-            object.name = `${newName}_${(0, generator_2.genHash)(new Date().getTime() + newName)}`;
+            object.name = `${newName}_${(0, generator_1.genHash)(new Date().getTime() + newName)}`;
             list.push({ oldName, newName: object.name });
         }
         if (object?.children?.length) {
             object.children.forEach((child) => {
-                handleNodeName(curView, child);
+                const { list: childList } = handleNodeName(curView, child, list);
+                // 去重并合并
+                list.push(...childList?.filter((item) => !list?.find((it) => it.oldName === item.oldName)));
             });
         }
     }
-    return { object, list };
+    return { list };
 };
 function tryTransformTS2UI(tsCode, curView) {
     if (tsCode.includes('```')) {
@@ -1387,7 +1444,7 @@ function tryTransformTS2UI(tsCode, curView) {
     }
     if (!curView)
         return transformTS2View(tsCode);
-    const newView = new naslTypes.View(curView);
+    const newView = new utils_1.naslTypes.View(curView);
     const { json } = transformTS2View(tsCode);
     const replaceNameList = [];
     const selectedNodeNames = [];