@lcap/nasl 2.18.0-beta.7 → 2.19.0-beta.1

package/src/templator/dist/utils.js

@@ -0,0 +1,527 @@
+"use strict";
+exports.__esModule = true;
+exports.NaslNode = exports.NaslQueryExpression = exports.NaslLogicItem = exports.NaslCollectionTypeAnnotation = exports.NaslTypeAnnotation = exports.NaslUITypeAnnotation = exports.NaslCoreTypeAnnotation = exports.genUniqueQueryNameGroup = exports.genMemberExpression = exports.genLogicParam = exports.getFirstDisplayedProperty = exports.getParamFromLogic = exports.getExpression = exports.filterProperty = void 0;
+var __1 = require("..");
+exports.filterProperty = function (key) { return function (property) {
+    if (property.display) {
+        return property.display[key];
+    }
+    else {
+        return !['id', 'createdTime', 'updatedTime'].includes(property.name);
+    }
+}; };
+/**
+ * 生成表达式的代码
+ * @param property 实体属性
+ * @param expression 表达式
+ */
+function getExpression(property, expression) {
+    var typeAnnotation = (property || {}).typeAnnotation;
+    var _a = typeAnnotation || {}, propertyTypeName = _a.typeName, propertyTypeNamespace = _a.typeNamespace;
+    if (propertyTypeName === 'DateTime')
+        return "$utils['FormatDateTime'](" + expression + ", 'YYYY-MM-DD HH:mm:ss')";
+    else if (propertyTypeName === 'Date')
+        return "$utils['FormatDate'](" + expression + ", 'YYYY-MM-DD')";
+    else {
+        var namespaceArr = propertyTypeNamespace.split('.');
+        var type = namespaceArr.pop();
+        if (type === 'enums') {
+            return "$utils['EnumValueToText'](" + expression + ", '__enumTypeAnnotation_" + propertyTypeNamespace + "." + propertyTypeName + "')";
+        }
+        else {
+            return "" + (expression || "''");
+        }
+    }
+}
+exports.getExpression = getExpression;
+/**
+ * 从 Logic 中获取变量
+ * @param resolver
+ * @param paramName
+ */
+function getParamFromLogic(logic, paramName) {
+    var params = logic.params;
+    return params.find(function (item) { return item.name === paramName; });
+}
+exports.getParamFromLogic = getParamFromLogic;
+function getFirstDisplayedProperty(entity) {
+    var property = entity.properties.find(function (property) { return !property.readonly; });
+    if (!property)
+        property = entity.properties[0];
+    return property;
+}
+exports.getFirstDisplayedProperty = getFirstDisplayedProperty;
+function genArgumentMemberExpression(arr) {
+    var expressionNode;
+    var propertyName = arr.pop();
+    if (arr.length >= 1) {
+        expressionNode = exports.NaslLogicItem.MemberExpression({
+            object: genArgumentMemberExpression(arr),
+            property: exports.NaslLogicItem.Identifier({
+                name: propertyName
+            })
+        });
+    }
+    else {
+        return exports.NaslLogicItem.Identifier({
+            name: propertyName
+        });
+    }
+    return expressionNode;
+}
+/**
+ * 生成逻辑 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+function genLogicParam(paramIdOrName, expression) {
+    return exports.NaslLogicItem.Argument({
+        keyword: paramIdOrName,
+        expression: genArgumentMemberExpression(expression.split('.'))
+    });
+}
+exports.genLogicParam = genLogicParam;
+/**
+ * 生成接口 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+function genMemberExpression(expression, schemaRefs) {
+    if (schemaRefs === void 0) { schemaRefs = []; }
+    var arr = expression.split('.');
+    var expressionNode;
+    arr.forEach(function (name, index) {
+        var currentNode = exports.NaslLogicItem.Identifier({
+            name: name
+        });
+        if (expressionNode) {
+            expressionNode = exports.NaslLogicItem.MemberExpression({
+                object: expressionNode,
+                property: exports.NaslLogicItem.Identifier({
+                    name: name
+                })
+            });
+        }
+        else {
+            expressionNode = currentNode;
+        }
+    });
+    return expressionNode;
+}
+exports.genMemberExpression = genMemberExpression;
+function capFirstLetter(word) {
+    if (!word)
+        return word;
+    return word[0].toUpperCase() + word.slice(1);
+}
+/**
+ * 生成数据查询唯一的命名组
+ * @param viewName 页面名称
+ * @param componentName 组件名称
+ * @param suffix 其它后缀，比如实体名等等
+ * @param defaultInView 是否在页面逻辑中用 load 简写
+ */
+function genUniqueQueryNameGroup(scope, view, componentName, defaultInView, suffix) {
+    if (componentName === void 0) { componentName = ''; }
+    if (defaultInView === void 0) { defaultInView = true; }
+    if (suffix === void 0) { suffix = ''; }
+    var result = {};
+    result.viewLogicLoad = view.getLogicUniqueName("load" + (defaultInView ? '' : capFirstLetter(componentName)) + (suffix ? capFirstLetter(suffix) : ''));
+    result.logic = scope.getLogicUniqueName("load" + capFirstLetter(view.name) + (componentName ? capFirstLetter(componentName) : '') + (suffix ? capFirstLetter(suffix) : ''));
+    result.structure = scope.getStructureUniqueName(__1.utils.firstUpperCase(result.logic + 'Structure'));
+    return result;
+}
+exports.genUniqueQueryNameGroup = genUniqueQueryNameGroup;
+function genNaslCoreTypeAnnotation(typeName, text) {
+    if (text === void 0) { text = ''; }
+    return {
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'primitive',
+        typeNamespace: 'nasl.core',
+        typeName: typeName,
+        text: text
+    };
+}
+function genNaslUITypeAnnotation(typeName) {
+    return {
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'reference',
+        typeNamespace: 'nasl.ui',
+        typeName: typeName
+    };
+}
+function genNaslCollectionTypeAnnotation(typeName) {
+    return function (typeArguments) { return ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'generic',
+        typeNamespace: 'nasl.collection',
+        typeName: typeName,
+        typeArguments: typeArguments
+    }); };
+}
+function genNaslUIGenericTypeAnnotation(typeName) {
+    return function (typeArguments) { return ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'generic',
+        typeNamespace: 'nasl.ui',
+        typeName: typeName,
+        typeArguments: typeArguments
+    }); };
+}
+exports.NaslCoreTypeAnnotation = {
+    Boolean: genNaslCoreTypeAnnotation('Boolean'),
+    Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
+    Double: genNaslCoreTypeAnnotation('Double'),
+    Decimal: genNaslCoreTypeAnnotation('Decimal'),
+    Long: genNaslCoreTypeAnnotation('Long', 'Long 长整数'),
+    String: genNaslCoreTypeAnnotation('String', 'String 字符串'),
+    Text: genNaslCoreTypeAnnotation('Text'),
+    Binary: genNaslCoreTypeAnnotation('Binary'),
+    Date: genNaslCoreTypeAnnotation('Date'),
+    Time: genNaslCoreTypeAnnotation('Time'),
+    DateTime: genNaslCoreTypeAnnotation('DateTime'),
+    Email: genNaslCoreTypeAnnotation('Email')
+};
+exports.NaslUITypeAnnotation = {
+    DataSourceParams: genNaslUITypeAnnotation('DataSourceParams'),
+    EventTarget: genNaslUITypeAnnotation('EventTarget'),
+    MouseEvent: genNaslUITypeAnnotation('MouseEvent'),
+    FocusEvent: genNaslUITypeAnnotation('FocusEvent'),
+    ChangeEvent: genNaslUITypeAnnotation('ChangeEvent'),
+    NavigateEvent: genNaslUITypeAnnotation('NavigateEvent'),
+    ChangeItemEvent: genNaslUITypeAnnotation('ChangeItemEvent'),
+    ChangeItemsEvent: genNaslUITypeAnnotation('ChangeItemsEvent'),
+    CascadeCapsulesEvent: genNaslUITypeAnnotation('CascadeCapsulesEvent'),
+    CollapseEvent: genNaslUITypeAnnotation('CollapseEvent'),
+    SliderEvent: genNaslUITypeAnnotation('SliderEvent'),
+    DateEvent: genNaslUITypeAnnotation('DateEvent'),
+    OperatorItemEvent: genNaslUITypeAnnotation('OperatorItemEvent'),
+    ValidateEvent: genNaslUITypeAnnotation('ValidateEvent'),
+    PaginationEvent: genNaslUITypeAnnotation('PaginationEvent'),
+    DurationEvent: genNaslUITypeAnnotation('DurationEvent'),
+    TransferEvent: genNaslUITypeAnnotation('TransferEvent'),
+    TreeChangeEvent: genNaslUITypeAnnotation('TreeChangeEvent'),
+    CheckedEvent: genNaslUITypeAnnotation('CheckedEvent'),
+    UploadEvent: genNaslUITypeAnnotation('UploadEvent'),
+    UploadErrorEvent: genNaslUITypeAnnotation('UploadErrorEvent'),
+    SortEvent: genNaslUITypeAnnotation('SortEvent'),
+    PoiInfo: genNaslUITypeAnnotation('PoiInfo'),
+    File: genNaslUITypeAnnotation('File'),
+    Current: genNaslUIGenericTypeAnnotation('Current')
+};
+exports.NaslTypeAnnotation = {
+    Reference: function (_a) {
+        var typeNamespace = _a.typeNamespace, typeName = _a.typeName;
+        return ({
+            concept: 'TypeAnnotation',
+            name: '',
+            typeKind: 'reference',
+            typeNamespace: typeNamespace,
+            typeName: typeName
+        });
+    },
+    AnonymousStructure: function (properties) { return ({
+        concept: 'TypeAnnotation',
+        typeKind: 'anonymousStructure',
+        properties: [{
+                concept: 'StructureProperty',
+                name: 'list',
+                typeAnnotation: {
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'List',
+                    typeNamespace: 'nasl.collection',
+                    typeArguments: [{
+                            concept: 'TypeAnnotation',
+                            typeKind: 'anonymousStructure',
+                            properties: properties
+                        }]
+                }
+            }, {
+                concept: 'StructureProperty',
+                name: 'total',
+                typeAnnotation: {
+                    concept: 'TypeAnnotation',
+                    typeKind: 'primitive',
+                    typeNamespace: 'nasl.core',
+                    typeName: 'Integer'
+                }
+            }]
+    }); }
+};
+exports.NaslCollectionTypeAnnotation = {
+    List: genNaslCollectionTypeAnnotation('List'),
+    PageOf: genNaslCollectionTypeAnnotation('PageOf')
+};
+exports.NaslLogicItem = {
+    // 开始
+    Start: {
+        concept: 'Start',
+        name: '',
+        label: '开始',
+        kind: 'Statement'
+    },
+    // 结束
+    End: {
+        concept: 'End',
+        name: '',
+        label: '结束',
+        kind: 'Statement'
+    },
+    // 调用逻辑
+    CallLogic: function (_a) {
+        var calleeNamespace = _a.calleeNamespace, calleeName = _a.calleeName, _b = _a.label, label = _b === void 0 ? '调用逻辑' : _b, _c = _a.shortcut, shortcut = _c === void 0 ? false : _c, args = _a.arguments;
+        return ({
+            concept: 'CallLogic',
+            name: '',
+            label: label,
+            kind: 'Statement',
+            shortcut: shortcut,
+            calleeNamespace: calleeNamespace,
+            calleeName: calleeName,
+            arguments: args
+        });
+    },
+    // 内置函数
+    CallFunction: function (_a) {
+        var _b = _a.calleeNamespace, calleeNamespace = _b === void 0 ? 'nasl.util' : _b, calleeName = _a.calleeName, _c = _a.label, label = _c === void 0 ? '内置函数' : _c, _d = _a.shortcut, shortcut = _d === void 0 ? false : _d, _e = _a.arguments, args = _e === void 0 ? [] : _e;
+        return ({
+            concept: 'CallFunction',
+            name: '',
+            label: '调用逻辑',
+            kind: 'Expression',
+            calleeNamespace: calleeNamespace,
+            calleeName: calleeName,
+            arguments: args
+        });
+    },
+    // 参数
+    Argument: function (_a) {
+        var keyword = _a.keyword, expression = _a.expression;
+        return ({
+            concept: 'Argument',
+            name: '',
+            kind: 'Statement',
+            keyword: keyword,
+            expression: expression
+        });
+    },
+    // 成员表达式
+    MemberExpression: function (_a) {
+        var object = _a.object, property = _a.property;
+        return ({
+            concept: 'MemberExpression',
+            name: '',
+            kind: 'Expression',
+            object: object,
+            property: property
+        });
+    },
+    // 变量
+    Identifier: function (_a) {
+        var name = _a.name;
+        return ({
+            concept: 'Identifier',
+            kind: 'Expression',
+            name: name
+        });
+    },
+    // 字面量
+    StringLiteral: function (_a) {
+        var value = _a.value;
+        return ({
+            concept: 'StringLiteral',
+            name: '',
+            kind: 'Expression',
+            value: value
+        });
+    },
+    Assignment: function (_a) {
+        var left = _a.left, right = _a.right;
+        return ({
+            concept: 'Assignment',
+            name: '',
+            label: '赋值',
+            kind: 'Statement',
+            left: left,
+            right: right
+        });
+    },
+    IfStatement: function (_a) {
+        var test = _a.test, consequent = _a.consequent, alternate = _a.alternate;
+        return ({
+            concept: 'IfStatement',
+            name: '',
+            kind: 'Statement',
+            test: test,
+            consequent: consequent,
+            alternate: alternate
+        });
+    },
+    // 二元
+    BinaryExpression: function (_a) {
+        var operator = _a.operator, left = _a.left, _b = _a.label, label = _b === void 0 ? '算术运算' : _b, right = _a.right;
+        return ({
+            concept: 'BinaryExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            operator: operator,
+            left: left,
+            right: right
+        });
+    }
+};
+exports.NaslQueryExpression = {
+    QueryFieldExpression: function (_a) {
+        var label = _a.label, isDotStar = _a.isDotStar, entityAsName = _a.entityAsName, propertyName = _a.propertyName;
+        return ({
+            concept: 'QueryFieldExpression',
+            name: '',
+            label: label,
+            kind: 'Expression',
+            isDotStar: isDotStar,
+            entityAsName: entityAsName,
+            propertyName: propertyName
+        });
+    },
+    QueryFromExpression: function (_a) {
+        var entityNamespace = _a.entityNamespace, entityName = _a.entityName, joinParts = _a.joinParts;
+        return ({
+            concept: 'QueryFromExpression',
+            name: '',
+            kind: 'Expression',
+            entityNamespace: entityNamespace,
+            entityName: entityName,
+            joinParts: joinParts
+        });
+    },
+    QueryJoinExpression: function (_a) {
+        var label = _a.label, entityNamespace = _a.entityNamespace, entityName = _a.entityName, joinType = _a.joinType, onExpressions = _a.onExpressions, joinParts = _a.joinParts;
+        return ({
+            concept: 'QueryJoinExpression',
+            label: label,
+            name: '',
+            kind: 'Expression',
+            entityNamespace: entityNamespace,
+            entityName: entityName,
+            joinType: joinType,
+            onExpressions: onExpressions,
+            joinParts: joinParts
+        });
+    },
+    QuerySelectExpression: function (_a) {
+        var label = _a.label, distinct = _a.distinct, star = _a.star, selectElements = _a.selectElements;
+        return ({
+            concept: 'QuerySelectExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            distinct: distinct,
+            star: star,
+            selectElements: selectElements
+        });
+    },
+    QueryOrderByExpression: function (_a) {
+        var label = _a.label, order = _a.order, orderElement = _a.orderElement;
+        return ({
+            concept: 'QueryOrderByExpression',
+            label: label,
+            order: order,
+            orderElement: orderElement
+        });
+    },
+    QueryLimitExpression: function (_a) {
+        var label = _a.label, pageElement = _a.pageElement, pageSizeElement = _a.pageSizeElement;
+        return ({
+            concept: 'QueryLimitExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            pageElement: pageElement,
+            pageSizeElement: pageSizeElement
+        });
+    },
+    CallQueryComponent: function (_a) {
+        var label = _a.label, typeAnnotation = _a.typeAnnotation, select = _a.select, from = _a.from, where = _a.where, limit = _a.limit, groupBy = _a.groupBy, having = _a.having, orderBy = _a.orderBy, logicName = _a.logicName, structureName = _a.structureName, ideVersion = _a.ideVersion;
+        return ({
+            concept: 'CallQueryComponent',
+            name: '',
+            label: label,
+            kind: 'Statement',
+            typeAnnotation: typeAnnotation,
+            select: select,
+            from: from,
+            where: where,
+            limit: limit,
+            groupBy: groupBy,
+            having: having,
+            orderBy: orderBy,
+            logicName: logicName,
+            structureName: structureName,
+            ideVersion: ideVersion
+        });
+    }
+};
+exports.NaslNode = {
+    Logic: function (_a) {
+        var name = _a.name, params = _a.params, returns = _a.returns, variables = _a.variables, body = _a.body, description = _a.description, playground = _a.playground;
+        return ({
+            concept: 'Logic',
+            name: name,
+            params: params,
+            returns: returns,
+            variables: variables,
+            body: body,
+            description: description,
+            playground: playground
+        });
+    },
+    Structure: function (_a) {
+        var name = _a.name, properties = _a.properties, origin = _a.origin;
+        return ({
+            concept: 'Structure',
+            name: name,
+            properties: properties,
+            origin: origin
+        });
+    },
+    StructureProperty: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'StructureProperty',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Variable: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Variable',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Param: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Param',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Return: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Return',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    }
+};

package/src/templator/genEditTableBlock.ts

@@ -1,14 +1,10 @@
 import * as utils from '../utils';
-import { App, Module, Namespace, Entity, EntityProperty, DataSource } from '../concepts';
+import { Entity, EntityProperty, DataSource } from '../concepts';
 import {
-    getExpression, filterProperty, NameGroup,
-    getFirstDisplayedProperty, getParamFromLogic, genCallComponentLogic,
-    genMemberExpression, genLogicParam,
+    filterProperty, NameGroup, getFirstDisplayedProperty, getParamFromLogic,
+    genCallComponentLogic, genMemberExpression, genLogicParam,
 } from '.';
-import {
-    NaslCoreTypeAnnotation, NaslUITypeAnnotation, NaslCollectionTypeAnnotation,
-    NaslTypeAnnotation, NaslLogicItem, NaslNode,
-} from './utils';
+import { NaslUITypeAnnotation, NaslLogicItem, NaslNode } from './utils';
 
 /**
  * 根据实体属性生成表格列模板
@@ -19,20 +15,16 @@ export function genEditTableColumnTemplate(entity: Entity, property: EntityPrope
     const lowerEntityName = utils.firstLowerCase(entity.name);
     const valueExpression = `current.item.${lowerEntityName}.${property.name}`;
     const title = property.label || property.name;
-
-    const expression = getExpression(property, `current.item.${lowerEntityName}.${property.name}`);
-
     const canEditable = (property: EntityProperty) => !property.readonly;
-
     const getText = (property: EntityProperty) => {
         const propertyTypeName = property.typeAnnotation.typeName;
         if (propertyTypeName === 'Boolean') {
             return `
-            <u-text v-if="${expression}" text="是"></u-text>
-            <u-text v-if="!${expression}" text="否"></u-text>
+            <u-text v-if="${valueExpression}" text="是"></u-text>
+            <u-text v-if="!${valueExpression}" text="否"></u-text>
             `;
         } else {
-            return `<u-text :text="${expression}"></u-text>`;
+            return `<u-text :text="${valueExpression}"></u-text>`;
         }
     };
 
@@ -120,7 +112,7 @@ export function genEditTableTemplate(entity: Entity, nameGroup: NameGroup, selec
     return `<u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" data-schema="${nameGroup.structure}"
         value-field="${nameGroup.viewVariableEntity}.id"
         :pageable="true" :remote-paging="true" :show-sizer="true" :default-column-width="300" editable>
-    <u-table-view-column type="index" width="60"><template #title><u-text text="序号"></u-text></template></u-table-view-column>
+    <u-table-view-column type="index" width="60"><template #title><u-text text="序号"></u-text></template><template #cell="current"></template></u-table-view-column>
 
     ${properties.map((property) => genEditTableColumnTemplate(entity, property, nameGroup, selectNameGroupMap) + '\n').join('')}
 

package/src/templator/genGetBlock.ts

@@ -2,7 +2,7 @@ import { config } from '../config';
 import * as utils from '../utils';
 import { Entity, Logic, View, ViewElement } from '../concepts';
 import { NaslCoreTypeAnnotation, NaslTypeAnnotation, NaslLogicItem, NaslNode } from './utils';
-import { NameGroup, filterProperty, getExpression, genLogicParam } from '.';
+import { NameGroup, filterProperty, genLogicParam } from '.';
 
 export function genGetTemplate(entity: Entity, nameGroup: NameGroup) {
     const properties = entity.properties.filter(filterProperty('inDetail'));
@@ -11,15 +11,14 @@ export function genGetTemplate(entity: Entity, nameGroup: NameGroup) {
     <u-info-list-group>
     <template #title><u-text text="基本信息"></u-text></template>
     ${properties
-        .map((property) => {
-            let formItem = `            <u-info-list-item><template #label><u-text text="${property.label || property.name}"></u-text></template>`;
-
-            formItem += '<u-text :text="' + getExpression(property, `${nameGroup.viewVariableEntity}.${property.name}`) + '"></u-text>';
-
-            formItem += `            </u-info-list-item>\n`;
-            return formItem;
-        })
-        .join('')}
+            .map((property) => {
+                const valueExpression = `${nameGroup.viewVariableEntity}.${property.name}`;
+                let formItem = `            <u-info-list-item><template #label><u-text text="${property.label || property.name}"></u-text></template>`;
+                formItem += `<u-text :text="'${valueExpression}'"></u-text>`;
+                formItem += `            </u-info-list-item>\n`;
+                return formItem;
+            })
+            .join('')}
     </u-info-list-group>
 </u-info-list>`;
 }
@@ -55,16 +54,16 @@ export function genH5GetTemplate(entity: Entity, nameGroup: NameGroup) {
 
     return `<van-cell-group>
     ${properties
-        .map((property) => {
-            const temptitle = property.label || property.name;
-            let formItem = `            <van-cell isLink`;
+            .map((property) => {
+                const temptitle = property.label || property.name;
+                let formItem = `            <van-cell isLink`;
 
-            formItem += ' :value="' + getExpression(property, `${nameGroup.viewVariableEntity}.${property.name}`) + '">';
-            formItem += `<template  #title>${temptitle}</template>`;
-            formItem += `<template>{{ ${getExpression(property, `${nameGroup.viewVariableEntity}.${property.name}`)} }}</template>            </van-cell>\n`;
-            return formItem;
-        })
-        .join('')}
+                formItem += ' :value="' + `${nameGroup.viewVariableEntity}.${property.name}` + '">';
+                formItem += `<template  #title>${temptitle}</template>`;
+                formItem += `<template>{{ ${`${nameGroup.viewVariableEntity}.${property.name}`} }}</template>            </van-cell>\n`;
+                return formItem;
+            })
+            .join('')}
 </van-cell-group>`;
 }