@lcap/nasl 3.7.0-beta.8 → 3.7.1-alpha.1

package/out/natural/transformTS2UI.js

@@ -0,0 +1,1173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 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);
+}
+function flatMemberExpression(node) {
+    if (node.type === 'MemberExpression')
+        return [...flatMemberExpression(node.object), node.property];
+    return [node];
+}
+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];
+        }
+    }
+}
+// 处理类型
+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 (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/.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;
+    return new naslTypes.Param({
+        name: node.name,
+        typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
+    });
+}
+// 处理变量
+function transformVariableDeclaration(node) {
+    const declList = node?.declarations || [];
+    let newNode;
+    declList?.forEach((decl) => {
+        const variableName = decl.id.name;
+        const varTypeAnnotation = decl.id.typeAnnotation?.typeAnnotation;
+        newNode = new naslTypes.Variable({
+            name: variableName,
+            typeAnnotation: varTypeAnnotation && transformTypeAnnotation(varTypeAnnotation),
+        });
+        if (decl.init) {
+            if (decl.init.type !== 'ArrayExpression' && decl.init.type !== 'ObjectExpression') {
+                // 变量值需要默认值还是赋值，在使用的地方处理
+                newNode.defaultValue = new naslTypes.DefaultValue({
+                    expression: transformNode2Expression(decl.init),
+                });
+            }
+        }
+    });
+    return newNode;
+}
+// 处理 if
+function pushElseIf(ifNode, switchStatement) {
+    switchStatement.cases.push(new naslTypes.SwitchCase({
+        test: transformNode2Expression(ifNode.test),
+        consequent: !ifNode.consequent ? [] : ifNode.consequent.body.map((item) => transformNode2Expression(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) => transformNode2Expression(item)).filter((item) => !!item),
+        }));
+    }
+}
+// 处理运算
+function handleBinaryExpression(calleeName, argument) {
+    const map = {
+        plus: '+',
+        minus: '-',
+        multiply: '*',
+        divide: '/',
+        remainder: '%',
+    };
+    return new naslTypes.BinaryExpression({
+        operator: map?.[calleeName],
+        left: transformNode2Expression(argument?.[0]),
+        right: transformNode2Expression(argument?.[1]),
+    });
+}
+// 处理数据结构
+function handleNewExpression(calleeName, node, type) {
+    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) => transformNode2Expression(arg, type)),
+        });
+    }
+    if (calleeName === 'NewMap') {
+        const keys = [];
+        const values = [];
+        node?.arguments?.[0]?.properties.forEach((arg) => {
+            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),
+            }),
+            keys,
+            values,
+        });
+    }
+    if (calleeName === 'NewEntity') {
+        const properties = [];
+        const rights = [];
+        const assignmentLines = [];
+        node?.arguments?.[0]?.properties.forEach((arg, index) => {
+            properties.push(transformNode2Expression(arg.key));
+            rights.push(new naslTypes.SelectMembers({
+                expression: transformNode2Expression(arg.value)
+            }));
+            if (arg?.value) {
+                assignmentLines.push(new naslTypes.AssignmentLine({
+                    leftIndex: [0, index],
+                    rightIndex: [index],
+                }));
+            }
+        });
+        const typeName = node?.typeParameters?.params?.[0]?.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(transformNode2Expression(arg.key));
+            rights.push(new naslTypes.SelectMembers({
+                expression: transformNode2Expression(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(transformNode2Expression(arg.key));
+            rights.push(new naslTypes.SelectMembers({
+                expression: transformNode2Expression(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 transformNode2Expression(node, type) {
+    if (!node)
+        return null;
+    fixLogicNode(node);
+    // console.log('lemon ~~~ transformNode2Expression:', node);
+    if (node.type === 'VariableDeclaration') {
+        return transformVariableDeclaration(node);
+    }
+    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 ~~~ CallExpression', 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: transformNode2Expression(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({
+                calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
+                calleeName: callee[1].name,
+                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                    expression: transformNode2Expression(arg, type),
+                })),
+            });
+        }
+        if (calleeName === 'nasl.util.consoleLog' || calleeName === 'console.log') {
+            return new naslTypes.CallLogic({
+                calleeNamespace: 'nasl.util',
+                calleeName: 'consoleLog',
+                shortcut: true,
+                arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                    expression: transformNode2Expression(arg, type),
+                })),
+            });
+        }
+        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: transformNode2Expression(arg, type),
+                })),
+            });
+        }
+        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: transformNode2Expression(arg, type),
+                })),
+                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, type);
+            }
+            const nodeElement = new naslTypes.CallFunction({
+                calleeNamespace: 'nasl.util',
+                calleeName: curCalleeName,
+                arguments: argument.map((arg, index) => new 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 })),
+            });
+            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('')}`,
+                    viewName,
+                    arguments: node.arguments.slice(1).map((arg) => new naslTypes.Argument({
+                        expression: transformNode2Expression(arg, type),
+                    })),
+                });
+            }
+            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: transformNode2Expression(arg, type),
+                })),
+            });
+        }
+        if (calleeName.endsWith('.map')) {
+            return new naslTypes.CallFunction({
+                calleeNamespace: 'nasl.util',
+                calleeName: 'ListTransform',
+                arguments: [new naslTypes.Argument({
+                        expression: transformNode2Expression(node.callee.object, type),
+                    }), ...node?.arguments?.map((arg) => new naslTypes.Argument({
+                        expression: transformNode2Expression(arg, type),
+                    }))],
+            });
+        }
+        if (calleeName === 'PAGINATE') {
+            const newCallee = node?.arguments || [];
+            return new naslTypes.Paginate({
+                list: newCallee?.[0] && transformNode2Expression(newCallee?.[0], type),
+                page: newCallee?.[1] && transformNode2Expression(newCallee?.[1], type),
+                size: newCallee?.[2] && transformNode2Expression(newCallee?.[2], type),
+            });
+        }
+        if (calleeName === 'ForEach') {
+            const newCallee = node.arguments;
+            const arrowFunction = node.arguments[3];
+            const nodeElement = new 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'),
+                }),
+                body: arrowFunction.body.body.map((item) => transformNode2Expression(item, type)).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: 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'),
+                    }),
+                    body: arrowFunction.body.body.map((item) => transformNode2Expression(item, type)).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: 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({
+                    calleeNamespace: `${calleeNamespace}.${entityName}.logics`,
+                    calleeName: node?.callee?.property?.name,
+                    arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
+                        expression: transformNode2Expression(arg, type),
+                    })),
+                });
+            }
+            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: transformNode2Expression(arg, type),
+                })),
+            });
+        }
+        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: transformNode2Expression(arg, type),
+                    })),
+                });
+            }
+            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: transformNode2Expression(arg, type),
+                })),
+            });
+        }
+        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: transformNode2Expression(item?.value, type),
+                }))).flat(),
+            });
+        }
+        else if (/connector./.test(calleeName)) {
+            const flatCalleeKey = (0, generator_1.default)(node?.callee)?.code;
+            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: transformNode2Expression(arg, type),
+                })),
+            });
+        }
+        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: transformNode2Expression(arg, type),
+                })),
+            });
+        }
+        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: transformNode2Expression(newCallee[0], type),
+                    isExpression: type !== 'logic',
+                    cases: flatIfStatement(newCallee[1].body.body[0]).map((_case) => new 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({
+                        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 = transformNode2Expression(newCallee[0].body.body[0], type);
+                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: transformNode2Expression(node.test, type),
+            consequent: !node.consequent ? [] : node.consequent.body.map((item, index) => {
+                if (item?.type === 'ReturnStatement') {
+                    item.ends = true;
+                    if (item?.argument) {
+                        consequentIndex = index;
+                    }
+                }
+                return transformNode2Expression(item, type);
+            }).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 transformNode2Expression(item, type);
+            }).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: 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({
+            expression: transformNode2Expression(node.discriminant, type),
+            isExpression: type !== 'logic',
+            cases: node.cases.map((_case) => new 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({
+                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')) {
+            return new naslTypes.MemberExpression({
+                object: new naslTypes.Identifier({
+                    namespace: 'app.enums',
+                    name: callee?.[2]?.name,
+                }),
+                property: new naslTypes.Identifier({
+                    name: callee?.[3]?.value || callee?.[3]?.name,
+                }),
+            });
+        }
+        if (node.property.type === 'NumericLiteral') {
+            return new naslTypes.CallFunction({
+                calleeNamespace: 'nasl.util',
+                calleeName: 'Get',
+                arguments: [
+                    new naslTypes.Argument({
+                        expression: transformNode2Expression(node.object, type),
+                    }),
+                    new naslTypes.Argument({
+                        expression: transformNode2Expression(node.property, type),
+                    }),
+                ],
+            });
+        }
+        return new naslTypes.MemberExpression({
+            object: transformNode2Expression(node.object, type),
+            property: transformNode2Expression(node.property, type),
+        });
+    }
+    else if (node.type === 'Identifier') {
+        return new naslTypes.Identifier({
+            name: node.name,
+        });
+    }
+    else if (node.type === 'ExpressionStatement') {
+        return transformNode2Expression(node.expression, type);
+    }
+    else if (node.type === 'AssignmentExpression') {
+        if (node.operator === '+=' || node.operator === '-=') {
+            if (type === 'logic') {
+                return new naslTypes.Assignment({
+                    left: transformNode2Expression(node.left, type),
+                    right: new naslTypes.BinaryExpression({
+                        operator: node.operator[0],
+                        left: transformNode2Expression(node.left, type),
+                        right: transformNode2Expression(node.right, type),
+                    }),
+                });
+            }
+            return new naslTypes.BinaryExpression({
+                operator: node.operator[0],
+                left: transformNode2Expression(node.left, type),
+                right: transformNode2Expression(node.right, type),
+            });
+        }
+        if (type !== 'logic') {
+            return transformNode2Expression(node.right, type);
+        }
+        return new 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;
+        if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
+            return transformNode2Expression(node.arguments[0], type);
+        }
+        throwError(`Unhandled node ${node.type}`);
+    }
+    else if (node.type === 'ArrowFunctionExpression') {
+        return new naslTypes.AnonymousFunction({
+            params: node.params.map((param) => transformParam(param)),
+            body: transformNode2Expression(node.body, type),
+        });
+    }
+    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: 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) => transformNode2Expression(item, type)),
+        });
+    }
+    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: transformNode2Expression(node.left, type),
+                right: transformNode2Expression(node.right, type),
+            });
+        }
+        throwError(`Unhandled node ${node.type}`);
+    }
+    else if (node.type === 'UnaryExpression') {
+        if (['!'].includes(node.operator)) {
+            return new naslTypes.UnaryExpression({
+                operator: node.operator,
+                argument: transformNode2Expression(node.argument, type),
+            });
+        }
+        if (['-'].includes(node.operator) && node.argument.type === 'NumericLiteral') {
+            return transformNode2Expression({
+                type: 'NumericLiteral',
+                value: -node.argument.value,
+            }, type);
+        }
+        throwError(`Unhandled node ${node.type}`);
+    }
+    else if (node.type === 'UpdateExpression') {
+        if (node.operator === '++' || node.operator === '--') {
+            return new naslTypes.Assignment({
+                left: transformNode2Expression(node.argument, type),
+                right: new naslTypes.BinaryExpression({
+                    operator: node.operator[0],
+                    left: transformNode2Expression(node.argument, type),
+                    right: new naslTypes.NumericLiteral({
+                        value: '1',
+                        typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Integer'),
+                    }),
+                }),
+            });
+        }
+    }
+    else if (node.type === 'ReturnStatement') {
+        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 transformNode2Expression(node?.body?.[0], type);
+    }
+    else if (node.type === 'ObjectExpression' && node?.properties?.length > 0) {
+        const properties = [];
+        const rights = [];
+        const structureProperties = [];
+        const assignmentLines = [];
+        node?.properties?.forEach((arg, index) => {
+            properties.push(transformNode2Expression(arg.key, type));
+            rights.push(new naslTypes.SelectMembers({
+                expression: transformNode2Expression(arg?.value, type)
+            }));
+            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}`);
+    }
+}
+// 处理逻辑
+function transformNode2Logic(node, name) {
+    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, index) => {
+        if (item.type === 'ReturnStatement' && item?.argument) {
+            if (!curLogic.returns.length) {
+                curLogic.returns.push(new naslTypes.Return({
+                    name: 'result',
+                }));
+            }
+            const logicItem = new naslTypes.Assignment({
+                left: new naslTypes.Identifier({
+                    name: curLogic.returns[0].name,
+                }),
+                right: transformNode2Expression(item.argument, 'logic')
+            });
+            curLogic.insertItemInBodyAt(logicItem, index + 1);
+        }
+        else {
+            let logicItem = transformNode2Expression(item, 'logic');
+            if (logicItem) {
+                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 }),
+                        right: logicItem.defaultValue?.expression || '',
+                    });
+                }
+                curLogic.insertItemInBodyAt(logicItem, index + 1);
+            }
+        }
+    });
+    return curLogic;
+}
+function transformNode2ViewElement(node, componentName) {
+    const viewNode = node.arguments?.[0];
+    if (viewNode.type === 'ObjectExpression') {
+        const tag = (0, lodash_1.kebabCase)(node?.callee.name);
+        const name = componentName?.replace(/-/g, '_');
+        const newViewElement = new naslTypes.ViewElement({
+            tag,
+            name,
+        });
+        viewNode.properties.forEach((prop, propIndex) => {
+            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 });
+                prop.value.elements.forEach((element) => {
+                    const logicName = bindEvent.getLogicUniqueName();
+                    const curLogic = transformNode2Logic(element, logicName);
+                    bindEvent.addLogic(curLogic);
+                });
+                newViewElement.addBindEvent(bindEvent);
+            }
+            else if (['FunctionExpression', 'ArrowFunctionExpression'].includes(prop.value.type) && ['ArrayExpression'].includes(prop.value.body?.type)) {
+                // 子组件
+                const slotTarget = prop.key.name.replace(/^slot/, '').toLowerCase();
+                if (slotTarget === 'default') {
+                    // 默认插槽，不需要 template
+                    if (prop.value.body?.elements?.length) {
+                        prop.value.body.elements.forEach((element, index) => {
+                            // $ref.componentName = new xxx({}) 形式，这种是标准的
+                            if (element.type === 'AssignmentExpression' && element.right?.type === 'NewExpression') {
+                                const elementName = element?.left?.property?.name;
+                                newViewElement.addViewElement(transformNode2ViewElement(element.right, elementName));
+                            }
+                            // new xxx({}) 形式，这种是没有组件名称，为了兼容，自己建一个
+                            if (element.type === 'NewExpression') {
+                                const eleTag = (0, lodash_1.kebabCase)(element?.callee.name);
+                                const eleName = `${eleTag}_${index}_${newViewElement.name}`;
+                                newViewElement.addViewElement(transformNode2ViewElement(element, eleName));
+                            }
+                        });
+                    }
+                }
+                else {
+                    const slotScope = prop.value?.params[0]?.name || '';
+                    const newTemplateElement = new naslTypes.ViewElement({
+                        tag: 'template',
+                        slotTarget,
+                        slotScope,
+                    });
+                    if (prop.value.body?.elements?.length) {
+                        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}`)}`;
+                                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}`)}`;
+                                const eleTag = (0, lodash_1.kebabCase)(element?.callee.name);
+                                const eleName = `${eleTag}_${index}_${newTemplateElement.name}`;
+                                newTemplateElement.addViewElement(transformNode2ViewElement(element, eleName));
+                            }
+                        });
+                    }
+                    newViewElement.addViewElement(newTemplateElement);
+                }
+            }
+            else {
+                // 属性
+                if (['StringLiteral', 'NumericLiteral'].includes(prop.value.type)) {
+                    newViewElement.addBindAttribute(new naslTypes.BindAttribute({
+                        name: prop.key.name,
+                        type: 'string',
+                        value: prop.value.value,
+                    }));
+                }
+                else if (['ArrowFunctionExpression'].includes(prop.value.type)) {
+                    newViewElement.addBindAttribute(new naslTypes.BindAttribute({
+                        name: prop.key.name,
+                        type: 'string',
+                        value: (0, generator_1.default)(prop.value.body.property).code,
+                    }));
+                }
+                else {
+                    // ['TemplateLiteral', 'BooleanLiteral', 'NullLiteral', 'CallExpression']
+                    newViewElement.addBindAttribute(new naslTypes.BindAttribute({
+                        name: prop.key.name,
+                        type: 'dynamic',
+                        expression: transformNode2Expression(prop.value),
+                    }));
+                }
+            }
+        });
+        return newViewElement;
+    }
+}
+/**
+ * 转换Node为View下的构件
+*/
+function transformNode2ViewConstruct(node) {
+    // console.log("lemon ~ transformNode2ViewConstruct ~ node:", node);
+    // 变量声明
+    if (node.type === 'VariableDeclaration') {
+        return transformVariableDeclaration(node);
+    }
+    // 页面逻辑
+    if (node.type === 'FunctionDeclaration') {
+        const logicName = node.id.name.replace(/^viewLogic_/, '');
+        return transformNode2Logic(node, logicName);
+    }
+    if (node.type === 'ExpressionStatement') {
+        return transformNode2ViewConstruct(node.expression);
+    }
+    // 组件
+    if (node.type === 'AssignmentExpression' && node.right?.type === 'NewExpression') {
+        const componentName = node?.left?.property?.name;
+        return transformNode2ViewElement(node.right, componentName);
+    }
+    if (node.type === 'ReturnStatement' && node?.argument?.type === 'CallExpression') {
+        return transformNode2ViewConstruct(node.argument.arguments?.[1]);
+    }
+    // throwError(`Unhandled node ${node}`);
+    console.error('warning: Unhandled node', node);
+    return null;
+}
+/**
+ * 转换Node为View
+*/
+function transformNode2View(node, root) {
+    const parameters = node.params;
+    let statements = node.body.body;
+    const currentPositionComment = root?.comments.find((comment) => comment.type === 'CommentLine' && comment.value === ' 当前页面');
+    if (currentPositionComment) {
+        statements = statements.filter((stat) => stat.start > currentPositionComment.start);
+    }
+    const view = new naslTypes.View();
+    parameters.forEach((item) => {
+        const param = transformParam(item);
+        param && view.params.push(param);
+    });
+    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;
+            view.aiParams = { selectedNodeName, action };
+        }
+        if (viewItem?.concept === 'Variable') {
+            if (!view.variables.find((_) => _.name === viewItem.name))
+                view.addVariable(viewItem);
+        }
+        if (viewItem?.concept === 'Logic') {
+            if (!view.logics.find((_) => _.name === viewItem.name))
+                view.addLogic(viewItem);
+        }
+        if (viewItem?.concept === 'ViewElement') {
+            // viewItem.name = view.getViewElementUniqueName(viewItem.name);
+            view.addViewElement(viewItem);
+        }
+    });
+    // console.log("lemon ~ 转换出的 view:", view);
+    return view;
+}
+/**
+ * 转换ts代码为View
+*/
+const transformTS2View = (tsCode) => {
+    const root = babel.parseSync(tsCode, {
+        filename: 'result.ts',
+        presets: [require('@babel/preset-typescript')],
+    });
+    let func;
+    if (root.program?.body[0]?.type === 'ExportNamedDeclaration') {
+        func = root.program?.body[0]?.declaration;
+    }
+    else {
+        func = root.program?.body[0];
+    }
+    // console.log("lemon ~ 初始 node", func);
+    return transformNode2View(func, root);
+};
+function tryTransformTS2UI(tsCode) {
+    if (tsCode.includes('```')) {
+        const cap = tsCode.match(/```.*\n([\s\S]+?)```/);
+        if (cap)
+            tsCode = cap[1].trim();
+    }
+    const view = transformTS2View(tsCode);
+    return {
+        view,
+        ...view.aiParams
+    };
+}
+exports.tryTransformTS2UI = tryTransformTS2UI;
+//# sourceMappingURL=transformTS2UI.js.map