@lcap/nasl 3.9.0-beta.2 → 3.9.0-beta.20

package/out/natural/transformTSCode.js

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