@lcap/nasl 4.3.0-creator.3 → 4.3.0-creator.5

package/out/natural/parseNaturalTSXView.js

@@ -57,7 +57,7 @@ function transform2Variables(node, options) {
 exports.transform2Variables = transform2Variables;
 function transform2EventLogics(node, eventName, options) {
     if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
-        const logic = (0, transform2Logic_1.transform2Logic)(node, eventName, options);
+        const logic = (0, transform2Logic_1.transform2Logic)(node, eventName, { ...options, logicType: 'event_logic' });
         logic.params = [];
         return [logic];
     }
@@ -66,21 +66,24 @@ function transform2EventLogics(node, eventName, options) {
             const args = node.arguments;
             return args.map((node) => {
                 if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
-                    const logic = (0, transform2Logic_1.transform2Logic)(node, eventName, options);
+                    const logic = (0, transform2Logic_1.transform2Logic)(node, eventName, { ...options, logicType: 'event_logic' });
                     logic.params = [];
                     return logic;
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, '事件逻辑参数不支持的类型', node.type, node);
+                    return (0, utils_1.throwError)(options, '事件逻辑参数不支持的类型', node.type, node);
                 }
             }).filter(Boolean);
         }
         else {
-            return (0, utils_1.throwError)(options?.parsingId, '事件逻辑参数不正确', node);
+            return (0, utils_1.throwError)(options, '事件逻辑参数不正确', node);
         }
     }
+    else if (node.type === 'Identifier' || node.type === 'MemberExpression') {
+        return (0, utils_1.throwError)(options, '事件逻辑参数不正确，不支持绑定逻辑，需要直接写在元素中', node);
+    }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, '事件逻辑参数不正确', node);
+        return (0, utils_1.throwError)(options, '事件逻辑参数不正确', node);
     }
 }
 function handleDirectoryItem(directoryItem, nextStatement, view, options, callerName) {
@@ -92,11 +95,11 @@ function handleDirectoryItem(directoryItem, nextStatement, view, options, caller
     }
     else if (nextStatement.type === 'FunctionDeclaration') {
         // 处理函数/逻辑声明
-        definitionItem = (0, transform2Logic_1.transform2Logic)(nextStatement, undefined, options);
+        definitionItem = (0, transform2Logic_1.transform2Logic)(nextStatement, undefined, { ...options, logicType: 'view_logic' });
     }
     else {
         const functionName = callerName || '$Variable';
-        (0, utils_1.throwError)(options?.parsingId, `${functionName} 后面必须跟变量声明或函数声明`, nextStatement);
+        (0, utils_1.throwError)(options, `${functionName} 后面必须跟变量声明或函数声明`, nextStatement);
     }
     if (!definitionItem)
         return null;
@@ -131,6 +134,9 @@ function transformJSXElement2ViewElement(node, options) {
     const el = node.openingElement;
     if (el.name.type === 'JSXIdentifier') {
         let tag = (0, lodash_1.kebabCase)(el.name.name);
+        if (['span', 'div'].includes(tag)) {
+            return (0, utils_1.throwError)(options, `不支持的JSX子元素 ${tag}, 请使用 ElFlex`, node);
+        }
         if (tag === 'el-form-date-time-picker')
             tag = 'el-form-date-picker';
         if (tag === 'el-form-input-date')
@@ -139,6 +145,8 @@ function transformJSXElement2ViewElement(node, options) {
             tag = 'el-form-input';
         if (tag === 'el-form-item')
             tag = 'el-form-input';
+        // 检查父组件约束
+        (0, utils_1.validateParentConstraints)(tag, options, node);
         const viewElement = new utils_1.naslTypes.ViewElement({
             tag,
         });
@@ -149,11 +157,11 @@ function transformJSXElement2ViewElement(node, options) {
         function addJSXChild(node, slotTarget = 'default', slotScope = '') {
             if (node.type === 'JSXElement') {
                 if (slotTarget === 'default' && !slotScope) {
-                    const child = transformJSXElement2ViewElement(node, options);
+                    const child = transformJSXElement2ViewElement(node, { ...options, parentTag: tag });
                     child && viewElement.children.push(child);
                 }
                 else {
-                    const child = transformJSXElement2ViewElement(node, options);
+                    const child = transformJSXElement2ViewElement(node, { ...options, parentTag: tag });
                     let templateName = 'template_' + (0, utils_2.uuidv4)().slice(0, 5);
                     // 确保模板名称也不重复
                     while (options.nameMap.has(templateName)) {
@@ -168,14 +176,14 @@ function transformJSXElement2ViewElement(node, options) {
                         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);
+                        (0, utils_1.throwError)(options, `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((child) => transformJSXElement2ViewElement(child, options)).filter(Boolean));
+                    viewElement.children.push(...children.filter((child) => child.type === 'JSXElement').map((child) => transformJSXElement2ViewElement(child, { ...options, parentTag: tag })).filter(Boolean));
                 }
                 else {
                     let templateName = 'template_' + (0, utils_2.uuidv4)().slice(0, 5);
@@ -189,21 +197,21 @@ function transformJSXElement2ViewElement(node, options) {
                         name: templateName,
                         slotTarget,
                         slotScope,
-                        children: children.filter((child) => child.type === 'JSXElement').map((child) => transformJSXElement2ViewElement(child, options)).filter(Boolean),
+                        children: children.filter((child) => child.type === 'JSXElement').map((child) => transformJSXElement2ViewElement(child, { ...options, parentTag: tag })).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);
+                        (0, utils_1.throwError)(options, `slot${(0, utils_2.firstUpperCase)(slotTarget)} 不能重复`, node);
                     viewElement.children.push(templateChild);
                 }
             }
             else {
-                return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX子元素类型', node);
+                return (0, utils_1.throwError)(options, '不支持的JSX子元素类型', node);
             }
         }
         function addArrowFunctionJSXChild(node, slotTarget = 'default') {
             const slotScopeName = node.params[0]?.name;
             if (slotScopeName && slotScopeName !== 'current' && !slotScopeName?.startsWith('current')) {
-                return (0, utils_1.throwError)(options?.parsingId, `slotScope 需以 current 参数名开头`, node);
+                return (0, utils_1.throwError)(options, `slotScope 需以 current 参数名开头`, node);
             }
             let slotScope = '';
             if (slotScopeName) {
@@ -220,23 +228,25 @@ function transformJSXElement2ViewElement(node, options) {
                 });
             }
             else {
-                return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX子元素类型', body.type, body);
+                return (0, utils_1.throwError)(options, '不支持的JSX子元素类型', body.type, body);
             }
         }
         attrs.forEach((attr) => {
             if (attr.type === 'JSXAttribute') {
                 const attrName = attr.name.name;
+                if (!attrName)
+                    (0, utils_1.throwError)(options, '属性名不能为空', attr);
                 if (attrName === 'ref') {
                     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);
+                            return (0, utils_1.throwError)(options, `ref 属性值 "${proposedName}" 已存在，不能重复使用`, attr);
                         }
                         viewElement.name = proposedName;
                         options.nameMap.set(proposedName, true);
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, 'ref 属性值不正确', attr.value);
+                        return (0, utils_1.throwError)(options, 'ref 属性值不正确', attr.value);
                     }
                 }
                 else if (attrName === 'style') {
@@ -244,12 +254,12 @@ function transformJSXElement2ViewElement(node, options) {
                         viewElement.staticStyle = attr.value.value;
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, 'style 属性只能用字符串字面量', attr.value);
+                        return (0, utils_1.throwError)(options, 'style 属性只能用字符串字面量', attr.value);
                     }
                 }
                 else if (attrName === '$extraStyle') {
                     if (!attr.value) {
-                        (0, utils_1.throwError)(options?.parsingId, '$extraStyle 属性只能用字符串字面量', attr);
+                        (0, utils_1.throwError)(options, '$extraStyle 属性只能用字符串字面量', attr);
                     }
                     else if (attr.value.type === 'StringLiteral') {
                         viewElement.cssRules = (0, transformThemeAndStyle_1.transformStyle)(attr.value.value, options);
@@ -258,22 +268,22 @@ function transformJSXElement2ViewElement(node, options) {
                         const templateLiteral = attr.value.expression;
                         if (templateLiteral.type === 'TemplateLiteral') {
                             if (templateLiteral.expressions.length > 0) {
-                                return (0, utils_1.throwError)(options?.parsingId, '不支持在 $theme 中使用动态表达式');
+                                return (0, utils_1.throwError)(options, '不支持在 $theme 中使用动态表达式');
                             }
                             const css = templateLiteral.quasis[0].value.raw;
                             viewElement.cssRules = (0, transformThemeAndStyle_1.transformStyle)(css, options);
                         }
                         else {
-                            return (0, utils_1.throwError)(options?.parsingId, '$extraStyle 属性只能用字符串字面量', attr.value);
+                            return (0, utils_1.throwError)(options, '$extraStyle 属性只能用字符串字面量', attr.value);
                         }
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, '$extraStyle 属性只能用字符串字面量', attr.value);
+                        return (0, utils_1.throwError)(options, '$extraStyle 属性只能用字符串字面量', attr.value);
                     }
                 }
                 else if (attrName === '$dynamicStyle') {
                     if (!attr.value) {
-                        (0, utils_1.throwError)(options?.parsingId, '$dynamicStyle 属性只能用字符串字面量', attr);
+                        (0, utils_1.throwError)(options, '$dynamicStyle 属性只能用字符串字面量', attr);
                     }
                     else if (attr.value.type === 'JSXExpressionContainer') {
                         const expression = attr.value.expression;
@@ -297,7 +307,7 @@ function transformJSXElement2ViewElement(node, options) {
                         }
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, 'style 属性值不正确', attr.value);
+                        return (0, utils_1.throwError)(options, 'style 属性值不正确', attr.value);
                     }
                 }
                 else if (attrName.startsWith(directivePrefix)) {
@@ -321,7 +331,7 @@ function transformJSXElement2ViewElement(node, options) {
                         else {
                             directive.type = 'dynamic';
                             if (attr.value.expression.type === 'FunctionExpression')
-                                return (0, utils_1.throwError)(options?.parsingId, '指令不支持传函数表达式', attr);
+                                return (0, utils_1.throwError)(options, '指令不支持传函数表达式', attr);
                             directive.expression = (0, transform2LogicItem_1.transform2LogicItem)(attr.value.expression, {
                                 ...options,
                                 transformType: 'attr',
@@ -331,7 +341,7 @@ function transformJSXElement2ViewElement(node, options) {
                         }
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, '不支持的指令类型', attr.value.type, attr.value);
+                        return (0, utils_1.throwError)(options, '不支持的指令类型', attr.value.type, attr.value);
                     }
                     if (directiveName !== 'for') {
                         viewElement.addBindDirective(directive);
@@ -339,6 +349,7 @@ function transformJSXElement2ViewElement(node, options) {
                 }
                 else if (attrName.startsWith(eventPrefix)) {
                     const eventName = (0, utils_2.firstLowerCase)(attrName.slice(eventPrefix.length));
+                    (0, utils_1.validateComponentFeature)(tag, 'event', attrName, options, attr);
                     if (attr.value?.type === 'JSXExpressionContainer') {
                         const bindEvent = new utils_1.naslTypes.BindEvent({
                             name: eventName,
@@ -347,11 +358,12 @@ function transformJSXElement2ViewElement(node, options) {
                         viewElement.addBindEvent(bindEvent);
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, '事件逻辑参数不正确', attr.value);
+                        return (0, utils_1.throwError)(options, '事件逻辑参数不正确', attr.value);
                     }
                 }
                 else if (attrName.startsWith(slotPrefix)) {
                     const slotTarget = (0, utils_2.firstLowerCase)(attrName.slice(slotPrefix.length));
+                    (0, utils_1.validateComponentFeature)(tag, 'slot', attrName, options, attr);
                     if (attr.value?.type === 'JSXExpressionContainer') {
                         const expression = attr.value.expression;
                         if (expression.type === 'JSXElement' || expression.type === 'JSXFragment') {
@@ -361,7 +373,7 @@ function transformJSXElement2ViewElement(node, options) {
                             addArrowFunctionJSXChild(expression, slotTarget);
                         }
                         else {
-                            return (0, utils_1.throwError)(options?.parsingId, 'slot 属性值不正确', attr.value);
+                            return (0, utils_1.throwError)(options, 'slot 属性值不正确', attr.value);
                         }
                     }
                 }
@@ -381,19 +393,20 @@ function transformJSXElement2ViewElement(node, options) {
                                 bindAttribute.rules = elements.map((node) => (0, transform2ValidationRule_1.transform2ValidationRule)(node, options)).filter(Boolean);
                             }
                             else {
-                                return (0, utils_1.throwError)(options?.parsingId, 'rules 属性值不正确', attr.value);
+                                return (0, utils_1.throwError)(options, 'rules 属性值不正确', attr.value);
                             }
                         }
                         else {
-                            return (0, utils_1.throwError)(options?.parsingId, 'rules 属性值不正确', attr.value);
+                            return (0, utils_1.throwError)(options, 'rules 属性值不正确', attr.value);
                         }
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, 'rules 属性值不正确', attr.value);
+                        return (0, utils_1.throwError)(options, 'rules 属性值不正确', attr.value);
                     }
                     viewElement.addBindAttribute(bindAttribute);
                 }
                 else {
+                    (0, utils_1.validateComponentFeature)(tag, 'prop', attrName, options, attr);
                     const bindAttribute = new utils_1.naslTypes.BindAttribute({
                         name: attrName,
                     });
@@ -406,19 +419,23 @@ function transformJSXElement2ViewElement(node, options) {
                         bindAttribute.value = attr.value.value;
                     }
                     else if (attr.value.type === 'JSXExpressionContainer') {
-                        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') {
+                            bindAttribute.type = 'static';
+                            bindAttribute.value = attr.value.expression.value;
+                        }
+                        else if (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;
                         }
                         else {
                             let expr = attr.value.expression;
-                            if (attrName === 'prop' || attrName.endsWith('Field')) {
+                            if (attrName === 'prop' || attrName.endsWith('Field') || attrName === 'rowKey') {
                                 if (expr.type === 'ArrowFunctionExpression') {
                                     bindAttribute.type = 'string';
                                     const paramName = expr.params[0]?.name || 'item';
                                     const code = (0, utils_1.generate)(expr.body).code;
                                     bindAttribute.value = code.replace(new RegExp(`${paramName}\\.`, 'g'), '');
-                                    if (bindAttribute.value === 'item')
+                                    if (bindAttribute.value === 'item' && code !== 'item.item')
                                         bindAttribute.value = '';
                                     viewElement.addBindAttribute(bindAttribute);
                                     return;
@@ -427,20 +444,29 @@ function transformJSXElement2ViewElement(node, options) {
                             bindAttribute.type = 'dynamic';
                             if (expr.type === 'CallExpression' && expr.callee.type === 'Identifier' && expr.callee.name === '$sync') {
                                 bindAttribute.sync = true;
-                                if (expr.arguments.length > 0) {
+                                if (expr.arguments.length === 0) {
+                                    return (0, utils_1.throwError)(options, '$sync 的参数不能为空', attr);
+                                }
+                                else if (expr.arguments.length > 0) {
                                     expr = expr.arguments[0];
                                     if (!expr)
-                                        return (0, utils_1.throwError)(options?.parsingId, '$sync 的参数不能为空', attr);
+                                        return (0, utils_1.throwError)(options, '$sync 的参数不能为空', attr);
                                 }
                             }
                             if (expr.type === 'FunctionExpression')
-                                return (0, utils_1.throwError)(options?.parsingId, '属性不支持传函数表达式', attr);
+                                return (0, utils_1.throwError)(options, '属性不支持传函数表达式', attr);
                             const expression = (0, transform2LogicItem_1.transform2LogicItem)(expr, {
                                 ...options,
                                 transformType: 'attr',
                                 isRestricted: attrName !== 'dataSource',
                                 isInFrontend: true,
                             });
+                            if (attr.name.name === 'destination' && expression.concept !== 'Destination') {
+                                return (0, utils_1.throwError)(options, 'destination 属性值必须使用 nasl.ui.destination', attr);
+                            }
+                            if (attr.name.name === 'externalDestination' && expression.concept !== 'ExternalDestination') {
+                                return (0, utils_1.throwError)(options, 'externalDestination 属性值必须使用 nasl.ui.gotoLink', attr);
+                            }
                             if (expression?.concept === 'Destination') {
                                 bindAttribute.destination = expression;
                             }
@@ -453,13 +479,13 @@ function transformJSXElement2ViewElement(node, options) {
                         }
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, '不支持的指令类型', attr.value.type, attr.value);
+                        return (0, utils_1.throwError)(options, '不支持的指令类型', attr.value.type, attr.value);
                     }
                     viewElement.addBindAttribute(bindAttribute);
                 }
             }
             else {
-                return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX属性类型', attr.type, attr);
+                return (0, utils_1.throwError)(options, '不支持的JSX属性类型', attr.type, attr);
             }
         });
         { /* 临时补救 EnumToList 问题 */
@@ -468,7 +494,7 @@ function transformJSXElement2ViewElement(node, options) {
                 ~index && viewElement.bindAttrs.splice(index, 1);
             }
         }
-        node.children.forEach((child) => {
+        node.children.forEach((child, index) => {
             if (child.type === 'JSXElement' || child.type === 'JSXFragment') {
                 addJSXChild(child);
             }
@@ -478,22 +504,62 @@ function transformJSXElement2ViewElement(node, options) {
                     addJSXChild(expression);
                 }
                 else if (expression.type === 'ArrowFunctionExpression') {
+                    if (index > 0) {
+                        const previousNode = node.children[index - 1];
+                        if (previousNode?.type === 'JSXText') {
+                            const trimmedValue = previousNode.value.trim();
+                            const isSlotAssignment = trimmedValue.startsWith('slot') && trimmedValue.endsWith('=');
+                            if (isSlotAssignment) {
+                                const positionCode = (0, utils_1.generate)(previousNode).code + '{' + (0, utils_1.generate)(expression).code + '}';
+                                return (0, utils_1.throwError)(options, '不支持的JSX子元素类型', positionCode, node);
+                            }
+                        }
+                    }
                     addArrowFunctionJSXChild(expression);
                 }
                 else if (expression.type === 'JSXEmptyExpression') {
                     // ignore
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX子元素类型', expression.type, expression);
+                    return (0, utils_1.throwError)(options, '不支持的JSX子元素类型', expression.type, expression);
                 }
             }
             else if (child.type === 'JSXText') {
                 // ignore
             }
             else {
-                return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX子元素类型', child.type, child);
+                return (0, utils_1.throwError)(options, '不支持的JSX子元素类型', child.type, child);
             }
         });
+        if (viewElement.tag === 'el-table') {
+            (0, utils_1.addLint)(options, {
+                name: '表格列不推荐全设置宽度',
+                description: '从表格列中选取几个较长文本字段（如名称、地址、描述等）不设置宽度，以便自适应显示，其他列可根据展示内容和表格整体宽度酌情设置宽度。 使用style属性进行宽度设置。',
+            }, (rule) => {
+                // 检查所有子元素是否都是 el-table-column 且都有 width 样式
+                const allColumnsHaveWidth = viewElement.children.every((child) => {
+                    return (child.tag === 'el-table-column' &&
+                        child.staticStyle &&
+                        child.staticStyle.includes('width:'));
+                });
+                if (allColumnsHaveWidth) {
+                    return (0, utils_1.throwError)(options, `${rule.name}: ${rule.description}`, node);
+                }
+            });
+        }
+        if (viewElement.tag === 'el-form') {
+            (0, utils_1.addLint)(options, {
+                name: '表单缺少校验',
+                description: '表单定义中包含校验规则，需要为 ElForm 设置 ref 属性，并在提交前调用 validated() 方法进行校验',
+            }, (rule) => {
+                // 需检测ElForm在其子项有rules的情况下，无ref或者代码中无ref对应validated的情况
+                const hasRule = viewElement.children.some((child) => child.bindAttrs.some((bindAttr) => bindAttr.name === 'rules'));
+                const hasRef = viewElement.name;
+                if (hasRule && !hasRef) {
+                    return (0, utils_1.throwError)(options, `${rule.name}: ${rule.description}`, node);
+                }
+            });
+        }
         if (!viewElement.name) {
             let generatedName = viewElement.tag.replace(/-/g, '_') + '_' + (0, utils_2.uuidv4)().slice(0, 5);
             // 确保生成的名称也不重复
@@ -506,7 +572,7 @@ function transformJSXElement2ViewElement(node, options) {
         return viewElement;
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, '不支持的JSX元素类型', el.name.type, el);
+        return (0, utils_1.throwError)(options, '不支持的JSX元素类型', el.name.type, el);
     }
 }
 exports.transformJSXElement2ViewElement = transformJSXElement2ViewElement;
@@ -517,6 +583,8 @@ function transform2View(func, decorator, options) {
     const view = new utils_1.naslTypes.View({
         name: func.id?.name,
     });
+    options.nodeName = view.name;
+    const opts = { ...options, nameMap };
     if (decorator) {
         if (decorator.arguments[0].type === 'ObjectExpression') {
             const viewObj = (0, utils_1.pickDecoratorObject)(decorator.arguments[0], new Set([
@@ -534,7 +602,7 @@ function transform2View(func, decorator, options) {
             });
         }
         else {
-            return (0, utils_1.throwError)(options?.parsingId, '不支持的装饰器类型', decorator.type, decorator);
+            return (0, utils_1.throwError)(options, '不支持的装饰器类型', decorator.type, decorator);
         }
     }
     func.params.forEach((param) => {
@@ -557,13 +625,13 @@ function transform2View(func, decorator, options) {
                         propertyMap[property.value.left.name] = property.value;
                     }
                     else {
-                        return (0, utils_1.throwError)(options?.parsingId, '不支持的参数类型', property.value.type, property.value);
+                        return (0, utils_1.throwError)(options, '不支持的参数类型', property.value.type, property.value);
                     }
                 }
             });
             const type = param.typeAnnotation?.typeAnnotation;
             if (!type)
-                return (0, utils_1.throwError)(options?.parsingId, 'param 没有对应的类型', param);
+                return (0, utils_1.throwError)(options, 'param 没有对应的类型', param);
             type.members.forEach((member) => {
                 if (member.type === 'TSPropertySignature') {
                     const name = member.key.name;
@@ -581,13 +649,13 @@ function transform2View(func, decorator, options) {
     for (let index = 0; index < statements.length; index++) {
         const statement = statements[index];
         if (statement.type === 'VariableDeclaration') {
-            const variables = transform2Variables(statement);
+            const variables = transform2Variables(statement, { ...options });
             variables.forEach((variable) => {
                 view.addVariable(variable);
             });
         }
         else if (statement.type === 'FunctionDeclaration') {
-            const logic = (0, transform2Logic_1.transform2Logic)(statement, undefined, options);
+            const logic = (0, transform2Logic_1.transform2Logic)(statement, undefined, { ...options, logicType: 'view_logic' });
             view.addLogic(logic);
         }
         else if (statement.type === 'ExpressionStatement' && statement.expression.type === 'CallExpression') {
@@ -597,7 +665,7 @@ function transform2View(func, decorator, options) {
                 const arg = expression.arguments[0];
                 const bindEvent = new utils_1.naslTypes.BindEvent({
                     name: eventName,
-                    logics: transform2EventLogics(arg, eventName, options) || [],
+                    logics: transform2EventLogics(arg, eventName, { ...options }) || [],
                 });
                 view.addBindEvent(bindEvent);
             }
@@ -610,7 +678,7 @@ function transform2View(func, decorator, options) {
                         if (directoryItem) {
                             const nextStatement = statements[index + 1];
                             if (nextStatement) {
-                                const definitionItem = handleDirectoryItem(directoryItem, nextStatement, view, options, expression.callee.name);
+                                const definitionItem = handleDirectoryItem(directoryItem, nextStatement, view, { ...options }, expression.callee.name);
                                 if (definitionItem) {
                                     // 跳过下一个语句，因为已经处理过了
                                     index++;
@@ -618,33 +686,33 @@ function transform2View(func, decorator, options) {
                             }
                         }
                         else {
-                            return (0, utils_1.throwError)(options?.parsingId, '不支持的定义类型', directoryNode);
+                            return (0, utils_1.throwError)(options, '不支持的定义类型', directoryNode);
                         }
                     }
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, '不支持的表达式', statement);
+                    return (0, utils_1.throwError)(options, '不支持的表达式', statement);
                 }
             }
             else {
-                return (0, utils_1.throwError)(options?.parsingId, '不支持的表达式', statement);
+                return (0, utils_1.throwError)(options, '不支持的表达式', statement);
             }
         }
         else if (statement.type === 'ReturnStatement') {
             const arg = statement.argument;
             if (arg.type === 'JSXElement') {
-                const child = transformJSXElement2ViewElement(arg, { ...options, nameMap });
+                const child = transformJSXElement2ViewElement(arg, opts);
                 view.elements = child ? [child] : [];
             }
             else if (arg.type === 'JSXFragment') {
-                view.elements = arg.children.filter((child) => child.type === 'JSXElement').map((child) => transformJSXElement2ViewElement(child, { ...options, nameMap })).filter(Boolean);
+                view.elements = arg.children.filter((child) => child.type === 'JSXElement').map((child) => transformJSXElement2ViewElement(child, opts)).filter(Boolean);
             }
             else {
-                return (0, utils_1.throwError)(options?.parsingId, '返回值不正确', arg);
+                return (0, utils_1.throwError)(options, '返回值不正确', arg);
             }
         }
         else {
-            return (0, utils_1.throwError)(options?.parsingId, '不支持的表达式', statement);
+            return (0, utils_1.throwError)(options, '不支持的表达式', statement);
         }
     }
     return view;
@@ -654,6 +722,7 @@ function transformTSDeclareFunction2View(func, decorator, options) {
     const view = new utils_1.naslTypes.View({
         name: func.id?.name,
     });
+    options.nodeName = view.name;
     if (decorator) {
         if (decorator.arguments[0].type === 'ObjectExpression') {
             const viewObj = (0, utils_1.pickDecoratorObject)(decorator.arguments[0], new Set([
@@ -671,7 +740,7 @@ function transformTSDeclareFunction2View(func, decorator, options) {
             });
         }
         else {
-            return (0, utils_1.throwError)(options?.parsingId, '不支持的装饰器类型', decorator.type, decorator);
+            return (0, utils_1.throwError)(options, '不支持的装饰器类型', decorator.type, decorator);
         }
     }
     func.params.forEach((param) => {