@lcap/nasl 3.1.0-beta.2 → 3.1.0-beta.4

package/out/src/server/formatTsUtils.js

@@ -1,857 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatConfigProperties = exports.formatFrontEndVariables = exports.formatBackendVariables = exports.formatVariableData = exports.nextFindTypeChild = exports.isNoChildType = exports.getPlatformType = exports.displayString2TypeAnnotation = exports.type2TypeAnnotation = void 0;
-const __1 = require("..");
-const utils_1 = require("../automate/engine/utils");
-/**
- * 把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) {
-    let str = '';
-    displayParts?.forEach((item) => {
-        str += item.text;
-    });
-    return str;
-}
-function isValidName(str) {
-    const regex = /^[a-zA-Z][a-zA-Z0-9_]*$/;
-    return regex.test(str);
-}
-/**
- * 解析 Completion 和 QuickInfo 的 displayString
- * 生成 TypeAnnotation
- * @param displayString
- * @returns TypeAnnotation
- */
-function type2TypeAnnotation(oldType) {
-    if (!oldType)
-        return null;
-    let type = oldType;
-    if (Array.isArray(oldType)) {
-        type = oldType[0];
-    }
-    let typeAnnotation;
-    try {
-        const { typeName, typeNamespace, typeArguments, typeKind, properties } = type;
-        if (typeKind === 'anonymousStructure') {
-            // 自定义类型
-            const newProperties = [];
-            if (Array.isArray(properties) && properties.length) {
-                properties.forEach((item) => {
-                    if (!item?.name?.startsWith('__')) {
-                        // 如果没有获取到类型，就默认塞一个string
-                        const itemType = type2TypeAnnotation(item.typeInfo) || __1.TypeAnnotation.createPrimitive('String');
-                        const structureProperty = __1.StructureProperty.from({ name: item.name, typeAnnotation: itemType }, typeAnnotation, 'properties');
-                        newProperties.push(structureProperty);
-                    }
-                });
-            }
-            typeAnnotation = __1.TypeAnnotation.createTypeAnonymousStructure(newProperties);
-        }
-        else if (!typeName || typeName === 'Promise' || typeName === 'nasl' || typeName === '___IDENTIFIER__') {
-            return null;
-        }
-        else if (typeName === 'String' || typeName === 'Boolean') {
-            typeAnnotation = __1.TypeAnnotation.createPrimitive(typeName);
-        }
-        else if (typeName === 'Union') {
-            typeAnnotation = __1.TypeAnnotation.createPrimitive('Union');
-            typeAnnotation.typeArguments = [];
-            typeArguments.forEach((item) => {
-                const typeItem = type2TypeAnnotation(item);
-                if (typeItem) {
-                    typeAnnotation.typeArgumentsPush(typeItem);
-                }
-            });
-        }
-        else if (typeNamespace && typeNamespace.startsWith('nasl.core')) {
-            typeAnnotation = __1.TypeAnnotation.createPrimitive(typeName);
-        }
-        else if (typeNamespace && typeArguments?.length) {
-            // 泛型类型
-            typeAnnotation = __1.TypeAnnotation.createGeneric(typeName, {
-                typeNamespace,
-            });
-            // 如果有泛型处理泛型
-            typeAnnotation.typeArguments = [];
-            typeArguments.forEach((item) => {
-                const typeItem = type2TypeAnnotation(item);
-                if (typeItem) {
-                    typeAnnotation.typeArgumentsPush(typeItem);
-                }
-            });
-        }
-        else {
-            // 其余的引用类型
-            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
-                typeNamespace,
-            });
-        }
-    }
-    catch (err) {
-        console.log(err, type);
-    }
-    return typeAnnotation;
-}
-exports.type2TypeAnnotation = type2TypeAnnotation;
-/**
- * 解析 Completion 和 QuickInfo 的 displayString
- * 生成 TypeAnnotation
- * @param displayString
- * @returns TypeAnnotation
- */
-function displayString2TypeAnnotation(typeStr, parentPrefix) {
-    let type = '';
-    if (typeStr?.includes(': ')) {
-        const lastIndexOf = typeStr.lastIndexOf(': ');
-        type = typeStr.substring(lastIndexOf + 2, typeStr.length);
-    }
-    else {
-        type = typeStr;
-    }
-    if (!type)
-        return;
-    type = type.replaceAll(' ', '');
-    if (type === 'Promise<void>')
-        return null;
-    // 把后面结尾里带()的比如
-    // 'function nasl.core.add(left: nasl.core.Long, right: nasl.core.Long): nasl.core.Long (+12 overloads)'
-    if (type.includes('(') && type.includes(')')) {
-        type = type.replace(/\([^)]*\)/g, '');
-    }
-    let typeAnnotation;
-    try {
-        if (type.includes('<') && type.includes('>')) {
-            // 泛型的处理
-            typeAnnotation = createGenericTypeAnnotation(type, parentPrefix);
-        }
-        else {
-            typeAnnotation = createType2Annotation(type, parentPrefix);
-        }
-    }
-    catch (err) {
-        console.log(err);
-    }
-    return typeAnnotation;
-}
-exports.displayString2TypeAnnotation = displayString2TypeAnnotation;
-function createGenericTypeAnnotation(type, parentPrefix) {
-    // 取出匹配的内容
-    const childType = type.substring(0, type.indexOf('<'));
-    const typeAnnotation = createType2Annotation(childType);
-    // 如果还有匹配到的多层泛型;
-    // 取出匹配到的内容
-    const types = /<([^()]+)>/g.exec(type);
-    if (types === null)
-        return types;
-    const newtext = types[1];
-    // 把匹配的值，的内容在，检索一遍，看是不是泛型套泛型
-    const newTypes = /<([^()]+)>/g.exec(newtext);
-    // 如果是的话就去递归
-    if (newTypes) {
-        const argTypeAnnotation = createGenericTypeAnnotation(newtext, parentPrefix);
-        typeAnnotation.typeArguments = [argTypeAnnotation];
-    }
-    else {
-        const argTypeAnnotation = createType2Annotation(newtext, parentPrefix);
-        // 如果不是就创造内部的真正类型
-        if (newtext.includes(',')) {
-            typeAnnotation.typeArguments = newtext.split(',').map((item) => createType2Annotation(item));
-        }
-        else {
-            typeAnnotation.typeArguments = [argTypeAnnotation];
-        }
-    }
-    return typeAnnotation;
-}
-function createType2Annotation(type, parentPrefix) {
-    let typeAnnotation;
-    // 没有泛型类型的
-    const types = type.split('.');
-    // 长度等于1就说明是
-    if (types.length === 1) {
-        typeAnnotation = __1.TypeAnnotation.createPrimitive(types[0]);
-    }
-    else {
-        const typeName = types.pop();
-        const typeNamespace = types.join('.');
-        if (type.startsWith('nasl.core')) {
-            typeAnnotation = __1.TypeAnnotation.createPrimitive(typeName);
-        }
-        else if (type.startsWith('nasl.ui')) {
-            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
-                typeNamespace,
-            });
-        }
-        else if (type.startsWith('nasl.process')) {
-            // nasl的引用类型
-            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
-                typeNamespace,
-            });
-        }
-        else if (type.startsWith('nasl.collection')) {
-            // nasl的泛型类型
-            typeAnnotation = __1.TypeAnnotation.createGeneric(typeName, {
-                typeNamespace,
-            });
-        }
-        else if (type.startsWith('dataSources.') || type.startsWith('structures.') || type.startsWith('enums.')) {
-            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
-                typeNamespace: (parentPrefix || 'app.') + typeNamespace,
-            });
-        }
-        else {
-            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
-                typeNamespace,
-            });
-        }
-    }
-    return typeAnnotation;
-}
-function getPlatformType(type) {
-    let tsType = '';
-    if (type?.includes(': ')) {
-        const lastIndexOf = type.lastIndexOf(': ');
-        tsType = type.substring(lastIndexOf + 2, type.length);
-    }
-    else {
-        tsType = type;
-    }
-    tsType = tsType.replaceAll(' ', '');
-    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;
-}
-exports.getPlatformType = getPlatformType;
-function isNoChildType(type) {
-    return (type?.startsWith('nasl.core') && !['String', 'Text', 'Email'].includes(type.split('.')[2])) || type?.startsWith('app.enums');
-}
-exports.isNoChildType = isNoChildType;
-function findNode(typeKey, node) {
-    let newType;
-    if (typeKey.startsWith('nasl.') && typeKey.includes('<')) {
-        const findGenericsIndex = typeKey.indexOf('<');
-        typeKey = typeKey.substring(0, findGenericsIndex);
-        const typeIndex = typeKey.lastIndexOf('.');
-        newType = (0, utils_1.getNaslNodeByNodeCallee)(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
-    }
-    else if (typeKey.startsWith('nasl.')) {
-        const typeIndex = typeKey.lastIndexOf('.');
-        newType = (0, utils_1.getNaslNodeByNodeCallee)(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
-    }
-    else {
-        newType = node?.app?.findNodeByCompleteName(typeKey);
-    }
-    return newType;
-}
-/**
- * 获取下一级的节点进行递归
- * @param typeKey 当前节点的类型，主要为了取出内部的 T中的实际类型
- * @param item 当前节点的内容
- * @param node 获取变量框的位置
- */
-function nextFindTypeChild(typeKey, item, node) {
-    const newType = findNode(typeKey, node);
-    if (newType?.properties && newType.properties.length) {
-        // 处理泛型的内容要取到值
-        const StructureJson = newType.toJSON();
-        const newStructure = new __1.Structure(StructureJson);
-        newStructure.properties.forEach((item) => {
-            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 __1.TypeAnnotation({
-                    typeKind: 'reference',
-                    typeNamespace,
-                    typeName,
-                });
-            }
-        });
-        item.children = formatVariableData(newStructure.properties, node, item);
-    }
-}
-exports.nextFindTypeChild = nextFindTypeChild;
-/**
- * 获取scope下一级的展示
- * @param type 返回的字符串如下展示
- *  `nasl.ui.Current<{
-    __name: "AStructure_dc8bcbaf";
-    entity1: dataSources.defaultDS.entities.Entity1;
-    lCAPRolePerMapping: dataSources.defaultDS.entities.LCAPRolePerMapping;
-}>`
- */
-function getAStructureScopeType(type, parent, node) {
-    let newType = type.replaceAll(' ', '').replaceAll('\n', '').replace(/__name:"AStructure_\w{8}";/g, '');
-    const parentItem = parent;
-    // 如果没有父节点就是Identifier
-    // value需要拼接生成
-    const identifier = new __1.Identifier({ name: parentItem.text });
-    parentItem.expression = identifier;
-    parentItem.value = parentItem.text;
-    parentItem.name = parentItem.text;
-    // 处理泛型的内容要取到值
-    const newNode = findNode(newType, node);
-    const StructureJson = newNode.toJSON();
-    const newStructure = new __1.Structure(StructureJson);
-    const children = newStructure.properties;
-    if (children && children.length) {
-        const newChildren = children.map((structureProperty) => {
-            const structureItem = structureProperty;
-            // 如果没有父节点就是Identifier
-            structureItem.value = `${parentItem.value}.${structureItem.name}`;
-            const memberExpression = new __1.MemberExpression({
-                object: parentItem.expression,
-                property: new __1.Identifier({ name: structureItem.name }),
-            });
-            structureItem.expression = memberExpression;
-            // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-            structureItem.concept = 'CompletionProperty';
-            const completionProperty = new __1.CompletionProperty(structureItem);
-            completionProperty.icon = 'refProperty';
-            if (structureItem.name === 'item') {
-                const context = /\{([^()]+)\}/.exec(newType);
-                newType = context[1];
-                let res = [];
-                newType.split(';').forEach((item) => {
-                    if (item) {
-                        const itemArr = item.split(':');
-                        const name = itemArr[0];
-                        let typeKey = itemArr[1];
-                        if (typeKey && typeKey.startsWith('dataSources')) {
-                            typeKey = 'app.' + typeKey;
-                        }
-                        // 如果ls传过来的名字是不合法的就隐藏
-                        if (!isValidName(name)) {
-                            console.warn(item, '获取变量不展示');
-                            return null;
-                        }
-                        res.push({
-                            name,
-                            typeKey,
-                        });
-                    }
-                });
-                res = res.map((item) => {
-                    const newItem = item;
-                    // 如果没有父节点就是Identifier
-                    newItem.value = `${structureItem.value}.${newItem.name}`;
-                    const memberExpression = new __1.MemberExpression({
-                        object: structureItem.expression,
-                        property: new __1.Identifier({ name: newItem.name }),
-                    });
-                    newItem.expression = memberExpression;
-                    // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-                    newItem.concept = 'CompletionProperty';
-                    // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
-                    if (item.typeKey && !isNoChildType(item.typeKey)) {
-                        newItem.children = nextObjectTypeChild(item.typeKey, newItem, node);
-                    }
-                    newItem.typeAnnotation = displayString2TypeAnnotation(newItem.typeKey);
-                    const completionProperty = new __1.CompletionProperty(newItem);
-                    completionProperty.icon = 'refProperty';
-                    return completionProperty;
-                });
-                completionProperty.children = res;
-                return completionProperty;
-            }
-            else {
-                return completionProperty;
-            }
-        });
-        parentItem.children = newChildren;
-    }
-    const completionProperty = new __1.CompletionProperty(parentItem);
-    // 变量 param return 在这里添加图标
-    completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
-    return completionProperty;
-}
-/**
- * 获取对象类型的下一级展示
- * @param type 返回的字符串如下展示
- *  `{
-    __name: "AStructure_bf19c4d5";
-    list: nasl.collection.List<{
-        __name: "AStructure_dc8bcbaf";
-        entity1: app.dataSources.defaultDS.entities.Entity1;
-        lCAPRolePerMapping: app.dataSources.defaultDS.entities.LCAPRolePerMapping;
-    }>;
-    total: nasl.core.Long;
-}`
- */
-function getAStructureObjectStringType(type, parent, node) {
-    let newType = type.replaceAll(' ', '').replaceAll('\n', '').replace(/__name:"AStructure_\w{8}";/g, '');
-    newType = newType.substring(1, newType.length - 1);
-    if (/\{([^()]+)\}/.exec(newType)) {
-        newType = newType.replace(/\{([^()]+)\}/, '');
-    }
-    let res = [];
-    newType.split(';').forEach((item) => {
-        if (item) {
-            const itemArr = item.split(':');
-            const name = itemArr[0];
-            const typeKey = itemArr[1];
-            res.push({
-                name,
-                typeKey,
-            });
-        }
-    });
-    const parentItem = parent;
-    // 如果没有父节点就是Identifier
-    // value需要拼接生成
-    const identifier = new __1.Identifier({ name: parentItem.text });
-    parentItem.expression = identifier;
-    parentItem.value = parentItem.text;
-    parentItem.name = parentItem.text;
-    // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-    parentItem.concept = 'CompletionProperty';
-    res = res.map((item) => {
-        const newItem = item;
-        // 如果没有父节点就是Identifier
-        newItem.value = `${parentItem.value}.${newItem.name}`;
-        const memberExpression = new __1.MemberExpression({
-            object: parentItem.expression,
-            property: new __1.Identifier({ name: newItem.name }),
-        });
-        newItem.expression = memberExpression;
-        // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-        newItem.concept = 'CompletionProperty';
-        // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
-        if (item.typeKey && !isNoChildType(item.typeKey)) {
-            newItem.children = nextObjectTypeChild(getPlatformType(item.typeKey), newItem, node);
-        }
-        newItem.typeAnnotation = displayString2TypeAnnotation(newItem.typeKey);
-        const completionProperty = new __1.CompletionProperty(newItem);
-        completionProperty.icon = 'refProperty';
-        return completionProperty;
-    });
-    parentItem.children = res;
-    const completionProperty = new __1.CompletionProperty(parentItem);
-    // 变量 param return 在这里添加图标
-    completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
-    return completionProperty;
-}
-function nextObjectTypeChild(typeKey, item, node) {
-    const newType = findNode(typeKey, node);
-    if (newType?.properties && newType.properties.length) {
-        // 处理泛型的内容要取到值
-        const StructureJson = newType.toJSON();
-        const newStructure = new __1.Structure(StructureJson);
-        newStructure.properties.forEach((item) => {
-            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 __1.TypeAnnotation({
-                    typeKind: 'reference',
-                    typeNamespace,
-                    typeName,
-                });
-            }
-        });
-        return formatVariableData(newStructure.properties, node, item);
-    }
-}
-function getNodeTypeVariableData(nodeType, item, node) {
-    item.value = item.text;
-    item.name = item.text;
-    const parentExpression = new __1.Identifier({ name: item.text });
-    item.expression = parentExpression;
-    if (nodeType) {
-        const typeAnnotation = type2TypeAnnotation(nodeType);
-        const typeKeyMap = new Map();
-        const app = (node.rootNode);
-        let structure = {};
-        // 偶尔会报这个错误，先跳过吧
-        if (!typeAnnotation) {
-            return;
-        }
-        // 数据查询没有输出参数，特殊处理
-        if (typeAnnotation.typeKind === 'anonymousStructure') {
-            structure = { properties: typeAnnotation.properties };
-        }
-        else if (typeAnnotation.typeArguments) {
-            structure = { properties: app.getSelectRef(typeAnnotation, true) };
-        }
-        else {
-            structure = app.findNodeByCompleteName(typeAnnotation.typeNamespace + '.' + typeAnnotation.typeName);
-        }
-        structure?.properties?.forEach((structureProperty) => {
-            const { name, typeAnnotation } = structureProperty;
-            const expression = new __1.MemberExpression({
-                object: parentExpression,
-                property: new __1.Identifier({ name }),
-            });
-            const completionData = new __1.CompletionProperty({
-                name,
-                value: name,
-                expression,
-                children: [],
-            });
-            completionData.icon = 'refProperty';
-            item.children.push(completionData);
-            recursionProperty(typeAnnotation, completionData, node, typeKeyMap);
-        });
-    }
-    const completionData = new __1.CompletionProperty(item);
-    // 变量 param return 在这里添加图标
-    completionData.icon = getNodeiconFromLogic(completionData, node);
-    return completionData;
-}
-function recursionProperty(structureTypeAnnotation, parentCompletion, node, typeKeyMap) {
-    const app = (node.rootNode);
-    let structure;
-    if (structureTypeAnnotation.typeArguments) {
-        structure = { properties: app.getSelectRef(structureTypeAnnotation, true) };
-    }
-    else {
-        if (structureTypeAnnotation.typeKind === 'anonymousStructure') {
-            structure = { properties: structureTypeAnnotation.properties };
-        }
-        else {
-            structure = app.findNodeByCompleteName(structureTypeAnnotation.typeNamespace + '.' + structureTypeAnnotation.typeName);
-        }
-    }
-    structure?.properties?.forEach((structureProperty) => {
-        const { name, typeAnnotation } = structureProperty;
-        const object = __1.BaseNode.from({ ...parentCompletion.expression.toJSON() });
-        const expression = new __1.MemberExpression({
-            object,
-            property: new __1.Identifier({ name }),
-        });
-        const completionData = new __1.CompletionProperty({
-            name,
-            value: name,
-            expression,
-            children: [],
-        });
-        completionData.icon = 'refProperty';
-        parentCompletion.children.push(completionData);
-        if (getNextFlag(typeAnnotation.typeKey, typeKeyMap)) {
-            recursionProperty(typeAnnotation, completionData, node, typeKeyMap);
-        }
-    });
-}
-function getNextFlag(typeKey, typeKeyMap) {
-    if (['nasl.core.String', 'nasl.collection.List', 'nasl.collection.Map'].includes(typeKey))
-        return true;
-    if (typeKeyMap.get(typeKey) === 3) {
-        return false;
-    }
-    else if (typeKeyMap.get(typeKey) > 0) {
-        typeKeyMap.set(typeKey, typeKeyMap.get(typeKey) + 1);
-    }
-    else {
-        typeKeyMap.set(typeKey, 1);
-    }
-    return true;
-}
-// 格式化变量数据
-function formatVariableData(data, node, parent) {
-    if (Array.isArray(data)) {
-        let result = data.map((item) => {
-            item.children = [];
-            // 当前的类型如 app.entitys.entity1 nasl.core.String
-            let typeKey;
-            if (item.completionDetail) {
-                if (item.completionDetail?.hasOwnProperty('nodeType') || item.completionDetail?.hasOwnProperty('newNodeType')) {
-                    const completionProperty = getNodeTypeVariableData(item.completionDetail?.nodeType || item.completionDetail?.newNodeType, item, node);
-                    return completionProperty;
-                }
-                else {
-                    // 当前节点的完整类型，主要是在有T的内容使用 nasl.list<Enum1> 内部匹配内容给里面子集的T赋值类型
-                    let currentType = formatTs2TypeString(item.completionDetail.displayParts);
-                    if (currentType) {
-                        if (currentType?.includes(': ')) {
-                            const indexOf = currentType.indexOf(': ');
-                            const newCurrentType = currentType.substring(indexOf + 2, currentType.length);
-                            // 如果是对象形式的就单独处理
-                            if (newCurrentType.startsWith('{') && newCurrentType.endsWith('}')) {
-                                const completionProperty = getAStructureObjectStringType(newCurrentType, item, node);
-                                return completionProperty;
-                            }
-                            else if (newCurrentType.startsWith('nasl.ui.Current<{')) {
-                                const completionProperty = getAStructureScopeType(newCurrentType, item, node);
-                                return completionProperty;
-                            }
-                            else if (newCurrentType.startsWith('nasl.collection.List<{') && newCurrentType.endsWith('}>')) {
-                                currentType = 'nasl.collection.List<nasl.core.Any>';
-                            }
-                        }
-                    }
-                    typeKey = getPlatformType(currentType);
-                    item.typeAnnotation = displayString2TypeAnnotation(typeKey);
-                }
-            }
-            else if (item instanceof __1.StructureProperty || item instanceof __1.EntityProperty) {
-                typeKey = item?.typeAnnotation?.typeKey;
-            }
-            // 如果没有父节点就是Identifier
-            if (!parent) {
-                // value需要拼接生成
-                item.value = parent ? `${parent.value}.${item.text}` : item.text;
-                item.name = item.text;
-                const identifier = new __1.Identifier({ name: item.name });
-                item.expression = identifier;
-                item.typeKey = typeKey;
-            }
-            else {
-                item.value = `${parent.value}.${item.name}`;
-                const object = __1.BaseNode.from(parent.expression.toJSON());
-                const memberExpression = new __1.MemberExpression({
-                    object,
-                    property: new __1.Identifier({ name: item.name }),
-                });
-                item.expression = memberExpression;
-                item.variableParent = parent;
-                item.typeKey = typeKey;
-                // 标记实体属性是否是符合类型
-                item.isComplexType = item.typeAnnotation?.isComplexType();
-            }
-            // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
-            if (typeKey && !isNoChildType(typeKey)) {
-                let currentParent = item;
-                let typeKeyIndex = 0;
-                while (currentParent.variableParent) {
-                    currentParent = currentParent.variableParent;
-                    if (currentParent.typeKey === typeKey) {
-                        typeKeyIndex++;
-                    }
-                }
-                // 向上找到3次一样的就结束
-                if (typeKeyIndex < 3) {
-                    nextFindTypeChild(typeKey, item, node);
-                }
-            }
-            // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-            item.concept = 'CompletionProperty';
-            const completionProperty = new __1.CompletionProperty(item);
-            completionProperty.jsonName = item.jsonName;
-            // 标记实体属性是否是符合类型
-            if (typeof item.isComplexType === 'boolean') {
-                Object.assign(completionProperty, { isComplexType: item.isComplexType });
-            }
-            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.filter(Boolean);
-    }
-}
-exports.formatVariableData = formatVariableData;
-// 从logic获取节点的icon
-function getNodeiconFromLogic(completionProperty, node) {
-    const { name: propName } = completionProperty;
-    const { view } = node;
-    const logic = node.logic || node.OverriddenLogic || node.AuthLogic || node.AuthLogicForCallInterface;
-    if (node.concept === 'Identifier' || node.concept === 'BindAttribute' || node.concept === 'MemberExpression') {
-        const callLogic = node.getAncestor('CallLogic');
-        const originLogic = callLogic?.getCallNode();
-        if (originLogic?.params.find((item) => item.name === propName)) {
-            return 'param';
-        }
-    }
-    if (view) {
-        // 前端逻辑调用
-        const { params } = view;
-        if (params.find((item) => item.name === propName)) {
-            return 'param';
-        }
-    }
-    if (logic) {
-        const { params, returns } = logic;
-        if (logic instanceof __1.AuthLogicForCallInterface) {
-            const { authParams } = logic;
-            if (authParams.find((item) => item.name === completionProperty.name))
-                return 'api-auth-params';
-            if (params.find((item) => item.name === completionProperty.name))
-                return 'api-auth-params';
-        }
-        else if (logic instanceof __1.AuthLogic) {
-            if (params.find((item) => item.name === completionProperty.name))
-                return 'api-auth-params';
-        }
-        else {
-            if (params.find((item) => item.name === completionProperty.name))
-                return 'param';
-        }
-        if (params.find((item) => item.name === propName)) {
-            return 'param';
-        }
-        else if (returns.find((item) => item.name === propName)) {
-            return 'return';
-        }
-        else {
-            return 'variable';
-        }
-    }
-    const bindAttr = node.getAncestor('BindAttribute');
-    if (bindAttr) {
-        const interfaceInstance = bindAttr.getAncestor('Interface');
-        if (interfaceInstance?.params.find((item) => item.name === propName)) {
-            return 'param';
-        }
-    }
-    return 'variable';
-}
-/**
- * 把要返回去的数据做一下排序
- * @param result 要返回数据
- * @param node 当前内容的上下级
- * @returns 返回排序后的数组
- * 因为ts会按照 a-z的顺序进行排序
- * 但是影响用户体验，需要先按照页面排序，其次按照logic进行排序
- * 流程的韬哥自己解决了，所以先解决这两部分
- */
-function sortFirstVariableData(result, node) {
-    const newResult = [];
-    const logic = node.logic;
-    const view = node.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 !== -1) {
-                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 !== -1) {
-                newResult.push(result[findIndex]);
-                result.splice(findIndex, 1);
-            }
-        });
-    }
-    newResult.push(...result);
-    return newResult;
-}
-function formatBackendVariables(variables) {
-    const result = variables.map((itemNode) => {
-        const namespace = itemNode.getNamespace();
-        const newItem = {
-            name: itemNode.name,
-            value: itemNode.name,
-            expression: new __1.Identifier({
-                name: itemNode.name,
-                namespace,
-            }),
-        };
-        const noChildType = isNoChildType(itemNode.typeAnnotation.typeKey);
-        if (!noChildType) {
-            nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
-        }
-        const completionProperty = new __1.CompletionProperty(newItem);
-        completionProperty.icon = 'backendVariable';
-        return completionProperty;
-    });
-    return result;
-}
-exports.formatBackendVariables = formatBackendVariables;
-function formatFrontEndVariables(frontEndVariables) {
-    const result = frontEndVariables.map((itemNode) => {
-        const namespace = itemNode.getNamespace();
-        const newItem = {
-            name: itemNode.name,
-            value: itemNode.name,
-            expression: new __1.Identifier({
-                name: itemNode.name,
-                namespace,
-            }),
-        };
-        const noChildType = isNoChildType(itemNode.typeAnnotation.typeKey);
-        if (!noChildType) {
-            nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
-        }
-        const completionProperty = new __1.CompletionProperty(newItem);
-        completionProperty.icon = 'frontendVariable';
-        return completionProperty;
-    });
-    return result;
-}
-exports.formatFrontEndVariables = formatFrontEndVariables;
-function formatConfigProperties(configProperties, isView) {
-    const result = configProperties.reduce((pre, item) => {
-        const { isPrivate = false } = item;
-        if (!isPrivate || !isView) {
-            const namespace = item.getNamespace();
-            const newItem = {
-                name: item.name,
-                value: item.name,
-                expression: new __1.Identifier({
-                    name: item.name,
-                    namespace,
-                }),
-                icon: 'configProperty',
-                calleewholeKey: item.calleewholeKey,
-            };
-            pre.push(newItem);
-        }
-        return pre;
-    }, []);
-    // const result = configProperties.map((item) => {
-    //     const namespace = item.getNamespace();
-    //     const newItem: any = {
-    //         name: item.name,
-    //         value: item.name,
-    //         expression: new Identifier({
-    //             name: item.name,
-    //             namespace,
-    //         }),
-    //         icon: 'configProperty',
-    //         calleewholeKey: item.calleewholeKey,
-    //     };
-    //     return newItem;
-    // });
-    return result;
-}
-exports.formatConfigProperties = formatConfigProperties;
-//# sourceMappingURL=formatTsUtils.js.map