@lcap/nasl 2.13.0 → 2.13.1-beta.1

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) {

package/src/server/formatTsUtils.ts

@@ -0,0 +1,319 @@
+import { BaseNode, Identifier, TypeAnnotation, StructureProperty, Entity, Structure, EntityProperty, Param, MemberExpression, CompletionProperty } from '..';
+import { getNaslNodeByNodeCallee } from '../automate/engine/utils';
+
+interface variableItem {
+    text: string;
+    completionDetail: any;
+    children?: variableItem[] | any;
+    name?: string;
+    value?: string;
+    expression: MemberExpression | Identifier;
+}
+/**
+ * 把ts返回的详细信息截取成一个类型字符串
+ * @param displayParts  ts返回的key value
+ *  // 0: {text: 'let', kind: 'keyword'}
+    // 1: {text: ' ', kind: 'space'}
+    // 2: {text: 'bindRoles', kind: 'text'}
+    // 3: {text: ':', kind: 'punctuation'}
+    // 4: {text: ' ', kind: 'space'}
+    // 5: {text: 'roles', kind: 'moduleName'}
+    // 6: {text: '.', kind: 'punctuation'}
+    // 7: {text: 'DEV_AdminRole', kind: 'enumName'}
+ * @returns type roles.DEV_AdminRole
+ */
+function formatTs2TypeString(displayParts: Array<{ text: string; kind: string }>) {
+    let str = '';
+    displayParts.forEach((item) => {
+        str += item.text;
+    });
+    const strTypes = str.split(': ');
+    const type = strTypes[1];
+    return type;
+}
+/**
+ * 把当前类型转成typeAnnotation
+ * @param type app
+ * @returns typeAnnotation
+ */
+function getCompletionDetailType(type: string): TypeAnnotation {
+    let typeAnnotation;
+    try {
+        if (type.includes('<') && type.includes('>')) {
+            // 泛型的处理
+            typeAnnotation = createGenericTypeAnnotation(type);
+        } else {
+            typeAnnotation = createType2Annotation(type);
+        }
+    } catch (err) {
+        console.log(err);
+    }
+    return typeAnnotation;
+}
+
+function createGenericTypeAnnotation(type: string) {
+    // 取出匹配的内容
+
+    const childType = type.substring(0, type.indexOf('<'));
+    const typeAnnotation = createType2Annotation(childType);
+    // 如果还有匹配到的多层泛型;
+    // 取出匹配到的内容
+    const types = /\<([^()]+)\>/g.exec(type);
+    const newtext = types[1];
+    // 把匹配的值，的内容在，检索一遍，看是不是泛型套泛型
+    const newTypes = /\<([^()]+)\>/g.exec(newtext);
+    // 如果是的话就去递归
+    if (newTypes) {
+        const argTypeAnnotation = createGenericTypeAnnotation(newtext);
+        typeAnnotation.typeArguments = [argTypeAnnotation];
+    } else {
+        // 如果不是就创造内部的真正类型
+        const argTypeAnnotation = createType2Annotation(newtext);
+        typeAnnotation.typeArguments = [argTypeAnnotation];
+    }
+    return typeAnnotation;
+}
+function createType2Annotation(type: string): TypeAnnotation {
+    let typeAnnotation;
+    // 没有泛型类型的
+    const types = type.split('.');
+    if (types.length === 1) {
+        typeAnnotation = TypeAnnotation.createPrimitive(types[0]);
+    } else {
+        if (type.startsWith('nasl.core')) {
+            typeAnnotation = TypeAnnotation.createPrimitive(types[types.length - 1]);
+        } else if (type.startsWith('nasl.ui')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'nasl.ui',
+            });
+        } else if (type.startsWith('nasl.process')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'nasl.process',
+            });
+        } else if (type.startsWith('nasl.collection')) {
+            typeAnnotation = TypeAnnotation.createGeneric(types[types.length - 1], {
+                typeNamespace: 'nasl.collection',
+            });
+        } else if (type.startsWith('entities.')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'app.entities',
+            });
+        } else if (type.startsWith('structures.')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'app.structures',
+            });
+        } else if (type.startsWith('enums.')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'app.enums',
+            });
+        }
+    }
+    return typeAnnotation;
+}
+export function getPlatformType(tsType: string): string {
+    const namespacePrefix = ['app', 'extensions', 'apis', 'components', 'nasl'];
+    if (tsType === 'String') {
+        return 'nasl.core.String';
+    } else if (tsType === 'Boolean') {
+        return 'nasl.core.Boolean';
+    }
+
+    const strTypes = tsType.split('.');
+    if (strTypes.length) {
+        const first = strTypes[0];
+        // 如果不是这几个前缀就加一个namespace
+        if (!namespacePrefix.includes(first)) {
+            return 'app.' + tsType;
+        }
+    }
+    return tsType;
+}
+export function isNoChildType(type: String) {
+    return type?.startsWith('nasl.core') || type?.startsWith('app.enums');
+}
+function findNode(typeKey: string, node: BaseNode) {
+    let newType: Structure | Entity;
+    if (typeKey.startsWith('nasl.') && typeKey.includes('<')) {
+        const findGenericsIndex = typeKey.indexOf('<');
+        typeKey = typeKey.substring(0, findGenericsIndex);
+        const typeIndex = typeKey.lastIndexOf('.');
+        newType = getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
+    } else if (typeKey.startsWith('nasl.')) {
+        const typeIndex = typeKey.lastIndexOf('.');
+        newType = getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
+    } else {
+        newType = (node as Identifier)?.app?.findNodeByCompleteName(typeKey);
+    }
+    return newType;
+}
+
+/**
+ * 获取下一级的节点进行递归
+ * @param typeKey 当前节点的类型，主要为了取出内部的 T中的实际类型
+ * @param item 当前节点的内容
+ * @param parent 父级节点的内容
+ * @param node 获取变量框的位置
+ */
+export function nextFindTypeChild(typeKey: string, item: any, parent: any, node: BaseNode) {
+    // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
+    const nodeMap = parent ? parent.nodeMap : new Map();
+    item.nodeMap = nodeMap;
+    const newType = findNode(typeKey, node);
+    if (newType?.properties && newType.properties.length) {
+        // 处理泛型的内容要取到值
+        const StructureJson = newType.toJSON();
+        const newStructure = new Structure(StructureJson);
+        newStructure.properties.forEach((item: StructureProperty | EntityProperty) => {
+            const itemType = item?.typeAnnotation?.typeKey;
+            if (itemType === 'T' && /\<([^()]+)\>/g.exec(typeKey)) {
+                const newTypes = /\<([^()]+)\>/g.exec(typeKey);
+                // 找到当前原来的类型
+                const contentType = getPlatformType(newTypes[1]);
+                const typeNamespace = contentType.substring(0, contentType.lastIndexOf('.'));
+                const typeName = contentType.substring(contentType.lastIndexOf('.') + 1, contentType.length);
+                item.typeAnnotation = new TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace,
+                    typeName,
+                });
+            }
+        });
+        const index = nodeMap.get(newType) || 0;
+        if (index) {
+            nodeMap.set(newType, index + 1);
+        } else {
+            nodeMap.set(newType, 1);
+        }
+        // 最多保留3层
+        if (index < 3) {
+            item.children = formatVariableData(newStructure.properties, node, item);
+        }
+    }
+}
+
+// 格式化变量数据
+export function formatVariableData(data: unknown | variableItem[], node: BaseNode, parent?: any) {
+    if (Array.isArray(data)) {
+        let result = data.map((item) => {
+            item.children = [];
+            // 当前结构的typeAnnotation
+            let typeAnnotation;
+            // 当前的类型如 app.entitys.entity1 nasl.core.String
+            let typeKey: string;
+
+            if (item.completionDetail) {
+                // 当前节点的完整类型，主要是在有T的内容使用 nasl.list<Enum1> 内部匹配内容给里面子集的T赋值类型
+                const currentType: string = formatTs2TypeString(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
+                typeAnnotation = getCompletionDetailType(currentType);
+                typeKey = getPlatformType(currentType);
+            } else if (item instanceof StructureProperty) {
+                typeKey = item?.typeAnnotation?.typeKey;
+            }
+            // 如果没有父节点就是Identifier
+            if (!parent) {
+                // value需要拼接生成
+                item.value = parent ? `${parent.value}.${item.text}` : item.text;
+                item.name = item.text;
+                const identifier = new Identifier({ name: item.name });
+                // 携带上当前的类型
+                identifier.typeAnnotation = typeAnnotation;
+                item.expression = identifier;
+            } else {
+                item.value = `${parent.value}.${item.name}`;
+                const memberExpression = new MemberExpression({
+                    object: parent.expression,
+                    property: new Identifier({ name: item.name }),
+                });
+                // 携带上当前的类型
+                memberExpression.typeAnnotation = typeAnnotation;
+                item.expression = memberExpression;
+            }
+            // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+            if (typeKey && !isNoChildType(typeKey)) {
+                nextFindTypeChild(typeKey, item, parent, node);
+            }
+            const completionProperty = new CompletionProperty(item);
+            if (!parent) {
+                // 变量 param return 在这里添加图标
+                completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
+            } else {
+                completionProperty.icon = 'refProperty';
+            }
+            return completionProperty;
+        });
+
+        /**
+         * 排序result
+         * 如果没有父级就是第一集就排序一下当前result，用户体验优化
+        */
+        if (!parent) {
+            result = sortFirstVariableData(result, node);
+        }
+        return result;
+    }
+}
+
+// 从logic获取节点的icon
+function getNodeiconFromLogic(completionProperty: CompletionProperty, node: BaseNode): string {
+    const logic = (node as Param).logic;
+    const view = (node as Param).view;
+    if (view) {
+        const { params } = view;
+        if (params.find((item) => item.name === completionProperty.name))
+            return 'param';
+    }
+    if (logic) {
+        const { params, returns } = logic;
+        if (params.find((item) => item.name === completionProperty.name))
+            return 'param';
+
+        if (returns.find((item) => item.name === completionProperty.name))
+            return 'return';
+        // if (variables.find((item) => item.name === completionProperty.name))
+        // return 'variable';
+
+        // 其余的全部按variable展示
+        return 'variable';
+    }
+    return 'variable';
+}
+
+
+/**
+ * 把要返回去的数据做一下排序
+ * @param result 要返回数据
+ * @param node 当前内容的上下级
+ * @returns 返回排序后的数组
+ * 因为ts会按照 a-z的顺序进行排序
+ * 但是影响用户体验，需要先按照页面排序，其次按照logic进行排序
+ * 流程的韬哥自己解决了，所以先解决这两部分
+ */
+ function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
+    const newResult: CompletionProperty[] = [];
+    const logic = (node as Param).logic;
+    const view = (node as Param).view;
+    if (view) {
+        const { params, variables } = view;
+        const list = [...params, ...variables];
+        list.forEach((item) => {
+            const findIndex = result.findIndex((findItem) => findItem.name === item.name);
+            if (findIndex === 0 || findIndex) {
+                newResult.push(result[findIndex]);
+                result.splice(findIndex, 1);
+            }
+        });
+    }
+    if (logic) {
+        const { params, returns, variables } = logic;
+        const list = [...params, ...returns, ...variables];
+        list.forEach((item) => {
+            const findIndex = result.findIndex((findItem) => findItem.name === item.name);
+            if (findIndex === 0 || findIndex) {
+                newResult.push(result[findIndex]);
+                result.splice(findIndex, 1);
+            }
+        });
+    }
+    newResult.push(...result);
+    return newResult;
+}