@lcap/nasl 2.22.0-beta.0 → 2.22.0-beta.1

package/src/concepts/QuerySelectExpression__.ts

@@ -10,6 +10,7 @@ import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import QueryAggregateExpression from './QueryAggregateExpression__';
+import QueryFieldExpression from './QueryFieldExpression__';
 import LogicItem from './LogicItem__';
 
 /**
@@ -38,10 +39,8 @@ export class QuerySelectExpression extends LogicItem {
     /**
      * 查询聚合函数列表
      */
-    @property('QueryAggregateExpression')
-    selectElements: Array<QueryAggregateExpression> = [];
-
-    
+    @property('QueryAggregateExpression | QueryFieldExpression')
+    selectElements: Array<QueryAggregateExpression | QueryFieldExpression> = [];
 
     /**
      * @param source 需要合并的部分参数
@@ -59,11 +58,10 @@ export class QuerySelectExpression extends LogicItem {
         return super.from(source, parentNode, parentKey) as QuerySelectExpression;
     }
 
-    
     /**
      * 设置查询聚合函数列表
      */
-    setSelectElements(selectElements: Array<QueryAggregateExpression>) {
+    setSelectElements(selectElements: Array<QueryAggregateExpression | QueryFieldExpression>) {
         const object = {
             selectElements,
         };
@@ -72,7 +70,7 @@ export class QuerySelectExpression extends LogicItem {
         });
     }
 
-        getQueryAggregateExpressionExistingNames(excludedList: Array<QueryAggregateExpression> = []) {
+    getQueryAggregateExpressionExistingNames(excludedList: Array<QueryAggregateExpression> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.selectElements as QueryAggregateExpression[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -85,23 +83,23 @@ export class QuerySelectExpression extends LogicItem {
     * @internal
     * @param name 查询聚合函数名称，如果不填会自动生成一个唯一名称
     */
-    _insertQueryAggregateExpressionAt(name: string, index: number): QueryAggregateExpression;
+    _insertQueryAggregateExpressionInSelectElementsAt(name: string, index: number): QueryAggregateExpression;
 
     /**
     * 插入查询聚合函数
     * @internal
     * @param queryAggregateExpressionOptions 查询聚合函数参数
     */
-    _insertQueryAggregateExpressionAt(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>, index: number): QueryAggregateExpression;
+    _insertQueryAggregateExpressionInSelectElementsAt(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>, index: number): QueryAggregateExpression;
 
     /**
     * 插入查询聚合函数
     * @internal
     * @param queryAggregateExpression 已有的查询聚合函数实例
     */
-    _insertQueryAggregateExpressionAt(queryAggregateExpression: QueryAggregateExpression, index: number): QueryAggregateExpression;
+    _insertQueryAggregateExpressionInSelectElementsAt(queryAggregateExpression: QueryAggregateExpression, index: number): QueryAggregateExpression;
 
-    _insertQueryAggregateExpressionAt(options: string | Partial<QueryAggregateExpression> | QueryAggregateExpression, index: number) {
+    _insertQueryAggregateExpressionInSelectElementsAt(options: string | Partial<QueryAggregateExpression> | QueryAggregateExpression, index: number) {
         const queryAggregateExpressionOptions: any = {};
         const relationOptions = { parentNode: this, parentKey: 'selectElements' };
         let queryAggregateExpression: QueryAggregateExpression;
@@ -133,22 +131,22 @@ export class QuerySelectExpression extends LogicItem {
      * 插入查询聚合函数
      * @param name 查询聚合函数名称，如果不填会自动生成一个唯一名称
      */
-    insertQueryAggregateExpressionAt(name: string, index: number): QueryAggregateExpression;
+    insertQueryAggregateExpressionInSelectElementsAt(name: string, index: number): QueryAggregateExpression;
 
     /**
      * 插入查询聚合函数
      * @param queryAggregateExpressionOptions 查询聚合函数参数
      */
-    insertQueryAggregateExpressionAt(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>, index: number): QueryAggregateExpression;
+    insertQueryAggregateExpressionInSelectElementsAt(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>, index: number): QueryAggregateExpression;
 
     /**
      * 插入查询聚合函数
      * @param queryAggregateExpression 已有的查询聚合函数实例
      */
-    insertQueryAggregateExpressionAt(queryAggregateExpression: QueryAggregateExpression, index: number): QueryAggregateExpression;
+    insertQueryAggregateExpressionInSelectElementsAt(queryAggregateExpression: QueryAggregateExpression, index: number): QueryAggregateExpression;
 
-    insertQueryAggregateExpressionAt(options: string | Partial<QueryAggregateExpression> | QueryAggregateExpression, index: number) {
-        const node = this._insertQueryAggregateExpressionAt(options as any, index);
+    insertQueryAggregateExpressionInSelectElementsAt(options: string | Partial<QueryAggregateExpression> | QueryAggregateExpression, index: number) {
+        const node = this._insertQueryAggregateExpressionInSelectElementsAt(options as any, index);
         node.create({
             index,
             parentNode: this,
@@ -162,25 +160,25 @@ export class QuerySelectExpression extends LogicItem {
      * @internal
      * @param name 查询聚合函数名称，如果不填会自动生成一个唯一名称
      */
-    _addQueryAggregateExpression(name?: string): QueryAggregateExpression;
+    _addQueryAggregateExpressionInSelectElements(name?: string): QueryAggregateExpression;
 
     /**
      * 添加查询聚合函数
      * @internal
      * @param queryAggregateExpressionOptions 查询聚合函数参数
      */
-    _addQueryAggregateExpression(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>): QueryAggregateExpression;
+    _addQueryAggregateExpressionInSelectElements(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>): QueryAggregateExpression;
 
     /**
      * 添加查询聚合函数
      * @internal
      * @param queryAggregateExpression 已有的查询聚合函数实例
      */
-    _addQueryAggregateExpression(queryAggregateExpression: QueryAggregateExpression): QueryAggregateExpression;
+    _addQueryAggregateExpressionInSelectElements(queryAggregateExpression: QueryAggregateExpression): QueryAggregateExpression;
 
-    _addQueryAggregateExpression(options?: string | Partial<QueryAggregateExpression> | QueryAggregateExpression) {
+    _addQueryAggregateExpressionInSelectElements(options?: string | Partial<QueryAggregateExpression> | QueryAggregateExpression) {
         const index = this.selectElements.length;
-        return this._insertQueryAggregateExpressionAt(options as any, index);
+        return this._insertQueryAggregateExpressionInSelectElementsAt(options as any, index);
     }
 
     /**
@@ -188,22 +186,22 @@ export class QuerySelectExpression extends LogicItem {
      * @internal
      * @param name 查询聚合函数名称，如果不填会自动生成一个唯一名称
      */
-    addQueryAggregateExpression(name?: string): QueryAggregateExpression;
+    addQueryAggregateExpressionInSelectElements(name?: string): QueryAggregateExpression;
 
     /**
      * 添加查询聚合函数
      * @param queryAggregateExpressionOptions 查询聚合函数参数
      */
-    addQueryAggregateExpression(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>): QueryAggregateExpression;
+    addQueryAggregateExpressionInSelectElements(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>): QueryAggregateExpression;
 
     /**
      * 添加查询聚合函数
      * @param queryAggregateExpression 已有的查询聚合函数实例
      */
-    addQueryAggregateExpression(queryAggregateExpression: QueryAggregateExpression): QueryAggregateExpression;
+    addQueryAggregateExpressionInSelectElements(queryAggregateExpression: QueryAggregateExpression): QueryAggregateExpression;
 
-    addQueryAggregateExpression(options?: string | Partial<QueryAggregateExpression> | QueryAggregateExpression) {
-        const node = this._addQueryAggregateExpression(options as any);
+    addQueryAggregateExpressionInSelectElements(options?: string | Partial<QueryAggregateExpression> | QueryAggregateExpression) {
+        const node = this._addQueryAggregateExpressionInSelectElements(options as any);
         const index = this.selectElements.indexOf(node);
         node.create({
             index,
@@ -213,22 +211,152 @@ export class QuerySelectExpression extends LogicItem {
         return node;
     }
 
+    /**
+    * 插入查询属性
+    * @internal
+    * @param name 查询属性名称，如果不填会自动生成一个唯一名称
+    */
+    _insertQueryFieldExpressionInSelectElementsAt(name: string, index: number): QueryFieldExpression;
+
+    /**
+    * 插入查询属性
+    * @internal
+    * @param queryFieldExpressionOptions 查询属性参数
+    */
+    _insertQueryFieldExpressionInSelectElementsAt(queryFieldExpressionOptions: Partial<QueryFieldExpression>, index: number): QueryFieldExpression;
+
+    /**
+    * 插入查询属性
+    * @internal
+    * @param queryFieldExpression 已有的查询属性实例
+    */
+    _insertQueryFieldExpressionInSelectElementsAt(queryFieldExpression: QueryFieldExpression, index: number): QueryFieldExpression;
+
+    _insertQueryFieldExpressionInSelectElementsAt(options: string | Partial<QueryFieldExpression> | QueryFieldExpression, index: number) {
+        const queryFieldExpressionOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'selectElements' };
+        let queryFieldExpression: QueryFieldExpression;
+        if (!options) {
+            queryFieldExpression = QueryFieldExpression.from({
+                ...queryFieldExpressionOptions,
+                name: this.getQueryFieldExpressionUniqueName(),
+            }, this, 'selectElements');
+        } else if (typeof options === 'string') {
+            queryFieldExpression = QueryFieldExpression.from({
+                ...queryFieldExpressionOptions,
+                name: options,
+            }, this, 'selectElements');
+        } else if (options instanceof QueryFieldExpression) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            queryFieldExpression = options;
+            Object.assign(queryFieldExpression, relationOptions);
+        } else {
+            queryFieldExpression = QueryFieldExpression.from({
+                ...queryFieldExpressionOptions,
+                ...options,
+            }, this, 'selectElements');
+        }
+        this.selectElements.splice(index, 0, queryFieldExpression);
+        return queryFieldExpression;
+    }
+
+    /**
+     * 插入查询属性
+     * @param name 查询属性名称，如果不填会自动生成一个唯一名称
+     */
+    insertQueryFieldExpressionInSelectElementsAt(name: string, index: number): QueryFieldExpression;
+
+    /**
+     * 插入查询属性
+     * @param queryFieldExpressionOptions 查询属性参数
+     */
+    insertQueryFieldExpressionInSelectElementsAt(queryFieldExpressionOptions: Partial<QueryFieldExpression>, index: number): QueryFieldExpression;
+
+    /**
+     * 插入查询属性
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    insertQueryFieldExpressionInSelectElementsAt(queryFieldExpression: QueryFieldExpression, index: number): QueryFieldExpression;
+
+    insertQueryFieldExpressionInSelectElementsAt(options: string | Partial<QueryFieldExpression> | QueryFieldExpression, index: number) {
+        const node = this._insertQueryFieldExpressionInSelectElementsAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'selectElements',
+        });
+        return node;
+    }
+
+    /**
+     * 添加查询属性
+     * @internal
+     * @param name 查询属性名称，如果不填会自动生成一个唯一名称
+     */
+    _addQueryFieldExpressionInSelectElements(name?: string): QueryFieldExpression;
+
+    /**
+     * 添加查询属性
+     * @internal
+     * @param queryFieldExpressionOptions 查询属性参数
+     */
+    _addQueryFieldExpressionInSelectElements(queryFieldExpressionOptions: Partial<QueryFieldExpression>): QueryFieldExpression;
+
+    /**
+     * 添加查询属性
+     * @internal
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    _addQueryFieldExpressionInSelectElements(queryFieldExpression: QueryFieldExpression): QueryFieldExpression;
+
+    _addQueryFieldExpressionInSelectElements(options?: string | Partial<QueryFieldExpression> | QueryFieldExpression) {
+        const index = this.selectElements.length;
+        return this._insertQueryFieldExpressionInSelectElementsAt(options as any, index);
+    }
+
+    /**
+     * 添加查询属性
+     * @internal
+     * @param name 查询属性名称，如果不填会自动生成一个唯一名称
+     */
+    addQueryFieldExpressionInSelectElements(name?: string): QueryFieldExpression;
 
-    
+    /**
+     * 添加查询属性
+     * @param queryFieldExpressionOptions 查询属性参数
+     */
+    addQueryFieldExpressionInSelectElements(queryFieldExpressionOptions: Partial<QueryFieldExpression>): QueryFieldExpression;
+
+    /**
+     * 添加查询属性
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    addQueryFieldExpressionInSelectElements(queryFieldExpression: QueryFieldExpression): QueryFieldExpression;
+
+    addQueryFieldExpressionInSelectElements(options?: string | Partial<QueryFieldExpression> | QueryFieldExpression) {
+        const node = this._addQueryFieldExpressionInSelectElements(options as any);
+        const index = this.selectElements.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'selectElements',
+        });
+        return node;
+    }
 
     /**
     * 删除查询聚合函数
     * @param name 查询聚合函数名称
     */
-    removeQueryAggregateExpression(name: string): void;
+    removeQueryAggregateExpressionInSelectElements(name: string): void;
 
     /**
      * 删除查询聚合函数
      * @param queryAggregateExpression 已有的查询聚合函数实例
      */
-    removeQueryAggregateExpression(queryAggregateExpression: QueryAggregateExpression): void;
+    removeQueryAggregateExpressionInSelectElements(queryAggregateExpression: QueryAggregateExpression): void;
 
-    removeQueryAggregateExpression(options: string | QueryAggregateExpression) {
+    removeQueryAggregateExpressionInSelectElements(options: string | QueryAggregateExpression) {
         let queryAggregateExpression: QueryAggregateExpression;
         if (typeof options === 'string') {
             queryAggregateExpression = (this.selectElements as QueryAggregateExpression[]).find((item) => item.name === options);
@@ -241,6 +369,31 @@ export class QuerySelectExpression extends LogicItem {
         return queryAggregateExpression.delete();
     }
 
+    /**
+    * 删除查询属性
+    * @param name 查询属性名称
+    */
+    removeQueryFieldExpressionInSelectElements(name: string): void;
+
+    /**
+     * 删除查询属性
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    removeQueryFieldExpressionInSelectElements(queryFieldExpression: QueryFieldExpression): void;
+
+    removeQueryFieldExpressionInSelectElements(options: string | QueryFieldExpression) {
+        let queryFieldExpression: QueryFieldExpression;
+        if (typeof options === 'string') {
+            queryFieldExpression = (this.selectElements as QueryFieldExpression[]).find((item) => item.name === options);
+            if (!queryFieldExpression) {
+                throw new Error('找不到查询属性 ' + options);
+            }
+        } else {
+            queryFieldExpression = options;
+        }
+        return queryFieldExpression.delete();
+    }
+
     __removeLogicItem(logicItem: LogicItem) {
         const parentKey = logicItem.parentKey;
         const params: Params = {
@@ -269,6 +422,29 @@ export class QuerySelectExpression extends LogicItem {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
+    /**
+     * 聚合函数列表
+     */
+    get selectAggregateElements(): QueryAggregateExpression[] {
+        return this.selectElements.filter((item) => item.concept === 'QueryAggregateExpression') as QueryAggregateExpression[];
+    }
+
+    /**
+     * select字段列表
+     */
+    get selectFieldElements(): QueryFieldExpression[] {
+        return this.selectElements.filter((item) => item.concept === 'QueryFieldExpression') as QueryFieldExpression[];
+    }
+
+    getQueryFieldExpressionExistingNames(excludedList: Array<QueryFieldExpression> = []) {
+        const excludedSet = new Set(excludedList);
+        return ((this.selectElements as QueryFieldExpression[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+
+    getQueryFieldExpressionUniqueName(name = 'queryFieldExpression1') {
+        return utils.unique(name, this.getQueryFieldExpressionExistingNames(), undefined, false);
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/SwitchCase__.ts

@@ -290,7 +290,7 @@ export class SwitchCase extends LogicItem {
                     code
                         += logicItem.toEmbeddedTS(shiftState(state, code, {
                             tabSize: (state?.tabSize || 0) + 1,
-                        })) + '\n';
+                        })) + ';\n';
                 });
             }
             code += indent((state?.tabSize || 0)) + '}\n';
@@ -301,7 +301,7 @@ export class SwitchCase extends LogicItem {
                     code
                         += logicItem.toEmbeddedTS(shiftState(state, code, {
                             tabSize: (state?.tabSize || 0) + 1,
-                        })) + '\n';
+                        })) + ';\n';
                 });
             }
             code += indent((state?.tabSize || 0)) + '}\n';

package/src/concepts/TypeAnnotation__.ts

@@ -54,6 +54,11 @@ export const OLD_PRIMITIVE_TITLE: Record<string, string> = {
 };
 
 export const PRIMITIVE_DESC: Record<string, string> = {
+    Integer: '可表示最大长度约 10 个数字的正负整数（将被删除）',
+    Double: '小数，有效数字约 16 个左右（将被删除）',
+    Text: '底层与String相同，可存储更长的内容（将被删除）',
+    Binary: '用于二进制流的存储',
+    Email: '表示一个邮箱，底层与String相同（将被删除）',
     Boolean: '包含真（true）、假（false）两个值',
     Long: '可表示最大长度约 19 个数字的正负整数',
     Decimal: '可表示 31 个有效数字以内的小数',
@@ -68,7 +73,6 @@ export const GENERIC_DESC: Record<string, string> = {
     Map: '从K类型到V类型的映射',
 };
 
-
 /**
  * 判断是否是联合类型
  * @param typeAnnotation
@@ -153,8 +157,6 @@ export class TypeAnnotation extends BaseNode {
     @property()
     ruleMap: Object = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -194,10 +196,6 @@ export class TypeAnnotation extends BaseNode {
         });
     }
 
-    
-
-    
-
     /**
     * 插入类型标注
     * @internal
@@ -230,8 +228,6 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
-    
-
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -254,8 +250,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加类型标注
      * @internal
@@ -275,8 +269,6 @@ export class TypeAnnotation extends BaseNode {
         return this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
     }
 
-    
-
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -300,8 +292,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
     * 插入类型标注
     * @internal
@@ -334,8 +324,6 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
-    
-
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -358,8 +346,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加类型标注
      * @internal
@@ -379,8 +365,6 @@ export class TypeAnnotation extends BaseNode {
         return this._insertTypeAnnotationInReturnTypeAt(options as any, index);
     }
 
-    
-
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -404,11 +388,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-
-
-
-    
-
     /**
     * 插入数据结构属性
     * @internal
@@ -441,8 +420,6 @@ export class TypeAnnotation extends BaseNode {
         return structureProperty;
     }
 
-    
-
     /**
      * 插入数据结构属性
      * @param structurePropertyOptions 数据结构属性参数
@@ -465,8 +442,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加数据结构属性
      * @internal
@@ -486,8 +461,6 @@ export class TypeAnnotation extends BaseNode {
         return this._insertStructurePropertyAt(options as any, index);
     }
 
-    
-
     /**
      * 添加数据结构属性
      * @param structurePropertyOptions 数据结构属性参数
@@ -511,9 +484,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
@@ -521,12 +491,10 @@ export class TypeAnnotation extends BaseNode {
     removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
 
     removeTypeAnnotationInTypeArguments(options: TypeAnnotation) {
-        let typeAnnotation: TypeAnnotation = options;
+        const typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
-    
-
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
@@ -534,7 +502,7 @@ export class TypeAnnotation extends BaseNode {
     removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
 
     removeTypeAnnotationInReturnType(options: TypeAnnotation) {
-        let typeAnnotation: TypeAnnotation = options;
+        const typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
@@ -561,8 +529,6 @@ export class TypeAnnotation extends BaseNode {
         return params;
     }
 
-
-
     /**
      * 删除数据结构属性
      * @param structureProperty 已有的数据结构属性实例
@@ -570,7 +536,7 @@ export class TypeAnnotation extends BaseNode {
     removeStructureProperty(structureProperty: StructureProperty): void;
 
     removeStructureProperty(options: StructureProperty) {
-        let structureProperty: StructureProperty = options;
+        const structureProperty: StructureProperty = options;
         return structureProperty.delete();
     }
 

package/src/concepts/ViewElement__.ts

@@ -144,12 +144,26 @@ function transAstNodeToNaslNode(astNode: any, namespace?: string): any {
             };
         }
     } else if (astNode.type === 'UnaryExpression') {
+        const argument = astNode.argument;
+        if (argument.type === 'NumericLiteral') {
+            node = {
+                concept: 'NumericLiteral',
+                value: astNode.operator + argument.value,
+            };
+        } else {
+            node = {
+                concept: 'UnaryExpression',
+                kind: 'Expression',
+                name: '',
+                operator: astNode.operator,
+                argument: transAstNodeToNaslNode(astNode.argument),
+            };
+        }
+    } else if (astNode.type === 'NumericLiteral') {
+        const numberString = typeof astNode.value === 'number' ? astNode.value.toString() : astNode.value;
         node = {
-            concept: 'UnaryExpression',
-            kind: 'Expression',
-            name: '',
-            operator: astNode.operator,
-            argument: transAstNodeToNaslNode(astNode.argument),
+            concept: 'NumericLiteral',
+            value: numberString,
         };
     } else {
         node = astNode;
@@ -2027,7 +2041,11 @@ export class ViewElement extends BaseNode {
                     }
                     if (childEmpty) {
                         let addEmpty = true;
-                        if (el.tag === 'u-grid-view' || el.tag === 'u-list-view' || el.tag === 'van-list-view' || el.tag === 'van-grid-view') {
+                        if (['u-grid-view',
+                            'u-list-view',
+                            'van-list-view',
+                            'van-grid-view',
+                            'u-carousel'].includes(el.tag)) {
                             const hasDataSource = el.bindAttrs.find((attr) => attr.name === 'data-source');
                             addEmpty = !hasDataSource;
                         }