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

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;
+}

package/src/server/getLogics.ts

@@ -74,13 +74,13 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             }
             nc.map((item) => {
                 item.logics = item.logics.filter((logic) => !logic.name.startsWith('import'));
-                item.expanded = true;
+                item.expanded = false;
                 item.originConcept = 'Entity';
                 return item;
             });
             const ps = app.processes.map((p) => {
                 const pItem = process2LogicNamespace(p);
-                pItem.expanded = true;
+                pItem.expanded = false;
                 pItem.originConcept = 'Process';
                 return pItem;
             });
@@ -92,7 +92,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 logics: app.logics,
                 children: [...nc, ...extensions, ...ps],
             });
-            tree.expanded = true;
+            tree.expanded = false;
             result.push(tree);
         }
 
@@ -114,7 +114,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                         path: `elements.${toHump(item.name)}.logics`,
                         originConcept: 'ViewElement',
                     });
-                    viewElement.expanded = true;
+                    viewElement.expanded = false;
                     viewElements.push(viewElement);
                 }
             });
@@ -126,7 +126,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 logics: node.view.logics,
                 children: viewElements,
             });
-            tree.expanded = true;
+            tree.expanded = false;
             result.push(tree);
             const systemTree = new Namespace({
                 name: 'category',
@@ -138,37 +138,37 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                         path: `process`,
                         title: '流程逻辑',
                         logics: stdlibNamespace.findChild('process').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                     new Namespace({
                         name: 'category',
                         path: `browser`,
                         title: '浏览器',
                         logics: stdlibNamespace.findChild('browser').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                     new Namespace({
                         name: 'category',
                         path: `auth`,
                         title: '认证与权限',
                         logics: stdlibNamespace.findChild('auth').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                     new Namespace({
                         name: 'category',
                         path: `configuration`,
                         title: '配置',
                         logics: stdlibNamespace.findChild('configuration').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                 ],
-                expanded: true,
+                expanded: false,
             });
             if (!app.processes.length)
                 systemTree.children.shift();
 
-            systemTree.expanded = true;
-            systemTree.children.forEach((child) => (child.expanded = true));
+            systemTree.expanded = false;
+            systemTree.children.forEach((child) => (child.expanded = false));
             result.push(systemTree);
         } else {
             // 增加全局逻辑中的系统逻辑
@@ -182,25 +182,26 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                         path: `process`,
                         title: '流程逻辑',
                         logics: stdlibNamespace.findChild('process').logics,
-                        expanded: true,
+                        expanded: false,
                     }),
                     new Namespace({
                         name: 'category',
                         path: `configuration`,
                         title: '配置',
                         logics: stdlibNamespace.findChild('configuration').logics,
-                        expanded: true,
+                        expanded: false,
                     })
                 ],
-                expanded: true,
+                expanded: false,
             });
             if (!app.processes.length)
                 systemTree.children.shift();
 
-            systemTree.expanded = true;
-            systemTree.children.forEach((child) => (child.expanded = true));
+            systemTree.expanded = false;
+            systemTree.children.forEach((child) => (child.expanded = false));
             result.push(systemTree);
         }
+        console.log(result)
         return result;
     }
 }