@lcap/nasl 2.13.0-beta.2 → 2.13.1-beta.1

package/src/concepts/TypeAnnotation__.ts

@@ -42,7 +42,6 @@ import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 
-
 /**
  * 类型标注
  */
@@ -90,8 +89,6 @@ export class TypeAnnotation extends BaseNode {
     @property()
     ruleMap: Object = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -128,10 +125,6 @@ export class TypeAnnotation extends BaseNode {
         });
     }
 
-    
-
-    
-
     /**
     * 插入类型标注
     * @internal
@@ -164,8 +157,6 @@ export class TypeAnnotation extends BaseNode {
         return typeAnnotation;
     }
 
-    
-
     /**
      * 插入类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -188,8 +179,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加类型标注
      * @internal
@@ -209,8 +198,6 @@ export class TypeAnnotation extends BaseNode {
         return this._insertTypeAnnotationAt(options as any, index);
     }
 
-    
-
     /**
      * 添加类型标注
      * @param typeAnnotationOptions 类型标注参数
@@ -234,9 +221,6 @@ export class TypeAnnotation extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
      * 删除类型标注
      * @param typeAnnotation 已有的类型标注实例
@@ -244,7 +228,7 @@ export class TypeAnnotation extends BaseNode {
     removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
 
     removeTypeAnnotation(options: TypeAnnotation) {
-        let typeAnnotation: TypeAnnotation = options;
+        const typeAnnotation: TypeAnnotation = options;
         return typeAnnotation.delete();
     }
 
@@ -307,7 +291,7 @@ export class TypeAnnotation extends BaseNode {
             return typeTitle;
         } else if (this.typeKind === 'generic') {
             if (this.typeArguments && this.typeArguments.length)
-                return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.headTitle || 'T')}>`;
+                return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.headTitle || arg.name || 'T').join(', ')}>`;
             else
                 return this.typeName;
         } else {
@@ -324,18 +308,7 @@ export class TypeAnnotation extends BaseNode {
         } else if (this.typeKind === 'reference') {
             return this.typeName;
         } else if (this.typeKind === 'generic') {
-            let str = `${this.typeName}`;
-            const loop = (typeArguments: Array<TypeAnnotation>) => {
-                str += '<' + (typeArguments[0].typeTitle || 'T');
-                if (typeArguments[0].typeKind === 'generic') {
-                    if (this.typeArguments && this.typeArguments.length) {
-                        loop(typeArguments[0].typeArguments);
-                    }
-                }
-                str += '>';
-            };
-            loop(this.typeArguments);
-            return str;
+            return `${this.typeName}<${this.typeArguments.map((arg) => arg.typeTitle || arg.name || 'T').join(', ')}>`;
         } else {
             return this.typeName;
         }

package/src/concepts/Unparsed__.ts

@@ -30,8 +30,6 @@ export class Unparsed extends LogicItem {
     @property()
     code: string = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -45,7 +43,6 @@ export class Unparsed extends LogicItem {
         return super.from(source, parentNode, parentKey) as Unparsed;
     }
 
-    
     /**
      * 设置表达式代码
      */
@@ -58,25 +55,21 @@ export class Unparsed extends LogicItem {
         });
     }
 
-    
-
-    
-
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
     toVue(options?: ElementToVueOptions): string {
-        return this.code ? ` ${this.code} ` : '';
+        return this.code || '';
     }
 
     toUI(): string {
-        return this.code ? ` ${this.code} ` : '';
+        return this.code || '';
     }
 
     toJS(): string {
-        return this.code ? ` ${this.code} ` : '';
+        return this.code || '';
     }
 
     @withSourceMap()

package/src/concepts/Variable__.ts

@@ -342,12 +342,14 @@ export class Variable extends BaseNode {
                 }
             } else if (typeKind === 'generic') {
                 const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
+                const properties = [...node.properties] || [];
                 for (let i = 0; i < properties.length; i++) {
                     const item = properties[i];
                     if (item?.typeAnnotation?.typeKind === 'typeParam') {
-                        properties[i].typeAnnotation = this?.typeAnnotation?.typeArguments[0];
-                        properties[i].parentNode = this;
+                        const newItem = StructureProperty.from(item.toJSON());
+                        newItem.typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        newItem.parentNode = this;
+                        properties[i] = newItem;
                     }
                 }
                 completionChildren = properties;

package/src/concepts/ViewElement__.ts

@@ -268,8 +268,6 @@ export class ViewElement extends BaseNode {
         super.subConstructor(source);
     }
 
-
-
     /**
      * 从父级删除该节点
      * @internal
@@ -318,7 +316,7 @@ export class ViewElement extends BaseNode {
         });
     }
 
-        getBindAttributeExistingNames(excludedList: Array<BindAttribute> = []) {
+    getBindAttributeExistingNames(excludedList: Array<BindAttribute> = []) {
         const excludedSet = new Set(excludedList);
         return (this.bindAttrs || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -459,7 +457,6 @@ export class ViewElement extends BaseNode {
         return node;
     }
 
-
     getBindEventExistingNames(excludedList: Array<BindEvent> = []) {
         const excludedSet = new Set(excludedList);
         return (this.bindEvents || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -601,7 +598,6 @@ export class ViewElement extends BaseNode {
         return node;
     }
 
-
     getBindDirectiveExistingNames(excludedList: Array<BindDirective> = []) {
         const excludedSet = new Set(excludedList);
         return (this.bindDirectives || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -743,11 +739,6 @@ export class ViewElement extends BaseNode {
         return node;
     }
 
-
-
-
-
-
     /**
     * 插入页面元素
     * @internal
@@ -881,9 +872,6 @@ export class ViewElement extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
     * 删除元素绑定属性
     * @param name 元素绑定属性名称
@@ -932,8 +920,6 @@ export class ViewElement extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除元素绑定事件
     * @param name 元素绑定事件名称
@@ -982,8 +968,6 @@ export class ViewElement extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除元素指令
     * @param name 元素指令名称
@@ -1032,8 +1016,6 @@ export class ViewElement extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除页面元素
     * @param name 页面元素名称

package/src/concepts/View__.ts

@@ -1813,6 +1813,7 @@ export class View extends BaseNode {
             code += this.toEmbeddedTS(state);
         } catch (err) {
             code += '';
+            console.log(err);
         }
 
         code += '}\n';

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

@@ -68,6 +68,18 @@ export const collectionStructures = [
             }),
         ],
     }),
+    new Structure({
+        name: 'Map',
+        typeParams: [
+            new TypeParam({
+                name: 'K',
+            }),
+            new TypeParam({
+                name: 'V',
+            }),
+        ],
+        properties: [],
+    }),
 ];
 export const collectionTypeList: Array<TypeAnnotation> = reference2TypeAnnotationList(collectionStructures, 'nasl.collection');
 

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

@@ -221,7 +221,7 @@ export default new Namespace({
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
-                    name: 'seperator',
+                    name: 'separator',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -244,7 +244,7 @@ export default new Namespace({
                     }),
                 }),
                 new Param({
-                    name: 'seperator',
+                    name: 'separator',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -275,10 +275,10 @@ export default new Namespace({
         }),
         new Function({
             name: 'Length',
-            description: '返回字符串长度',
+            description: '获得String、Map、List的长度',
             params: [
                 new Param({
-                    name: 'str1',
+                    name: 'param',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -427,7 +427,7 @@ export default new Namespace({
                     }),
                 }),
                 new Param({
-                    name: 'addlist',
+                    name: 'addList',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
@@ -496,6 +496,188 @@ export default new Namespace({
                 }),
             ],
         }),
+        new Function({
+            name: 'MapGet',
+            description: '查询出Map中key为指定值的value值列表',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('V'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapPut',
+            description: '为Map中添加键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+                new Param({
+                    name: 'value',
+                    typeAnnotation: TypeAnnotation.createTypeParam('V'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapRemove',
+            description: '删除Map中的键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapContains',
+            description: '指定Map中是否存在参数key的键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('Boolean'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapKeys',
+            description: '输出Map中key集合',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapValues',
+            description: '输出Map中value集合',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('V')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'MapFilter',
+            description: '在指定Map中过滤出符合条件参数的Map集合',
+            params: [
+                new Param({
+                    name: 'map',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'byKey',
+                    defaultExpression: new Function({
+                        name: 'byKey',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'byValue',
+                    defaultExpression: new Function({
+                        name: 'byValue',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K')],
+                    }),
+                }),
+            ],
+        }),
         new Function({
             name: 'CurrDate',
             description: '返回当前日期',

package/src/concepts/basics/stdlib/reference2TypeAnnotationList.ts

@@ -15,7 +15,7 @@ export function reference2TypeAnnotationList(list: Array<Entity | Structure | En
             return TypeAnnotation.createReference(item.name, {
                 typeKind: 'generic',
                 typeNamespace: namespace,
-                typeArguments: item.typeParams.map((typeParam) => new TypeAnnotation()),
+                typeArguments: item.typeParams.map((typeParam) => new TypeAnnotation({ name: typeParam.name })),
             });
         } else {
             return TypeAnnotation.createReference(item.name, {

package/src/enums/KEYWORDS.ts

@@ -1198,3 +1198,19 @@ export const ENTITY_PROPERTY_KEYWORDS = [
     'STATIC',
     'YIELD',
 ];
+
+export const USER_CUSTOM_KEYWORDS = [
+    'annotation',
+    'app',
+    'component',
+    'components',
+    'config',
+    'configuration',
+    'dataSource',
+    'element',
+    'elements',
+    'function',
+    'match',
+    'operator',
+    'system',
+];

package/src/generator/genBundleFiles.ts

@@ -132,6 +132,29 @@ export async function genBundleFiles(app: App,
         if (view.isIndex) {
             indexName = view.name;
         }
+        function getAuth(data: View) {
+            if (!data) return
+            let res:any = {};
+            if( data.children.length === 0) {
+                res.name = data.name;
+                res.auth = data.auth;
+                res.children = [];
+            } else {
+                res.name = data.name;
+                res.auth = data.auth;
+                res.children = [];
+                data.children.forEach(item => {
+                    res.children.push(getAuth(item));
+                })
+            }
+            return res;
+        }
+
+        let filterChildren: any[];
+        filterChildren = [];
+        view.children.forEach(item => {
+            filterChildren.push(getAuth(item));
+        });
         pages[view.name] = {
             title: view.title,
             name: view.name,
@@ -140,7 +163,7 @@ export async function genBundleFiles(app: App,
             hasAuth: app.hasAuth,
             domainName: app.name,
             auth: view.auth,
-            subPage: view.children,
+            subPage: filterChildren,
             documentTitle: app.documentTitle,
             router: {
                 notFound: '/',

package/src/server/createUiTs.ts

@@ -1,18 +1,18 @@
 import { Logic, TypeAnnotation, Param, LogicItem, NumericLiteral, BooleanLiteral, StringLiteral, Identifier, MemberExpression } from '..';
 
 const naslStdlibMap: any = {
-    'nasl.core.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.core.ts').default,
-    'nasl.collection.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.collection.ts').default,
-    'nasl.interface.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.interface.ts').default,
-    'nasl.util.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.util.ts').default,
-    'nasl.ui.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.ui.ts').default,
-    'nasl.browser.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.browser.ts').default,
-    'nasl.auth.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.auth.ts').default,
-    'nasl.configuration.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.configuration.ts').default,
-    'nasl.langUtil.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.langUtil.ts').default,
-    'nasl.annotation.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.annotation.ts').default,
-    'nasl.validation.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.validation.ts').default,
-    'nasl.process.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.process.ts').default,
+    'nasl.core.ts': require('!!raw-loader!./stdlib/nasl.core.ts').default,
+    'nasl.collection.ts': require('!!raw-loader!./stdlib/nasl.collection.ts').default,
+    'nasl.interface.ts': require('!!raw-loader!./stdlib/nasl.interface.ts').default,
+    'nasl.util.ts': require('!!raw-loader!./stdlib/nasl.util.ts').default,
+    'nasl.ui.ts': require('!!raw-loader!./stdlib/nasl.ui.ts').default,
+    'nasl.browser.ts': require('!!raw-loader!./stdlib/nasl.browser.ts').default,
+    'nasl.auth.ts': require('!!raw-loader!./stdlib/nasl.auth.ts').default,
+    'nasl.configuration.ts': require('!!raw-loader!./stdlib/nasl.configuration.ts').default,
+    'nasl.langUtil.ts': require('!!raw-loader!./stdlib/nasl.langUtil.ts').default,
+    'nasl.annotation.ts': require('!!raw-loader!./stdlib/nasl.annotation.ts').default,
+    'nasl.validation.ts': require('!!raw-loader!./stdlib/nasl.validation.ts').default,
+    'nasl.process.ts': require('!!raw-loader!./stdlib/nasl.process.ts').default,
 };
 
 export default function formatUiTs(allComponent: any) {