@lcap/nasl 3.4.0-beta.3 → 3.4.0-beta.4

package/out/server/formatTsUtils.js

@@ -1,852 +1,852 @@
-"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;
-            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;
-                    // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
-                    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;
-    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;
-        // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
-        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) {
-            // 数据查询没有输出参数，特殊处理
-            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);
-                }
-            }
-            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;
+"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;
+            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;
+                    // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+                    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;
+    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;
+        // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+        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) {
+            // 数据查询没有输出参数，特殊处理
+            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);
+                }
+            }
+            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