@lcap/nasl 4.1.0-creator.1 → 4.1.0-creator.10

package/out/natural/parseNaturalTSXView.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNaturalTSXView = exports.transform2View = exports.transformJSXElement2ViewElement = exports.transform2Variables = void 0;
+exports.parseNaturalTSXView = exports.transformTSDeclareFunction2View = exports.transform2View = exports.transformJSXElement2ViewElement = exports.transform2Variables = void 0;
 /* eslint-disable global-require */
 /* eslint-disable @typescript-eslint/no-use-before-define */
 const utils_1 = require("./transforms/utils");
@@ -35,19 +35,19 @@ const transform2LogicItem_1 = require("./transforms/transform2LogicItem");
 const transform2Logic_1 = require("./transforms/transform2Logic");
 const transform2ValidationRule_1 = require("./transforms/transform2ValidationRule");
 const transformThemeAndStyle_1 = require("./transforms/transformThemeAndStyle");
-function transform2Variables(node) {
+function transform2Variables(node, options) {
     const variables = [];
     const declList = node?.declarations || [];
     declList.forEach((decl) => {
         const variableName = decl.id.name;
-        let typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(decl.id.typeAnnotation?.typeAnnotation);
+        let typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(decl.id.typeAnnotation?.typeAnnotation, options) || undefined;
         const variable = new utils_1.naslTypes.Variable({
             name: variableName,
             typeAnnotation,
         });
         if (decl.init) {
             variable.defaultValue = new utils_1.naslTypes.DefaultValue({
-                expression: (0, transform2LogicItem_1.transform2LogicItem)(decl.init, { transformType: 'attr', typeAnnotation, isRestricted: true, isInFrontend: true }),
+                expression: (0, transform2LogicItem_1.transform2LogicItem)(decl.init, { ...options, transformType: 'attr', typeAnnotation, isRestricted: true, isInFrontend: true }),
             });
         }
         variables.push(variable);
@@ -55,31 +55,35 @@ function transform2Variables(node) {
     return variables;
 }
 exports.transform2Variables = transform2Variables;
-function transform2EventLogics(node, eventName) {
+function transform2EventLogics(node, eventName, options) {
     if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
-        return [(0, transform2Logic_1.transform2Logic)(node, eventName)];
+        const logic = (0, transform2Logic_1.transform2Logic)(node, eventName, options);
+        logic.params = [];
+        return [logic];
     }
     else if (node.type === 'CallExpression') {
         if (node.callee.type === 'Identifier' && node.callee.name === '$all') {
             const args = node.arguments;
             return args.map((node) => {
                 if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
-                    return (0, transform2Logic_1.transform2Logic)(node, eventName);
+                    const logic = (0, transform2Logic_1.transform2Logic)(node, eventName, options);
+                    logic.params = [];
+                    return logic;
                 }
                 else {
-                    (0, utils_1.throwError)('事件逻辑参数不支持的类型', node.type, node);
+                    return (0, utils_1.throwError)(options?.parsingId, '事件逻辑参数不支持的类型', node.type, node);
                 }
-            });
+            }).filter(Boolean);
         }
         else {
-            (0, utils_1.throwError)('事件逻辑参数不正确', node);
+            return (0, utils_1.throwError)(options?.parsingId, '事件逻辑参数不正确', node);
         }
     }
     else {
-        (0, utils_1.throwError)('事件逻辑参数不正确', node);
+        return (0, utils_1.throwError)(options?.parsingId, '事件逻辑参数不正确', node);
     }
 }
-function transformJSXElement2ViewElement(node) {
+function transformJSXElement2ViewElement(node, options) {
     const el = node.openingElement;
     if (el.name.type === 'JSXIdentifier') {
         let tag = (0, lodash_1.kebabCase)(el.name.name);
@@ -101,41 +105,61 @@ function transformJSXElement2ViewElement(node) {
         function addJSXChild(node, slotTarget = 'default', slotScope = '') {
             if (node.type === 'JSXElement') {
                 if (slotTarget === 'default' && !slotScope) {
-                    viewElement.children.push(transformJSXElement2ViewElement(node));
+                    const child = transformJSXElement2ViewElement(node, options);
+                    child && viewElement.children.push(child);
                 }
                 else {
-                    viewElement.children.push(new utils_1.naslTypes.ViewElement({
+                    const child = transformJSXElement2ViewElement(node, options);
+                    let templateName = 'template_' + (0, utils_2.uuidv4)().slice(0, 5);
+                    // 确保模板名称也不重复
+                    while (options.nameMap.has(templateName)) {
+                        templateName = 'template_' + (0, utils_2.uuidv4)().slice(0, 5);
+                    }
+                    options.nameMap.set(templateName, true);
+                    const templateChild = new utils_1.naslTypes.ViewElement({
                         tag: 'template',
-                        name: 'template_' + (0, utils_2.uuidv4)().slice(0, 5),
+                        name: templateName,
                         slotTarget,
                         slotScope,
-                        children: [transformJSXElement2ViewElement(node)],
-                    }));
+                        children: child ? [child] : [],
+                    });
+                    if (viewElement.children.some((child) => child.tag === 'template' && child.slotTarget === slotTarget))
+                        (0, utils_1.throwError)(options?.parsingId, `slot${(0, utils_2.firstUpperCase)(slotTarget)} 不能重复`, node);
+                    viewElement.children.push(templateChild);
                 }
             }
             else if (node.type === 'JSXFragment') {
                 const children = node.children;
                 if (slotTarget === 'default' && !slotScope) {
-                    viewElement.children.push(...children.filter((child) => child.type === 'JSXElement').map(transformJSXElement2ViewElement));
+                    viewElement.children.push(...children.filter((child) => child.type === 'JSXElement').map((child) => transformJSXElement2ViewElement(child, options)).filter(Boolean));
                 }
                 else {
-                    viewElement.children.push(new utils_1.naslTypes.ViewElement({
+                    let templateName = 'template_' + (0, utils_2.uuidv4)().slice(0, 5);
+                    // 确保模板名称也不重复
+                    while (options.nameMap.has(templateName)) {
+                        templateName = 'template_' + (0, utils_2.uuidv4)().slice(0, 5);
+                    }
+                    options.nameMap.set(templateName, true);
+                    const templateChild = new utils_1.naslTypes.ViewElement({
                         tag: 'template',
-                        name: 'template_' + (0, utils_2.uuidv4)().slice(0, 5),
+                        name: templateName,
                         slotTarget,
                         slotScope,
-                        children: children.filter((child) => child.type === 'JSXElement').map(transformJSXElement2ViewElement),
-                    }));
+                        children: children.filter((child) => child.type === 'JSXElement').map((child) => transformJSXElement2ViewElement(child, options)).filter(Boolean),
+                    });
+                    if (viewElement.children.some((child) => child.tag === 'template' && child.slotTarget === slotTarget))
+                        (0, utils_1.throwError)(options?.parsingId, `slot${(0, utils_2.firstUpperCase)(slotTarget)} 不能重复`, node);
+                    viewElement.children.push(templateChild);
                 }
             }
             else {
-                (0, utils_1.throwError)('不支持的JSX子元素类型', node);
+                return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX子元素类型', node);
             }
         }
         function addArrowFunctionJSXChild(node, slotTarget = 'default') {
             const slotScopeName = node.params[0]?.name;
             if (slotScopeName && slotScopeName !== 'current' && !slotScopeName?.startsWith('current')) {
-                (0, utils_1.throwError)(`slotScope 需以 current 开头`, node);
+                return (0, utils_1.throwError)(options?.parsingId, `slotScope 需以 current 参数名开头`, node);
             }
             let slotScope = '';
             if (slotScopeName) {
@@ -152,51 +176,62 @@ function transformJSXElement2ViewElement(node) {
                 });
             }
             else {
-                (0, utils_1.throwError)('不支持的JSX子元素类型', body.type, body);
+                return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX子元素类型', body.type, body);
             }
         }
         attrs.forEach((attr) => {
             if (attr.type === 'JSXAttribute') {
                 const attrName = attr.name.name;
                 if (attrName === 'ref') {
-                    if (attr.value.type === 'StringLiteral') {
-                        viewElement.name = attr.value.value;
+                    if (attr.value?.type === 'StringLiteral') {
+                        const proposedName = attr.value.value;
+                        if (options.nameMap.has(proposedName)) {
+                            return (0, utils_1.throwError)(options?.parsingId, `ref 属性值 "${proposedName}" 已存在，不能重复使用`, attr);
+                        }
+                        viewElement.name = proposedName;
+                        options.nameMap.set(proposedName, true);
                     }
                     else {
-                        (0, utils_1.throwError)('ref 属性值不正确', attr.value);
+                        return (0, utils_1.throwError)(options?.parsingId, 'ref 属性值不正确', attr.value);
                     }
                 }
                 else if (attrName === 'style') {
-                    if (attr.value.type === 'StringLiteral') {
+                    if (attr.value?.type === 'StringLiteral') {
                         viewElement.staticStyle = attr.value.value;
                     }
                     else {
-                        (0, utils_1.throwError)('style 属性只能用字符串字面量', attr.value);
+                        return (0, utils_1.throwError)(options?.parsingId, 'style 属性只能用字符串字面量', attr.value);
                     }
                 }
                 else if (attrName === '$extraStyle') {
-                    if (attr.value.type === 'StringLiteral') {
-                        viewElement.cssRules = (0, transformThemeAndStyle_1.transformStyle)(attr.value.value);
+                    if (!attr.value) {
+                        (0, utils_1.throwError)(options?.parsingId, '$extraStyle 属性只能用字符串字面量', attr);
+                    }
+                    else if (attr.value.type === 'StringLiteral') {
+                        viewElement.cssRules = (0, transformThemeAndStyle_1.transformStyle)(attr.value.value, options);
                     }
                     else if (attr.value.type === 'JSXExpressionContainer') {
                         const templateLiteral = attr.value.expression;
                         if (templateLiteral.type === 'TemplateLiteral') {
                             if (templateLiteral.expressions.length > 0) {
-                                (0, utils_1.throwError)('不支持在 $theme 中使用动态表达式');
+                                return (0, utils_1.throwError)(options?.parsingId, '不支持在 $theme 中使用动态表达式');
                             }
                             const css = templateLiteral.quasis[0].value.raw;
-                            viewElement.cssRules = (0, transformThemeAndStyle_1.transformStyle)(css);
+                            viewElement.cssRules = (0, transformThemeAndStyle_1.transformStyle)(css, options);
                         }
                         else {
-                            (0, utils_1.throwError)('$extraStyle 属性只能用字符串字面量', attr.value);
+                            return (0, utils_1.throwError)(options?.parsingId, '$extraStyle 属性只能用字符串字面量', attr.value);
                         }
                     }
                     else {
-                        (0, utils_1.throwError)('$extraStyle 属性只能用字符串字面量', attr.value);
+                        return (0, utils_1.throwError)(options?.parsingId, '$extraStyle 属性只能用字符串字面量', attr.value);
                     }
                 }
                 else if (attrName === '$dynamicStyle') {
-                    if (attr.value.type === 'JSXExpressionContainer') {
+                    if (!attr.value) {
+                        (0, utils_1.throwError)(options?.parsingId, '$dynamicStyle 属性只能用字符串字面量', attr);
+                    }
+                    else if (attr.value.type === 'JSXExpressionContainer') {
                         const expression = attr.value.expression;
                         if (expression.type === 'ObjectExpression') {
                             const properties = expression.properties;
@@ -207,6 +242,7 @@ function transformJSXElement2ViewElement(node) {
                                     viewElement.addBindStyle(new utils_1.naslTypes.BindStyle({
                                         name,
                                         expression: (0, transform2LogicItem_1.transform2LogicItem)(property.value, {
+                                            ...options,
                                             transformType: 'attr',
                                             isRestricted: true,
                                             isInFrontend: true,
@@ -217,7 +253,7 @@ function transformJSXElement2ViewElement(node) {
                         }
                     }
                     else {
-                        (0, utils_1.throwError)('style 属性值不正确', attr.value);
+                        return (0, utils_1.throwError)(options?.parsingId, 'style 属性值不正确', attr.value);
                     }
                 }
                 else if (attrName.startsWith(directivePrefix)) {
@@ -225,7 +261,11 @@ function transformJSXElement2ViewElement(node) {
                     const directive = new utils_1.naslTypes.BindDirective({
                         name: directiveName,
                     });
-                    if (attr.value.type === 'StringLiteral') {
+                    if (!attr.value) {
+                        directive.type = 'static';
+                        directive.value = 'true';
+                    }
+                    else if (attr.value.type === 'StringLiteral') {
                         directive.type = 'string';
                         directive.value = attr.value.value;
                     }
@@ -237,8 +277,9 @@ function transformJSXElement2ViewElement(node) {
                         else {
                             directive.type = 'dynamic';
                             if (attr.value.expression.type === 'FunctionExpression')
-                                (0, utils_1.throwError)('指令不支持传函数表达式', attr);
+                                return (0, utils_1.throwError)(options?.parsingId, '指令不支持传函数表达式', attr);
                             directive.expression = (0, transform2LogicItem_1.transform2LogicItem)(attr.value.expression, {
+                                ...options,
                                 transformType: 'attr',
                                 isRestricted: true,
                                 isInFrontend: true,
@@ -246,7 +287,7 @@ function transformJSXElement2ViewElement(node) {
                         }
                     }
                     else {
-                        (0, utils_1.throwError)('不支持的指令类型', attr.value.type, attr.value);
+                        return (0, utils_1.throwError)(options?.parsingId, '不支持的指令类型', attr.value.type, attr.value);
                     }
                     if (directiveName !== 'for') {
                         viewElement.addBindDirective(directive);
@@ -254,20 +295,20 @@ function transformJSXElement2ViewElement(node) {
                 }
                 else if (attrName.startsWith(eventPrefix)) {
                     const eventName = (0, utils_2.firstLowerCase)(attrName.slice(eventPrefix.length));
-                    if (attr.value.type === 'JSXExpressionContainer') {
+                    if (attr.value?.type === 'JSXExpressionContainer') {
                         const bindEvent = new utils_1.naslTypes.BindEvent({
                             name: eventName,
-                            logics: transform2EventLogics(attr.value.expression, eventName),
+                            logics: transform2EventLogics(attr.value.expression, eventName, options) || [],
                         });
                         viewElement.addBindEvent(bindEvent);
                     }
                     else {
-                        (0, utils_1.throwError)('事件逻辑参数不正确', attr.value);
+                        return (0, utils_1.throwError)(options?.parsingId, '事件逻辑参数不正确', attr.value);
                     }
                 }
                 else if (attrName.startsWith(slotPrefix)) {
                     const slotTarget = (0, utils_2.firstLowerCase)(attrName.slice(slotPrefix.length));
-                    if (attr.value.type === 'JSXExpressionContainer') {
+                    if (attr.value?.type === 'JSXExpressionContainer') {
                         const expression = attr.value.expression;
                         if (expression.type === 'JSXElement' || expression.type === 'JSXFragment') {
                             addJSXChild(expression, slotTarget);
@@ -276,39 +317,52 @@ function transformJSXElement2ViewElement(node) {
                             addArrowFunctionJSXChild(expression, slotTarget);
                         }
                         else {
-                            (0, utils_1.throwError)('slot 属性值不正确', attr.value);
+                            return (0, utils_1.throwError)(options?.parsingId, 'slot 属性值不正确', attr.value);
+                        }
+                    }
+                }
+                else if (attrName === 'rules') {
+                    const bindAttribute = new utils_1.naslTypes.BindAttribute({
+                        name: attrName,
+                    });
+                    if (attr.value?.type === 'JSXExpressionContainer') {
+                        if (attr.value.expression.type === 'ArrayExpression') {
+                            const elements = attr.value.expression.elements;
+                            bindAttribute.rules = elements.map((node) => (0, transform2ValidationRule_1.transform2ValidationRule)(node, options)).filter(Boolean);
+                        }
+                        else if (attr.value.expression.type === 'CallExpression') {
+                            const callee = (0, utils_1.generate)(attr.value.expression.callee).code;
+                            if (callee === 'nasl.util.NewList' || callee === 'NewList') {
+                                const elements = attr.value.expression.arguments[0].elements;
+                                bindAttribute.rules = elements.map((node) => (0, transform2ValidationRule_1.transform2ValidationRule)(node, options)).filter(Boolean);
+                            }
+                            else {
+                                return (0, utils_1.throwError)(options?.parsingId, 'rules 属性值不正确', attr.value);
+                            }
+                        }
+                        else {
+                            return (0, utils_1.throwError)(options?.parsingId, 'rules 属性值不正确', attr.value);
                         }
                     }
+                    else {
+                        return (0, utils_1.throwError)(options?.parsingId, 'rules 属性值不正确', attr.value);
+                    }
+                    viewElement.addBindAttribute(bindAttribute);
                 }
                 else {
                     const bindAttribute = new utils_1.naslTypes.BindAttribute({
                         name: attrName,
                     });
-                    if (attr.value.type === 'StringLiteral') {
+                    if (!attr.value) {
+                        bindAttribute.type = 'static';
+                        bindAttribute.value = 'true';
+                    }
+                    else if (attr.value.type === 'StringLiteral') {
                         bindAttribute.type = 'string';
                         bindAttribute.value = attr.value.value;
                     }
                     else if (attr.value.type === 'JSXExpressionContainer') {
-                        if (attrName === 'rules') {
-                            if (attr.value.expression.type === 'ArrayExpression') {
-                                const elements = attr.value.expression.elements;
-                                bindAttribute.rules = elements.map(transform2ValidationRule_1.transform2ValidationRule);
-                            }
-                            else if (attr.value.expression.type === 'CallExpression') {
-                                const callee = (0, utils_1.generate)(attr.value.expression.callee).code;
-                                if (callee === 'nasl.util.NewList' || callee === 'NewList') {
-                                    const elements = attr.value.expression.arguments[0].elements;
-                                    bindAttribute.rules = elements.map(transform2ValidationRule_1.transform2ValidationRule);
-                                }
-                                else {
-                                    (0, utils_1.throwError)('rules 属性值不正确', attr.value);
-                                }
-                            }
-                            else {
-                                (0, utils_1.throwError)('rules 属性值不正确', attr.value);
-                            }
-                        }
-                        else if (attr.value.expression.type === 'BooleanLiteral' || attr.value.expression.type === 'NumericLiteral' || attr.value.expression.type === 'NullLiteral' || attr.value.expression.type === 'StringLiteral') {
+                        if (attr.value.expression.type === 'BooleanLiteral' || attr.value.expression.type === 'NumericLiteral' || attr.value.expression.type === 'NullLiteral' || attr.value.expression.type === 'StringLiteral') {
                             bindAttribute.type = 'static';
                             bindAttribute.value = (0, utils_1.generate)(attr.value.expression).code;
                         }
@@ -332,12 +386,13 @@ function transformJSXElement2ViewElement(node) {
                                 if (expr.arguments.length > 0) {
                                     expr = expr.arguments[0];
                                     if (!expr)
-                                        (0, utils_1.throwError)('$sync 的参数不能为空', attr);
+                                        return (0, utils_1.throwError)(options?.parsingId, '$sync 的参数不能为空', attr);
                                 }
                             }
                             if (expr.type === 'FunctionExpression')
-                                (0, utils_1.throwError)('属性不支持传函数表达式', attr);
+                                return (0, utils_1.throwError)(options?.parsingId, '属性不支持传函数表达式', attr);
                             const expression = (0, transform2LogicItem_1.transform2LogicItem)(expr, {
+                                ...options,
                                 transformType: 'attr',
                                 isRestricted: attrName !== 'dataSource',
                                 isInFrontend: true,
@@ -354,15 +409,21 @@ function transformJSXElement2ViewElement(node) {
                         }
                     }
                     else {
-                        (0, utils_1.throwError)('不支持的指令类型', attr.value.type, attr.value);
+                        return (0, utils_1.throwError)(options?.parsingId, '不支持的指令类型', attr.value.type, attr.value);
                     }
                     viewElement.addBindAttribute(bindAttribute);
                 }
             }
             else {
-                (0, utils_1.throwError)('不支持的JSX属性类型', attr.type, attr);
+                return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX属性类型', attr.type, attr);
             }
         });
+        { /* 临时补救 EnumToList 问题 */
+            if (viewElement.bindAttrs.some((bindAttr) => bindAttr.name === 'dataSource' && bindAttr.expression?.concept === 'CallFunction' && bindAttr.expression?.calleeName === 'EnumToList')) {
+                const index = viewElement.bindAttrs.findIndex((bindAttr) => bindAttr.name === 'valueField');
+                ~index && viewElement.bindAttrs.splice(index, 1);
+            }
+        }
         node.children.forEach((child) => {
             if (child.type === 'JSXElement' || child.type === 'JSXFragment') {
                 addJSXChild(child);
@@ -379,28 +440,36 @@ function transformJSXElement2ViewElement(node) {
                     // ignore
                 }
                 else {
-                    (0, utils_1.throwError)('不支持的JSX子元素类型', expression.type, expression);
+                    return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX子元素类型', expression.type, expression);
                 }
             }
             else if (child.type === 'JSXText') {
                 // ignore
             }
             else {
-                (0, utils_1.throwError)('不支持的JSX子元素类型', child.type, child);
+                return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX子元素类型', child.type, child);
             }
         });
         if (!viewElement.name) {
-            viewElement.name = viewElement.tag.replace(/-/g, '_') + '_' + (0, utils_2.uuidv4)().slice(0, 5);
+            let generatedName = viewElement.tag.replace(/-/g, '_') + '_' + (0, utils_2.uuidv4)().slice(0, 5);
+            // 确保生成的名称也不重复
+            while (options.nameMap.has(generatedName)) {
+                generatedName = viewElement.tag.replace(/-/g, '_') + '_' + (0, utils_2.uuidv4)().slice(0, 5);
+            }
+            viewElement.name = generatedName;
+            options.nameMap.set(generatedName, true);
         }
         return viewElement;
     }
     else {
-        (0, utils_1.throwError)('不支持的JSX元素类型', el.name.type, el);
+        return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX元素类型', el.name.type, el);
     }
 }
 exports.transformJSXElement2ViewElement = transformJSXElement2ViewElement;
-function transform2View(func, decorator) {
+function transform2View(func, decorator, options) {
     const statements = func.body.body;
+    // 为每个视图创建独立的 nameMap
+    const nameMap = new Map();
     const view = new utils_1.naslTypes.View({
         name: func.id?.name,
     });
@@ -414,19 +483,20 @@ function transform2View(func, decorator) {
                 'auth',
                 'authDescription',
                 'isIndex',
-            ]));
+            ]), options);
             Object.assign(view, viewObj);
             view.crumb = new utils_1.naslTypes.StaticString({
                 value: viewObj.crumb,
             });
         }
         else {
-            (0, utils_1.throwError)('不支持的装饰器类型', decorator.type, decorator);
+            return (0, utils_1.throwError)(options?.parsingId, '不支持的装饰器类型', decorator.type, decorator);
         }
     }
     func.params.forEach((param) => {
         if (param.type === 'Identifier') {
-            view.params.push((0, transform2LogicItem_1.transform2Param)(param));
+            const _param = (0, transform2LogicItem_1.transform2Param)(param, { ...options, transformType: 'attr' });
+            _param && view.params.push(_param);
         }
         else if (param.type === 'ObjectPattern') {
             const propertyMap = {};
@@ -443,13 +513,13 @@ function transform2View(func, decorator) {
                         propertyMap[property.value.left.name] = property.value;
                     }
                     else {
-                        (0, utils_1.throwError)('不支持的参数类型', property.value.type, property.value);
+                        return (0, utils_1.throwError)(options?.parsingId, '不支持的参数类型', property.value.type, property.value);
                     }
                 }
             });
             const type = param.typeAnnotation?.typeAnnotation;
             if (!type)
-                (0, utils_1.throwError)('param 没有对应的类型', param);
+                return (0, utils_1.throwError)(options?.parsingId, 'param 没有对应的类型', param);
             type.members.forEach((member) => {
                 if (member.type === 'TSPropertySignature') {
                     const name = member.key.name;
@@ -459,7 +529,8 @@ function transform2View(func, decorator) {
                 }
             });
             Object.values(propertyMap).forEach((property) => {
-                view.params.push((0, transform2LogicItem_1.transform2Param)(property));
+                const param = (0, transform2LogicItem_1.transform2Param)(property, { ...options, transformType: 'attr' });
+                param && view.params.push(param);
             });
         }
     });
@@ -471,7 +542,7 @@ function transform2View(func, decorator) {
             });
         }
         else if (statement.type === 'FunctionDeclaration') {
-            const logic = (0, transform2Logic_1.transform2Logic)(statement);
+            const logic = (0, transform2Logic_1.transform2Logic)(statement, undefined, options);
             view.addLogic(logic);
         }
         else if (statement.type === 'ExpressionStatement' && statement.expression.type === 'CallExpression') {
@@ -481,34 +552,68 @@ function transform2View(func, decorator) {
                 const arg = expression.arguments[0];
                 const bindEvent = new utils_1.naslTypes.BindEvent({
                     name: eventName,
-                    logics: transform2EventLogics(arg, eventName),
+                    logics: transform2EventLogics(arg, eventName, options) || [],
                 });
                 view.addBindEvent(bindEvent);
             }
             else {
-                (0, utils_1.throwError)('不支持的表达式', statement);
+                return (0, utils_1.throwError)(options?.parsingId, '不支持的表达式', statement);
             }
         }
         else if (statement.type === 'ReturnStatement') {
             const arg = statement.argument;
             if (arg.type === 'JSXElement') {
-                view.elements = [transformJSXElement2ViewElement(arg)];
+                const child = transformJSXElement2ViewElement(arg, { ...options, nameMap });
+                view.elements = child ? [child] : [];
             }
             else if (arg.type === 'JSXFragment') {
-                view.elements = arg.children.filter((child) => child.type === 'JSXElement').map(transformJSXElement2ViewElement);
+                view.elements = arg.children.filter((child) => child.type === 'JSXElement').map((child) => transformJSXElement2ViewElement(child, { ...options, nameMap })).filter(Boolean);
             }
             else {
-                (0, utils_1.throwError)('返回值不正确', arg);
+                return (0, utils_1.throwError)(options?.parsingId, '返回值不正确', arg);
             }
         }
         else {
-            (0, utils_1.throwError)('不支持的表达式', statement);
+            return (0, utils_1.throwError)(options?.parsingId, '不支持的表达式', statement);
         }
     });
     return view;
 }
 exports.transform2View = transform2View;
-function parseNaturalTSXView(tsCode) {
+function transformTSDeclareFunction2View(func, decorator, options) {
+    const view = new utils_1.naslTypes.View({
+        name: func.id?.name,
+    });
+    if (decorator) {
+        if (decorator.arguments[0].type === 'ObjectExpression') {
+            const viewObj = (0, utils_1.pickDecoratorObject)(decorator.arguments[0], new Set([
+                'pageTemplateId',
+                'uuid',
+                'title',
+                'crumb',
+                'auth',
+                'authDescription',
+                'isIndex',
+            ]), options);
+            Object.assign(view, viewObj);
+            view.crumb = new utils_1.naslTypes.StaticString({
+                value: viewObj.crumb,
+            });
+        }
+        else {
+            return (0, utils_1.throwError)(options?.parsingId, '不支持的装饰器类型', decorator.type, decorator);
+        }
+    }
+    func.params.forEach((param) => {
+        if (param.type === 'Identifier') {
+            const _param = (0, transform2LogicItem_1.transform2Param)(param, { ...options, transformType: 'attr' });
+            _param && view.params.push(_param);
+        }
+    });
+    return view;
+}
+exports.transformTSDeclareFunction2View = transformTSDeclareFunction2View;
+function parseNaturalTSXView(tsCode, options) {
     const root = babel.parseSync(tsCode, {
         filename: 'result.tsx',
         presets: [require('@babel/preset-typescript')],
@@ -530,7 +635,7 @@ function parseNaturalTSXView(tsCode) {
             decorator = prevStatement.expression;
         }
     });
-    return transform2View(func, decorator);
+    return transform2View(func, decorator, options);
 }
 exports.parseNaturalTSXView = parseNaturalTSXView;
 //# sourceMappingURL=parseNaturalTSXView.js.map