@lcap/nasl 2.18.0-beta.3 → 2.18.0

package/src/server/dist/formatTsUtils.js

@@ -0,0 +1,683 @@
+"use strict";
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.formatFrontEndVariables = exports.formatVariableData = exports.nextFindTypeChild = exports.isNoChildType = exports.getPlatformType = exports.displayString2TypeAnnotation = exports.type2TypeAnnotation = void 0;
+var __1 = require("..");
+var 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) {
+    var str = '';
+    displayParts.forEach(function (item) {
+        str += item.text;
+    });
+    return str;
+}
+/**
+ * 解析 Completion 和 QuickInfo 的 displayString
+ * 生成 TypeAnnotation
+ * @param displayString
+ * @returns TypeAnnotation
+ */
+function type2TypeAnnotation(oldType) {
+    if (!oldType)
+        return null;
+    var type = oldType;
+    if (Array.isArray(oldType)) {
+        type = oldType[0];
+    }
+    var typeAnnotation;
+    try {
+        var _a = type, typeName = _a.typeName, typeNamespace = _a.typeNamespace, typeArguments = _a.typeArguments, typeKind = _a.typeKind, properties = _a.properties;
+        if (typeKind === 'anonymousStructure' && Array.isArray(properties) && properties.length) {
+            // 自定义类型
+            var newProperties_1 = [];
+            properties.forEach(function (item) {
+                var _a;
+                if (!((_a = item === null || item === void 0 ? void 0 : item.name) === null || _a === void 0 ? void 0 : _a.startsWith('__'))) {
+                    var itemType = type2TypeAnnotation(item.typeInfo);
+                    var structureProperty = __1.StructureProperty.from({ name: item.name, typeAnnotation: itemType }, typeAnnotation, 'properties');
+                    newProperties_1.push(structureProperty);
+                }
+            });
+            typeAnnotation = __1.TypeAnnotation.createTypeAnonymousStructure(newProperties_1);
+        }
+        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(function (item) {
+                var typeItem = type2TypeAnnotation(item);
+                if (typeItem) {
+                    typeAnnotation.typeArgumentsPush(typeItem);
+                }
+            });
+        }
+        else if (typeNamespace && typeNamespace.startsWith('nasl.core')) {
+            typeAnnotation = __1.TypeAnnotation.createPrimitive(typeName);
+        }
+        else if (typeNamespace && typeNamespace.startsWith('nasl.collection')) {
+            // nasl的泛型类型
+            typeAnnotation = __1.TypeAnnotation.createGeneric(typeName, {
+                typeNamespace: typeNamespace
+            });
+        }
+        else if (typeNamespace && typeNamespace.startsWith('nasl.')) {
+            // nasl的引用类型
+            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
+                typeNamespace: typeNamespace
+            });
+        }
+        else {
+            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
+                typeNamespace: typeNamespace
+            });
+        }
+        // 如果有泛型处理泛型
+        if (Array.isArray(typeArguments)) {
+            typeAnnotation.typeArguments = [];
+            typeArguments.forEach(function (item) {
+                var typeItem = type2TypeAnnotation(item);
+                if (typeItem) {
+                    typeAnnotation.typeArgumentsPush(typeItem);
+                }
+            });
+        }
+    }
+    catch (err) {
+        console.log(err, type);
+    }
+    return typeAnnotation;
+}
+exports.type2TypeAnnotation = type2TypeAnnotation;
+/**
+ * 解析 Completion 和 QuickInfo 的 displayString
+ * 生成 TypeAnnotation
+ * @param displayString
+ * @returns TypeAnnotation
+ */
+function displayString2TypeAnnotation(typeStr, parentPrefix) {
+    var type = '';
+    if (typeStr === null || typeStr === void 0 ? void 0 : typeStr.includes(': ')) {
+        var lastIndexOf = typeStr.lastIndexOf(': ');
+        type = typeStr.substring(lastIndexOf + 2, typeStr.length);
+    }
+    else {
+        type = typeStr;
+    }
+    type = type.replaceAll(' ', '');
+    if (type === 'Promise<void>')
+        return null;
+    // 把后面结尾里带()的比如
+    // 'function nasl.core.add(left: nasl.core.Integer, right: nasl.core.Integer): nasl.core.Integer (+12 overloads)'
+    if (type.includes('(') && type.includes(')')) {
+        type = type.replace(/\([^\)]*\)/g, '');
+    }
+    var 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) {
+    // 取出匹配的内容
+    var childType = type.substring(0, type.indexOf('<'));
+    var typeAnnotation = createType2Annotation(childType);
+    // 如果还有匹配到的多层泛型;
+    // 取出匹配到的内容
+    var types = /\<([^()]+)\>/g.exec(type);
+    var newtext = types[1];
+    // 把匹配的值，的内容在，检索一遍，看是不是泛型套泛型
+    var newTypes = /\<([^()]+)\>/g.exec(newtext);
+    // 如果是的话就去递归
+    if (newTypes) {
+        var argTypeAnnotation = createGenericTypeAnnotation(newtext, parentPrefix);
+        typeAnnotation.typeArguments = [argTypeAnnotation];
+    }
+    else {
+        var argTypeAnnotation = createType2Annotation(newtext, parentPrefix);
+        // 如果不是就创造内部的真正类型
+        if (newtext.includes(',')) {
+            typeAnnotation.typeArguments = newtext.split(',').map(function (item) { return createType2Annotation(item); });
+        }
+        else {
+            typeAnnotation.typeArguments = [argTypeAnnotation];
+        }
+    }
+    return typeAnnotation;
+}
+function createType2Annotation(type, parentPrefix) {
+    var typeAnnotation;
+    // 没有泛型类型的
+    var types = type.split('.');
+    // 长度等于1就说明是
+    if (types.length === 1) {
+        typeAnnotation = __1.TypeAnnotation.createPrimitive(types[0]);
+    }
+    else {
+        var typeName = types.pop();
+        var 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: typeNamespace
+            });
+        }
+        else if (type.startsWith('nasl.process')) {
+            // nasl的引用类型
+            typeAnnotation = __1.TypeAnnotation.createReference(typeName, {
+                typeNamespace: typeNamespace
+            });
+        }
+        else if (type.startsWith('nasl.collection')) {
+            // nasl的泛型类型
+            typeAnnotation = __1.TypeAnnotation.createGeneric(typeName, {
+                typeNamespace: 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: typeNamespace
+            });
+        }
+    }
+    return typeAnnotation;
+}
+function getPlatformType(type) {
+    var tsType = '';
+    if (type === null || type === void 0 ? void 0 : type.includes(': ')) {
+        var lastIndexOf = type.lastIndexOf(': ');
+        tsType = type.substring(lastIndexOf + 2, type.length);
+    }
+    else {
+        tsType = type;
+    }
+    tsType = tsType.replaceAll(' ', '');
+    var namespacePrefix = ['app', 'extensions', 'apis', 'components', 'nasl'];
+    if (tsType === 'String') {
+        return 'nasl.core.String';
+    }
+    else if (tsType === 'Boolean') {
+        return 'nasl.core.Boolean';
+    }
+    var strTypes = tsType.split('.');
+    if (strTypes.length) {
+        var first = strTypes[0];
+        // 如果不是这几个前缀就加一个namespace
+        if (!namespacePrefix.includes(first)) {
+            return 'app.' + tsType;
+        }
+    }
+    return tsType;
+}
+exports.getPlatformType = getPlatformType;
+function isNoChildType(type) {
+    return (type === null || type === void 0 ? void 0 : type.startsWith('nasl.core')) || (type === null || type === void 0 ? void 0 : type.startsWith('app.enums'));
+}
+exports.isNoChildType = isNoChildType;
+function findNode(typeKey, node) {
+    var _a, _b;
+    var newType;
+    if (typeKey.startsWith('nasl.') && typeKey.includes('<')) {
+        var findGenericsIndex = typeKey.indexOf('<');
+        typeKey = typeKey.substring(0, findGenericsIndex);
+        var typeIndex = typeKey.lastIndexOf('.');
+        newType = utils_1.getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
+    }
+    else if (typeKey.startsWith('nasl.')) {
+        var typeIndex = typeKey.lastIndexOf('.');
+        newType = utils_1.getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
+    }
+    else {
+        newType = (_b = (_a = node) === null || _a === void 0 ? void 0 : _a.app) === null || _b === void 0 ? void 0 : _b.findNodeByCompleteName(typeKey);
+    }
+    return newType;
+}
+/**
+ * 获取下一级的节点进行递归
+ * @param typeKey 当前节点的类型，主要为了取出内部的 T中的实际类型
+ * @param item 当前节点的内容
+ * @param parent 父级节点的内容
+ * @param node 获取变量框的位置
+ */
+function nextFindTypeChild(typeKey, item, parent, node) {
+    var _a;
+    // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
+    var nodeMap = parent ? parent.nodeMap : new Map();
+    item.nodeMap = nodeMap;
+    var newType = findNode(typeKey, node);
+    if (((_a = newType) === null || _a === void 0 ? void 0 : _a.properties) && newType.properties.length) {
+        // 处理泛型的内容要取到值
+        var StructureJson = newType.toJSON();
+        var newStructure = new __1.Structure(StructureJson);
+        newStructure.properties.forEach(function (item) {
+            var _a;
+            var itemType = (_a = item === null || item === void 0 ? void 0 : item.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeKey;
+            if (itemType === 'T' && /\<([^()]+)\>/g.exec(typeKey)) {
+                var newTypes = /\<([^()]+)\>/g.exec(typeKey);
+                // 找到当前原来的类型
+                var contentType = getPlatformType(newTypes[1]);
+                var typeNamespace = contentType.substring(0, contentType.lastIndexOf('.'));
+                var typeName = contentType.substring(contentType.lastIndexOf('.') + 1, contentType.length);
+                item.typeAnnotation = new __1.TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace: typeNamespace,
+                    typeName: typeName
+                });
+            }
+        });
+        var index = nodeMap.get(newType) || 0;
+        if (index) {
+            nodeMap.set(newType, index + 1);
+        }
+        else {
+            nodeMap.set(newType, 1);
+        }
+        // 最多保留3层
+        if (index < 3) {
+            item.children = formatVariableData(newStructure.properties, node, item);
+        }
+    }
+}
+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) {
+    var newType = type.replaceAll(' ', '').replaceAll('\n', '').replace(/__name:"AStructure_\w{8}";/g, '');
+    var parentItem = parent;
+    // 如果没有父节点就是Identifier
+    // value需要拼接生成
+    var identifier = new __1.Identifier({ name: parentItem.text });
+    parentItem.expression = identifier;
+    parentItem.value = parentItem.text;
+    parentItem.name = parentItem.text;
+    // 处理泛型的内容要取到值
+    var newNode = findNode(newType, node);
+    var StructureJson = newNode.toJSON();
+    var newStructure = new __1.Structure(StructureJson);
+    var children = newStructure.properties;
+    if (children && children.length) {
+        var newChildren = children.map(function (structureProperty) {
+            var structureItem = structureProperty;
+            // 如果没有父节点就是Identifier
+            structureItem.value = parentItem.value + "." + structureItem.name;
+            var memberExpression = new __1.MemberExpression({
+                object: parentItem.expression,
+                property: new __1.Identifier({ name: structureItem.name })
+            });
+            structureItem.expression = memberExpression;
+            // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+            structureItem.concept = 'CompletionProperty';
+            var completionProperty = new __1.CompletionProperty(structureItem);
+            completionProperty.icon = 'refProperty';
+            if (structureItem.name === 'item') {
+                var context = /\{([^()]+)\}/.exec(newType);
+                newType = context[1];
+                var res_1 = [];
+                newType.split(';').forEach(function (item) {
+                    if (item) {
+                        var itemArr = item.split(':');
+                        var name = itemArr[0];
+                        var typeKey = itemArr[1];
+                        if (typeKey && typeKey.startsWith('dataSources')) {
+                            typeKey = 'app.' + typeKey;
+                        }
+                        res_1.push({
+                            name: name,
+                            typeKey: typeKey
+                        });
+                    }
+                });
+                res_1 = res_1.map(function (item) {
+                    var newItem = item;
+                    // 如果没有父节点就是Identifier
+                    newItem.value = structureItem.value + "." + newItem.name;
+                    var memberExpression = new __1.MemberExpression({
+                        object: structureItem.expression,
+                        property: new __1.Identifier({ name: newItem.name })
+                    });
+                    newItem.expression = memberExpression;
+                    // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+                    newItem.concept = 'CompletionProperty';
+                    // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+                    if (item.typeKey && !isNoChildType(item.typeKey)) {
+                        newItem.children = nextObjectTypeChild(item.typeKey, newItem, parentItem, node);
+                    }
+                    var completionProperty = new __1.CompletionProperty(newItem);
+                    completionProperty.icon = 'refProperty';
+                    return completionProperty;
+                });
+                completionProperty.children = res_1;
+                return completionProperty;
+            }
+            else {
+                return completionProperty;
+            }
+        });
+        parentItem.children = newChildren;
+    }
+    var 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.Integer;
+}`
+ */
+function getAStructureObjectStringType(type, parent, node) {
+    var newType = type.replaceAll(' ', '').replaceAll('\n', '').replace(/__name:"AStructure_\w{8}";/g, '');
+    newType = newType.substring(1, newType.length - 1);
+    if (!parent.keyMap) {
+        parent.keyMap = new Map();
+    }
+    if (/\{([^()]+)\}/.exec(newType)) {
+        newType = newType.replace(/\{([^()]+)\}/, '');
+    }
+    var res = [];
+    newType.split(';').forEach(function (item) {
+        if (item) {
+            var itemArr = item.split(':');
+            var name = itemArr[0];
+            var typeKey = itemArr[1];
+            res.push({
+                name: name,
+                typeKey: typeKey
+            });
+        }
+    });
+    var parentItem = parent;
+    // 如果没有父节点就是Identifier
+    // value需要拼接生成
+    var identifier = new __1.Identifier({ name: parentItem.text });
+    parentItem.expression = identifier;
+    parentItem.value = parentItem.text;
+    parentItem.name = parentItem.text;
+    // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+    parentItem.concept = 'CompletionProperty';
+    res = res.map(function (item) {
+        var newItem = item;
+        // 如果没有父节点就是Identifier
+        newItem.value = parentItem.value + "." + newItem.name;
+        var memberExpression = new __1.MemberExpression({
+            object: parentItem.expression,
+            property: new __1.Identifier({ name: newItem.name })
+        });
+        newItem.expression = memberExpression;
+        // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+        newItem.concept = 'CompletionProperty';
+        // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+        if (item.typeKey && !isNoChildType(item.typeKey)) {
+            newItem.children = nextObjectTypeChild(getPlatformType(item.typeKey), newItem, parentItem, node);
+        }
+        var completionProperty = new __1.CompletionProperty(newItem);
+        completionProperty.icon = 'refProperty';
+        return completionProperty;
+    });
+    parentItem.children = res;
+    var completionProperty = new __1.CompletionProperty(parentItem);
+    // 变量 param return 在这里添加图标
+    completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
+    return completionProperty;
+}
+function nextObjectTypeChild(typeKey, item, parent, node) {
+    var _a;
+    // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
+    var nodeMap = parent.nodeMap || new Map();
+    item.nodeMap = nodeMap; // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
+    var keyMap = parent.keyMap;
+    item.keyMap = keyMap;
+    var newType = findNode(typeKey, node);
+    if (((_a = newType) === null || _a === void 0 ? void 0 : _a.properties) && newType.properties.length) {
+        // 处理泛型的内容要取到值
+        var StructureJson = newType.toJSON();
+        var newStructure = new __1.Structure(StructureJson);
+        newStructure.properties.forEach(function (item) {
+            var _a;
+            var itemType = (_a = item === null || item === void 0 ? void 0 : item.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeKey;
+            if (itemType === 'T' && /\<([^()]+)\>/g.exec(typeKey)) {
+                var newTypes = /\<([^()]+)\>/g.exec(typeKey);
+                // 找到当前原来的类型
+                var contentType = getPlatformType(newTypes[1]);
+                var typeNamespace = contentType.substring(0, contentType.lastIndexOf('.'));
+                var typeName = contentType.substring(contentType.lastIndexOf('.') + 1, contentType.length);
+                item.typeAnnotation = new __1.TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace: typeNamespace,
+                    typeName: typeName
+                });
+            }
+        });
+        var index = nodeMap.get(newType) || 0;
+        if (index) {
+            nodeMap.set(newType, index + 1);
+        }
+        else {
+            nodeMap.set(newType, 1);
+        }
+        // 最多保留3层
+        if (index < 3) {
+            return formatVariableData(newStructure.properties, node, item);
+        }
+    }
+}
+// 格式化变量数据
+function formatVariableData(data, node, parent) {
+    if (Array.isArray(data)) {
+        var result = data.map(function (item) {
+            var _a;
+            item.children = [];
+            // 当前的类型如 app.entitys.entity1 nasl.core.String
+            var typeKey;
+            if (item.completionDetail) {
+                if (item.completionDetail.nodeType) {
+                    var typeAnnotation = type2TypeAnnotation(item.completionDetail.nodeType);
+                    typeKey = typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.typeKey;
+                }
+                else {
+                    // 当前节点的完整类型，主要是在有T的内容使用 nasl.list<Enum1> 内部匹配内容给里面子集的T赋值类型
+                    var currentType = formatTs2TypeString(item.completionDetail.displayParts);
+                    if (currentType) {
+                        if (currentType === null || currentType === void 0 ? void 0 : currentType.includes(': ')) {
+                            var indexOf = currentType.indexOf(': ');
+                            var newCurrentType = currentType.substring(indexOf + 2, currentType.length);
+                            // 如果是对象形式的就单独处理
+                            if (newCurrentType.startsWith('{') && newCurrentType.endsWith('}')) {
+                                var completionProperty_1 = getAStructureObjectStringType(newCurrentType, item, node);
+                                return completionProperty_1;
+                            }
+                            else if (newCurrentType.startsWith('nasl.ui.Current<{')) {
+                                var completionProperty_2 = getAStructureScopeType(newCurrentType, item, node);
+                                return completionProperty_2;
+                            }
+                            else if (newCurrentType.startsWith('nasl.collection.List<{') && newCurrentType.endsWith('}>')) {
+                                currentType = 'nasl.collection.List<nasl.core.Any>';
+                            }
+                        }
+                    }
+                    typeKey = getPlatformType(currentType);
+                }
+            }
+            else if (item instanceof __1.StructureProperty) {
+                typeKey = (_a = item === null || item === void 0 ? void 0 : item.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeKey;
+            }
+            // 如果没有父节点就是Identifier
+            if (!parent) {
+                // value需要拼接生成
+                item.value = parent ? parent.value + "." + item.text : item.text;
+                item.name = item.text;
+                var identifier = new __1.Identifier({ name: item.name });
+                item.expression = identifier;
+            }
+            else {
+                item.value = parent.value + "." + item.name;
+                var memberExpression = new __1.MemberExpression({
+                    object: parent.expression,
+                    property: new __1.Identifier({ name: item.name })
+                });
+                item.expression = memberExpression;
+            }
+            // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+            if (typeKey && !isNoChildType(typeKey)) {
+                nextFindTypeChild(typeKey, item, parent, node);
+            }
+            // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+            item.concept = 'CompletionProperty';
+            var completionProperty = new __1.CompletionProperty(item);
+            if (!parent) {
+                // 变量 param return 在这里添加图标
+                completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
+            }
+            else {
+                completionProperty.icon = 'refProperty';
+            }
+            return completionProperty;
+        });
+        /**
+         * 排序result
+         * 如果没有父级就是第一集就排序一下当前result，用户体验优化
+        */
+        if (!parent) {
+            result = sortFirstVariableData(result, node);
+        }
+        return result;
+    }
+}
+exports.formatVariableData = formatVariableData;
+// 从logic获取节点的icon
+function getNodeiconFromLogic(completionProperty, node) {
+    var logic = node.logic;
+    var view = node.view;
+    if (view) {
+        var params = view.params;
+        if (params.find(function (item) { return item.name === completionProperty.name; }))
+            return 'param';
+    }
+    if (logic) {
+        var params = logic.params, returns = logic.returns;
+        if (params.find(function (item) { return item.name === completionProperty.name; }))
+            return 'param';
+        if (returns.find(function (item) { return item.name === completionProperty.name; }))
+            return 'return';
+        // if (variables.find((item) => item.name === completionProperty.name))
+        // return 'variable';
+        // 其余的全部按variable展示
+        return 'variable';
+    }
+    return 'variable';
+}
+/**
+ * 把要返回去的数据做一下排序
+ * @param result 要返回数据
+ * @param node 当前内容的上下级
+ * @returns 返回排序后的数组
+ * 因为ts会按照 a-z的顺序进行排序
+ * 但是影响用户体验，需要先按照页面排序，其次按照logic进行排序
+ * 流程的韬哥自己解决了，所以先解决这两部分
+ */
+function sortFirstVariableData(result, node) {
+    var newResult = [];
+    var logic = node.logic;
+    var view = node.view;
+    if (view) {
+        var params = view.params, variables = view.variables;
+        var list = __spreadArrays(params, variables);
+        list.forEach(function (item) {
+            var findIndex = result.findIndex(function (findItem) { return findItem.name === item.name; });
+            if (findIndex !== -1) {
+                newResult.push(result[findIndex]);
+                result.splice(findIndex, 1);
+            }
+        });
+    }
+    if (logic) {
+        var params = logic.params, returns = logic.returns, variables = logic.variables;
+        var list = __spreadArrays(params, returns, variables);
+        list.forEach(function (item) {
+            var findIndex = result.findIndex(function (findItem) { return findItem.name === item.name; });
+            if (findIndex !== -1) {
+                newResult.push(result[findIndex]);
+                result.splice(findIndex, 1);
+            }
+        });
+    }
+    newResult.push.apply(newResult, result);
+    return newResult;
+}
+function formatFrontEndVariables(frontEndVariables) {
+    var result = frontEndVariables.map(function (item) {
+        var namespace = item.getNamespace();
+        var newItem = {
+            name: item.name,
+            value: item.name,
+            expression: new __1.Identifier({
+                name: item.name,
+                namespace: namespace
+            })
+        };
+        var noChildType = isNoChildType(item.typeAnnotation.typeKey);
+        if (!noChildType) {
+            nextFindTypeChild(item.typeAnnotation.typeKey, newItem, null, item);
+        }
+        var completionProperty = new __1.CompletionProperty(newItem);
+        completionProperty.icon = 'frontendVariable';
+        return completionProperty;
+    });
+    return result;
+}
+exports.formatFrontEndVariables = formatFrontEndVariables;