@lcap/nasl 3.6.0-alpha.7 → 3.6.0-alpha.8

package/out/server/formatTsUtils.js

@@ -0,0 +1,854 @@
+"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");
+const utils_2 = require("../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
+ */
+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) {
+                for (const item of properties) {
+                    if (!item?.name?.startsWith('__')) {
+                        // 如果没有获取到类型，就默认塞一个string
+                        const itemType = (yield* 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 = [];
+            for (const item of typeArguments) {
+                const typeItem = yield* 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 = [];
+            for (const item of typeArguments) {
+                const typeItem = yield* type2TypeAnnotation(item);
+                if (typeItem) {
+                    typeAnnotation.typeArgumentsPush(typeItem);
+                }
+            }
+        }
+        else {
+            // 其余的引用类型
+            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
+                typeNamespace,
+            });
+        }
+    }
+    catch (err) {
+        console.log(err, type);
+    }
+    yield;
+    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 = (0, utils_2.runGeneratorSync)(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 likeComponent = node.getAncestor('View') || node.getAncestor('BusinessComponent');
+    const logic = node.logic || node.getAncestor('BusinessLogic') || 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 (likeComponent) {
+        const params = likeComponent.params;
+        // 前端逻辑调用
+        if (params.find((item) => item.name === propName)) {
+            return 'param';
+        }
+    }
+    if (logic) {
+        const { returns } = logic;
+        const params = logic.params;
+        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