@lcap/nasl 2.16.1 → 2.17.1

package/src/concepts/basics/stdlib/nasl.process.ts

@@ -114,9 +114,18 @@ const logics = [
         returns: [
             new Return({
                 name: 'result',
-                typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
-                    typeArguments: [TypeAnnotation.createTypeParam('T')],
-                }),
+                typeAnnotation: TypeAnnotation.createTypeAnonymousStructure([
+                    new StructureProperty({
+                        name: 'list',
+                        typeAnnotation: TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createTypeParam('T')],
+                        }),
+                    }),
+                    new StructureProperty({
+                        name: 'total',
+                        typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                    }),
+                ]),
             }),
         ],
     }),
@@ -243,9 +252,19 @@ const logics = [
         ],
         returns: [
             new Return({
-                typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
-                    typeArguments: [TypeAnnotation.createTypeParam('T')],
-                }),
+                name: 'result',
+                typeAnnotation: TypeAnnotation.createTypeAnonymousStructure([
+                    new StructureProperty({
+                        name: 'list',
+                        typeAnnotation: TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createTypeParam('T')],
+                        }),
+                    }),
+                    new StructureProperty({
+                        name: 'total',
+                        typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                    }),
+                ]),
             }),
         ],
     }),

package/src/concepts/basics/stdlib/nasl.ui.ts

@@ -9,7 +9,7 @@ import { reference2TypeAnnotationList } from './reference2TypeAnnotationList';
 
 export const uiStructures = [
     new Structure({
-        name: 'ScopeOf',
+        name: 'Current',
         typeParams: [
             new TypeParam({
                 name: 'T',
@@ -746,7 +746,7 @@ export const uiStructures = [
         properties: [
             new StructureProperty({
                 name: 'field',
-                description: '排序字段',
+                description: '排序属性',
                 typeAnnotation: TypeAnnotation.createPrimitive('String'),
             }),
             new StructureProperty({

package/src/concepts/basics/stdlib/nasl.util.ts

@@ -12,6 +12,7 @@ import NumericLiteral from '../../NumericLiteral__';
 import Identifier from '../../Identifier__';
 import BooleanLiteral from '../../BooleanLiteral__';
 import StringLiteral from '../../StringLiteral__';
+import AnonymousFunction from '../../AnonymousFunction__';
 
 export default new Namespace({
     name: 'util',
@@ -214,7 +215,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'Split',
-            description: '将字符串参数，用分割符分割成字符串集合，并返回',
+            description: '将字符串参数，用分割符分割成字符串列表，并返回',
             params: [
                 new Param({
                     name: 'str',
@@ -235,7 +236,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'Join',
-            description: '将集合的项，用连接符连接成一个字符串，并返回',
+            description: '将列表的项，用连接符连接成一个字符串，并返回',
             params: [
                 new Param({
                     name: 'list',
@@ -320,7 +321,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'Trim',
-            description: '返回删除前后空格的字符串',
+            description: '删除字符串的前后空格并返回',
             params: [
                 new Param({
                     name: 'str1',
@@ -335,7 +336,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'Get',
-            description: '获得集合指定索引的项',
+            description: '获得列表位于指定索引处的项',
             params: [
                 new Param({
                     name: 'list',
@@ -356,7 +357,8 @@ export default new Namespace({
         }),
         new Function({
             name: 'Set',
-            description: '为集合指定索引赋值（覆盖原索引项）',
+            description: '为列表的指定索引项赋值（覆盖原索引项）',
+
             params: [
                 new Param({
                     name: 'list',
@@ -381,7 +383,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'Contains',
-            description: '返回集合是否包含某一项',
+            description: '测试列表是否包含某一项，返回测试结果',
             params: [
                 new Param({
                     name: 'list',
@@ -402,7 +404,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'Add',
-            description: '为集合末尾添加项，并返回集合长度',
+            description: '在列表末尾追加项',
             params: [
                 new Param({
                     name: 'list',
@@ -418,7 +420,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'AddAll',
-            description: '为集合添加多项内容，并返回集合长度',
+            description: '为一个列表添加另一列表中的多项内容，并返回新列表的长度',
             params: [
                 new Param({
                     name: 'list',
@@ -441,7 +443,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'Insert',
-            description: '为集合指定索引插入项（原索引项依次后推）',
+            description: '在列表的指定索引处插入新项（原索引项依次后推）',
             params: [
                 new Param({
                     name: 'list',
@@ -461,7 +463,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'Remove',
-            description: '删除集合的项',
+            description: '删除列表的某项',
             params: [
                 new Param({
                     name: 'list',
@@ -477,7 +479,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'RemoveAt',
-            description: '删除集合位于某个索引的项',
+            description: '在列表中删除位于指定索引的项',
             params: [
                 new Param({
                     name: 'list',
@@ -496,6 +498,183 @@ export default new Namespace({
                 }),
             ],
         }),
+        new Function({
+            name: 'ListHead',
+            description: '返回列表的首项',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListLast',
+            description: '返回列表的末项',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListFlatten',
+            description: '将嵌套列表摊平一层并返回（List<List<T>> 变为 List<T>）',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListToMap',
+            description: '选取列表项的某些属性，根据这些属性将列表变为 Map 并返回',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+                new Param({
+                    name: 'by',
+                    description: `<div>(\${0}) → Boolean | Integer | Long | Decimal | String</div>
+                                  <div>(\${0}) → V</div>`,
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+                new Param({
+                    name: 'byVal',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListTransform',
+            description: '对列表的每一项调用函数 by，得到新项；最终返回新项构成的列表',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '(${0}) → T',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListSum',
+            description: '返回数值列表中所有项的和',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListProduct',
+            description: '返回数值列表中所有项的积',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListAverage',
+            description: '返回数值列表中所有项的平均值',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListMax',
+            description: '返回数值列表中所有项的最大值',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListMin',
+            description: '返回数值列表中所有项的最小值',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+        }),
         new Function({
             name: 'MapGet',
             description: '查询出Map中key为指定值的value值列表',
@@ -632,10 +811,32 @@ export default new Namespace({
         }),
         new Function({
             name: 'MapFilter',
-            description: '在指定Map中过滤出符合条件参数的Map集合',
+            description: '在指定Map中过滤出符合条件参数的Map列表',
             params: [
                 new Param({
                     name: 'map',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '(${0},${1}) → Boolean',
+                    defaultExpression: new AnonymousFunction({
+                        name: '',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
                     typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
                             TypeAnnotation.createTypeParam('K'),
@@ -643,25 +844,43 @@ export default new Namespace({
                         ],
                     }),
                 }),
+            ],
+        }),
+        new Function({
+            name: 'MapTransform',
+            description: '对 Map 的每一项调用函数 by，得到新项，并返回新项构成的 Map。（Map 的每一项从 (K0, V0) 变为 (K, V)。）',
+            params: [
                 new Param({
-                    name: 'byKey',
-                    defaultExpression: new Function({
-                        name: 'byKey',
-                        description: '',
+                    name: 'map',
+                }),
+                new Param({
+                    name: 'by',
+                    description: `<div>(\${0}, \${1}) → Boolean | Integer | Long | Decimal | String</div>
+                                  <div>(\${0}, \${1}) → V</div>`,
+                    defaultExpression: new AnonymousFunction({
                         params: [
                             new Param({
                                 name: 'key',
                                 typeAnnotation: null,
                             }),
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
                         ],
+                        body: new Identifier({
+                            name: 'key',
+                        }),
                     }),
                 }),
                 new Param({
-                    name: 'byValue',
-                    defaultExpression: new Function({
-                        name: 'byValue',
-                        description: '',
+                    name: 'byVal',
+                    defaultExpression: new AnonymousFunction({
                         params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
                             new Param({
                                 name: 'value',
                                 typeAnnotation: null,
@@ -672,8 +891,8 @@ export default new Namespace({
             ],
             returns: [
                 new Return({
-                    typeAnnotation: TypeAnnotation.createGeneric('List', {
-                        typeArguments: [TypeAnnotation.createTypeParam('K')],
+                    typeAnnotation: TypeAnnotation.createGeneric('Map', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K'), TypeAnnotation.createTypeParam('V')],
                     }),
                 }),
             ],
@@ -929,8 +1148,8 @@ export default new Namespace({
             ],
         }),
         new Function({
-            name: 'CreatePageOf',
-            description: '将List<T>集合转换为分页集合PageOf<T>',
+            name: 'CreateListPage',
+            description: '将List<T>列表转换为列表分页',
             params: [
                 new Param({
                     name: 'list',
@@ -938,14 +1157,6 @@ export default new Namespace({
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param({
-                    name: 'page',
-                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-                }),
-                new Param({
-                    name: 'size',
-                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-                }),
                 new Param({
                     name: 'total',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
@@ -961,7 +1172,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'ListSort',
-            description: '为集合按规则排序',
+            description: '为列表按指定规则排序',
             params: [
                 new Param({
                     name: 'list',
@@ -998,7 +1209,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'ListFind',
-            description: '筛选符合条件的第一个项',
+            description: '返回列表中第一个符合条件的项',
             params: [
                 new Param({
                     name: 'list',
@@ -1022,15 +1233,13 @@ export default new Namespace({
             ],
             returns: [
                 new Return({
-                    typeAnnotation: TypeAnnotation.createGeneric('List', {
-                        typeArguments: [TypeAnnotation.createTypeParam('T')],
-                    }),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
         new Function({
             name: 'ListFindIndex',
-            description: '筛选符合条件的第一个项的索引值',
+            description: '返回列表中第一个符合条件的项的索引值',
             params: [
                 new Param({
                     name: 'list',
@@ -1059,20 +1268,16 @@ export default new Namespace({
             ],
         }),
         new Function({
-            name: 'ListFindAll',
-            description: '筛选符合条件的所有项',
+            name: 'ListFilter',
+            description: '返回列表中符合条件的所有项',
             params: [
                 new Param({
                     name: 'list',
-                    typeAnnotation: TypeAnnotation.createGeneric('List', {
-                        typeArguments: [TypeAnnotation.createTypeParam('T')],
-                    }),
                 }),
                 new Param({
                     name: 'by',
-                    defaultExpression: new Function({
-                        name: '',
-                        description: '',
+                    description: '(${0}) → Boolean',
+                    defaultExpression: new AnonymousFunction({
                         params: [
                             new Param({
                                 name: 'item',
@@ -1084,13 +1289,16 @@ export default new Namespace({
             ],
             returns: [
                 new Return({
-                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
                 }),
             ],
         }),
         new Function({
             name: 'ListReverse',
-            description: '为集合反向排序',
+            description: '将列表的所有项反向排列（例如第一项变为最后一项）',
             params: [
                 new Param({
                     name: 'list',
@@ -1103,7 +1311,7 @@ export default new Namespace({
         }),
         new Function({
             name: 'ListDistinct',
-            description: '为集合去除重复项',
+            description: '为列表去除重复项',
             params: [
                 new Param({
                     name: 'list',
@@ -1114,9 +1322,70 @@ export default new Namespace({
             ],
             returns: [],
         }),
+        new Function({
+            name: 'ListDistinctBy',
+            description: '按某个属性为列表去除重复项',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '(${0}) → T',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+            ],
+            returns: [new Return({
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [
+                        TypeAnnotation.createTypeParam('T'),
+                    ],
+                }),
+            })],
+        }),
+        new Function({
+            name: 'ListGroupBy',
+            description: '按某个属性为列表分组。以选中的属性为 key 建立 Map 并返回。',
+            params: [
+                new Param({
+                    name: 'list',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '(${0}) → Boolean | Integer | Long | Decimal | String',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+            ],
+            returns: [new Return({
+                typeAnnotation: TypeAnnotation.createGeneric('map', {
+                    typeArguments: [
+                        TypeAnnotation.createTypeParam('K'),
+                        TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createTypeParam('A')],
+                        }),
+                    ],
+                }),
+            })],
+        }),
         new Function({
             name: 'ListSlice',
-            description: '将集合按照规则切片，返回切片后的子集合',
+            description: '将列表按照规则切片，返回切片后的子列表',
             params: [
                 new Param({
                     name: 'list',
@@ -1142,8 +1411,8 @@ export default new Namespace({
             ],
         }),
         new Function({
-            name: 'ListSliceToPageOf',
-            description: '将集合按照规则切片，返回切片后的PageOf集合',
+            name: 'SliceToListPage',
+            description: '将列表按照规则切片，返回切片后的列表分页',
             params: [
                 new Param({
                     name: 'list',
@@ -1184,36 +1453,5 @@ export default new Namespace({
                 }),
             ],
         }),
-        // new Function({
-        //     name: 'CreatePageOf',
-        //     description: '将List<T>集合转换为分页集合PageOf<T>',
-        //     params: [
-        //         new Param({
-        //             name: 'list',
-        //             typeAnnotation: TypeAnnotation.createGeneric('List', {
-        //                 typeArguments: [TypeAnnotation.createTypeParam('T')],
-        //             }),
-        //         }),
-        //         new Param({
-        //             name: 'page',
-        //             typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-        //         }),
-        //         new Param({
-        //             name: 'size',
-        //             typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-        //         }),
-        //         new Param({
-        //             name: 'total',
-        //             typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-        //         }),
-        //     ],
-        //     returns: [
-        //         new Return({
-        //             typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
-        //                 typeArguments: [TypeAnnotation.createTypeParam('T')],
-        //             }),
-        //         }),
-        //     ],
-        // }),
     ],
 });