@lcap/nasl 3.2.0-beta.3 → 3.3.0-alpha

package/src/server/formatTsUtils.ts

@@ -1,34 +1,34 @@
 import {
-    BaseNode,
-    Identifier,
-    TypeAnnotation,
-    StructureProperty,
-    Structure,
-    EntityProperty,
-    Param,
-    MemberExpression,
-    CompletionProperty,
-    Variable,
-    Logic,
-    ConfigProperty,
-    App,
-    SynatxNode,
-    BindAttribute,
-    Interface,
-    CallLogic,
-    BackendVariable,
-    AuthLogic,
-    AuthLogicForCallInterface,
+  BaseNode,
+  Identifier,
+  TypeAnnotation,
+  StructureProperty,
+  Structure,
+  EntityProperty,
+  Param,
+  MemberExpression,
+  CompletionProperty,
+  Variable,
+  Logic,
+  ConfigProperty,
+  App,
+  SynatxNode,
+  BindAttribute,
+  Interface,
+  CallLogic,
+  BackendVariable,
+  AuthLogic,
+  AuthLogicForCallInterface,
 } from '..';
 import { getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 interface variableItem {
-    text: string;
-    completionDetail: any;
-    children?: variableItem[] | any;
-    name?: string;
-    value?: string;
-    expression: MemberExpression | Identifier;
+  text: string;
+  completionDetail: any;
+  children?: variableItem[] | any;
+  name?: string;
+  value?: string;
+  expression: MemberExpression | Identifier;
 }
 /**
  * 把ts返回的详细信息截取成一个类型字符串
@@ -44,16 +44,16 @@ interface variableItem {
  * @returns type roles.DEV_AdminRole
  */
 function formatTs2TypeString(displayParts: Array<{ text: string; kind: string }>) {
-    let str = '';
-    displayParts?.forEach((item) => {
-        str += item.text;
-    });
-    return str;
+  let str = '';
+  displayParts?.forEach((item) => {
+    str += item.text;
+  });
+  return str;
 }
 
 function isValidName(str: string) {
-    const regex = /^[a-zA-Z][a-zA-Z0-9_]*$/;
-    return regex.test(str);
+  const regex = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+  return regex.test(str);
 }
 /**
  * 解析 Completion 和 QuickInfo 的 displayString
@@ -62,67 +62,66 @@ function isValidName(str: string) {
  * @returns TypeAnnotation
  */
 export function type2TypeAnnotation(oldType: Array<any> | {}): TypeAnnotation {
-    if (!oldType)
-        return null;
-    let type = oldType;
-    if (Array.isArray(oldType)) {
-        type = oldType[0];
-    }
-    let typeAnnotation: TypeAnnotation;
-    try {
-        const { typeName, typeNamespace, typeArguments, typeKind, properties } = type as any;
-        if (typeKind === 'anonymousStructure') {
-            // 自定义类型
-            const newProperties: StructureProperty[] = [];
-            if (Array.isArray(properties) && properties.length) {
-                properties.forEach((item) => {
-                    if (!item?.name?.startsWith('__')) {
-                        // 如果没有获取到类型，就默认塞一个string
-                        const itemType = type2TypeAnnotation(item.typeInfo) || TypeAnnotation.createPrimitive('String');
-                        const structureProperty = StructureProperty.from({ name: item.name, typeAnnotation: itemType }, typeAnnotation, 'properties');
-                        newProperties.push(structureProperty);
-                    }
-                });
-            }
-            typeAnnotation = TypeAnnotation.createTypeAnonymousStructure(newProperties);
-        } else if (!typeName || typeName === 'Promise' || typeName === 'nasl' || typeName === '___IDENTIFIER__') {
-            return null;
-        } else if (typeName === 'String' || typeName === 'Boolean') {
-            typeAnnotation = TypeAnnotation.createPrimitive(typeName);
-        } else if (typeName === 'Union') {
-            typeAnnotation = TypeAnnotation.createPrimitive('Union');
-            typeAnnotation.typeArguments = [];
-            typeArguments.forEach((item: any) => {
-                const typeItem = type2TypeAnnotation(item);
-                if (typeItem) {
-                    typeAnnotation.typeArgumentsPush(typeItem);
-                }
-            });
-        } else if (typeNamespace && typeNamespace.startsWith('nasl.core')) {
-            typeAnnotation = TypeAnnotation.createPrimitive(typeName);
-        } else if (typeNamespace && typeArguments?.length) {
-            // 泛型类型
-            typeAnnotation = TypeAnnotation.createGeneric(typeName, {
-                typeNamespace,
-            });
-            // 如果有泛型处理泛型
-            typeAnnotation.typeArguments = [];
-            typeArguments.forEach((item: any) => {
-                const typeItem = type2TypeAnnotation(item);
-                if (typeItem) {
-                    typeAnnotation.typeArgumentsPush(typeItem);
-                }
-            });
-        } else {
-            // 其余的引用类型
-            typeAnnotation = TypeAnnotation.createReference(typeName, {
-                typeNamespace,
-            });
+  if (!oldType) return null;
+  let type = oldType;
+  if (Array.isArray(oldType)) {
+    type = oldType[0];
+  }
+  let typeAnnotation: TypeAnnotation;
+  try {
+    const { typeName, typeNamespace, typeArguments, typeKind, properties } = type as any;
+    if (typeKind === 'anonymousStructure') {
+      // 自定义类型
+      const newProperties: StructureProperty[] = [];
+      if (Array.isArray(properties) && properties.length) {
+        properties.forEach((item) => {
+          if (!item?.name?.startsWith('__')) {
+            // 如果没有获取到类型，就默认塞一个string
+            const itemType = type2TypeAnnotation(item.typeInfo) || TypeAnnotation.createPrimitive('String');
+            const structureProperty = StructureProperty.from({ name: item.name, typeAnnotation: itemType }, typeAnnotation, 'properties');
+            newProperties.push(structureProperty);
+          }
+        });
+      }
+      typeAnnotation = TypeAnnotation.createTypeAnonymousStructure(newProperties);
+    } else if (!typeName || typeName === 'Promise' || typeName === 'nasl' || typeName === '___IDENTIFIER__') {
+      return null;
+    } else if (typeName === 'String' || typeName === 'Boolean') {
+      typeAnnotation = TypeAnnotation.createPrimitive(typeName);
+    } else if (typeName === 'Union') {
+      typeAnnotation = TypeAnnotation.createPrimitive('Union');
+      typeAnnotation.typeArguments = [];
+      typeArguments.forEach((item: any) => {
+        const typeItem = type2TypeAnnotation(item);
+        if (typeItem) {
+          typeAnnotation.typeArgumentsPush(typeItem);
+        }
+      });
+    } else if (typeNamespace && typeNamespace.startsWith('nasl.core')) {
+      typeAnnotation = TypeAnnotation.createPrimitive(typeName);
+    } else if (typeNamespace && typeArguments?.length) {
+      // 泛型类型
+      typeAnnotation = TypeAnnotation.createGeneric(typeName, {
+        typeNamespace,
+      });
+      // 如果有泛型处理泛型
+      typeAnnotation.typeArguments = [];
+      typeArguments.forEach((item: any) => {
+        const typeItem = type2TypeAnnotation(item);
+        if (typeItem) {
+          typeAnnotation.typeArgumentsPush(typeItem);
         }
-    } catch (err) {
-        console.log(err, type);
+      });
+    } else {
+      // 其余的引用类型
+      typeAnnotation = TypeAnnotation.createReference(typeName, {
+        typeNamespace,
+      });
     }
-    return typeAnnotation;
+  } catch (err) {
+    console.log(err, type);
+  }
+  return typeAnnotation;
 }
 
 /**
@@ -132,148 +131,146 @@ export function type2TypeAnnotation(oldType: Array<any> | {}): TypeAnnotation {
  * @returns TypeAnnotation
  */
 export function displayString2TypeAnnotation(typeStr: string, parentPrefix?: string): TypeAnnotation {
-    let type = '';
-    if (typeStr?.includes(': ')) {
-        const lastIndexOf = typeStr.lastIndexOf(': ');
-        type = typeStr.substring(lastIndexOf + 2, typeStr.length);
+  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 {
-        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);
+      typeAnnotation = createType2Annotation(type, parentPrefix);
     }
-    return typeAnnotation as TypeAnnotation;
+  } catch (err) {
+    console.log(err);
+  }
+  return typeAnnotation as TypeAnnotation;
 }
 
 function createGenericTypeAnnotation(type: string, parentPrefix?: string) {
-    // 取出匹配的内容
-
-    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 as TypeAnnotation];
+  // 取出匹配的内容
+
+  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 as TypeAnnotation];
+  } else {
+    const argTypeAnnotation = createType2Annotation(newtext, parentPrefix);
+
+    // 如果不是就创造内部的真正类型
+    if (newtext.includes(',')) {
+      typeAnnotation.typeArguments = newtext.split(',').map((item) => createType2Annotation(item));
     } else {
-        const argTypeAnnotation = createType2Annotation(newtext, parentPrefix);
-
-        // 如果不是就创造内部的真正类型
-        if (newtext.includes(',')) {
-            typeAnnotation.typeArguments = newtext.split(',').map((item) => createType2Annotation(item));
-        } else {
-            typeAnnotation.typeArguments = [argTypeAnnotation];
-        }
+      typeAnnotation.typeArguments = [argTypeAnnotation];
     }
-    return typeAnnotation;
+  }
+  return typeAnnotation;
 }
 function createType2Annotation(type: string, parentPrefix?: string): TypeAnnotation {
-    let typeAnnotation;
-    // 没有泛型类型的
-    const types = type.split('.');
-    // 长度等于1就说明是
-    if (types.length === 1) {
-        typeAnnotation = TypeAnnotation.createPrimitive(types[0]);
+  let typeAnnotation;
+  // 没有泛型类型的
+  const types = type.split('.');
+  // 长度等于1就说明是
+  if (types.length === 1) {
+    typeAnnotation = TypeAnnotation.createPrimitive(types[0]);
+  } else {
+    const typeName = types.pop();
+    const typeNamespace = types.join('.');
+    if (type.startsWith('nasl.core')) {
+      typeAnnotation = TypeAnnotation.createPrimitive(typeName);
+    } else if (type.startsWith('nasl.ui')) {
+      typeAnnotation = TypeAnnotation.createReference(typeName, {
+        typeNamespace,
+      });
+    } else if (type.startsWith('nasl.process')) {
+      // nasl的引用类型
+      typeAnnotation = TypeAnnotation.createReference(typeName, {
+        typeNamespace,
+      });
+    } else if (type.startsWith('nasl.collection')) {
+      // nasl的泛型类型
+      typeAnnotation = TypeAnnotation.createGeneric(typeName, {
+        typeNamespace,
+      });
+    } else if (type.startsWith('dataSources.') || type.startsWith('structures.') || type.startsWith('enums.')) {
+      typeAnnotation = TypeAnnotation.createReference(typeName, {
+        typeNamespace: (parentPrefix || 'app.') + typeNamespace,
+      });
     } else {
-        const typeName = types.pop();
-        const typeNamespace = types.join('.');
-        if (type.startsWith('nasl.core')) {
-            typeAnnotation = TypeAnnotation.createPrimitive(typeName);
-        } else if (type.startsWith('nasl.ui')) {
-            typeAnnotation = TypeAnnotation.createReference(typeName, {
-                typeNamespace,
-            });
-        } else if (type.startsWith('nasl.process')) {
-            // nasl的引用类型
-            typeAnnotation = TypeAnnotation.createReference(typeName, {
-                typeNamespace,
-            });
-        } else if (type.startsWith('nasl.collection')) {
-            // nasl的泛型类型
-            typeAnnotation = TypeAnnotation.createGeneric(typeName, {
-                typeNamespace,
-            });
-        } else if (type.startsWith('dataSources.') || type.startsWith('structures.') || type.startsWith('enums.')) {
-            typeAnnotation = TypeAnnotation.createReference(typeName, {
-                typeNamespace: (parentPrefix || 'app.') + typeNamespace,
-            });
-        } else {
-            typeAnnotation = TypeAnnotation.createReference(typeName, {
-                typeNamespace,
-            });
-        }
+      typeAnnotation = TypeAnnotation.createReference(typeName, {
+        typeNamespace,
+      });
     }
-    return typeAnnotation;
+  }
+  return typeAnnotation;
 }
 export function getPlatformType(type: string): string {
-    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';
+  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';
+  }
+  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}`;
     }
-
-    const strTypes = tsType.split('.');
-    if (strTypes.length) {
-        const first = strTypes[0];
-        // 如果不是这几个前缀就加一个namespace
-        if (!namespacePrefix.includes(first)) {
-            return 'app.' + tsType;
-        }
-    }
-    return tsType;
+  }
+  return tsType;
 }
 export function isNoChildType(type: String) {
-    return (type?.startsWith('nasl.core') && !['String', 'Text', 'Email'].includes(type.split('.')[2])) || type?.startsWith('app.enums');
+  return (type?.startsWith('nasl.core') && !['String', 'Text', 'Email'].includes(type.split('.')[2])) || type?.startsWith('app.enums');
 }
 function findNode(typeKey: string, node: BaseNode) {
-    let newType: Structure | Logic;
-    if (typeKey.startsWith('nasl.') && typeKey.includes('<')) {
-        const findGenericsIndex = typeKey.indexOf('<');
-        typeKey = typeKey.substring(0, findGenericsIndex);
-        const typeIndex = typeKey.lastIndexOf('.');
-        newType = getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
-    } else if (typeKey.startsWith('nasl.')) {
-        const typeIndex = typeKey.lastIndexOf('.');
-        newType = getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
-    } else {
-        newType = (node as Identifier)?.app?.findNodeByCompleteName(typeKey);
-    }
-    return newType;
+  let newType: Structure | Logic;
+  if (typeKey.startsWith('nasl.') && typeKey.includes('<')) {
+    const findGenericsIndex = typeKey.indexOf('<');
+    typeKey = typeKey.substring(0, findGenericsIndex);
+    const typeIndex = typeKey.lastIndexOf('.');
+    newType = getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
+  } else if (typeKey.startsWith('nasl.')) {
+    const typeIndex = typeKey.lastIndexOf('.');
+    newType = getNaslNodeByNodeCallee(typeKey.substring(0, typeIndex), typeKey.substring(typeIndex + 1, typeKey.length));
+  } else {
+    newType = (node as Identifier)?.app?.findNodeByCompleteName(typeKey);
+  }
+  return newType;
 }
 
 /**
@@ -283,28 +280,28 @@ function findNode(typeKey: string, node: BaseNode) {
  * @param node 获取变量框的位置
  */
 export function nextFindTypeChild(typeKey: string, item: any, node: SynatxNode) {
-    const newType = findNode(typeKey, node);
-    if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
-        // 处理泛型的内容要取到值
-        const StructureJson = newType.toJSON();
-        const newStructure = new Structure(StructureJson);
-        newStructure.properties.forEach((item: StructureProperty | EntityProperty) => {
-            const itemType = item?.typeAnnotation?.typeKey;
-            if (itemType === 'T' && /<([^()]+)>/g.exec(typeKey)) {
-                const newTypes = /<([^()]+)>/g.exec(typeKey);
-                // 找到当前原来的类型
-                const contentType = getPlatformType(newTypes[1]);
-                const typeNamespace = contentType.substring(0, contentType.lastIndexOf('.'));
-                const typeName = contentType.substring(contentType.lastIndexOf('.') + 1, contentType.length);
-                item.typeAnnotation = new TypeAnnotation({
-                    typeKind: 'reference',
-                    typeNamespace,
-                    typeName,
-                });
-            }
+  const newType = findNode(typeKey, node);
+  if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
+    // 处理泛型的内容要取到值
+    const StructureJson = newType.toJSON();
+    const newStructure = new Structure(StructureJson);
+    newStructure.properties.forEach((item: StructureProperty | EntityProperty) => {
+      const itemType = item?.typeAnnotation?.typeKey;
+      if (itemType === 'T' && /<([^()]+)>/g.exec(typeKey)) {
+        const newTypes = /<([^()]+)>/g.exec(typeKey);
+        // 找到当前原来的类型
+        const contentType = getPlatformType(newTypes[1]);
+        const typeNamespace = contentType.substring(0, contentType.lastIndexOf('.'));
+        const typeName = contentType.substring(contentType.lastIndexOf('.') + 1, contentType.length);
+        item.typeAnnotation = new TypeAnnotation({
+          typeKind: 'reference',
+          typeNamespace,
+          typeName,
         });
-        item.children = formatVariableData(newStructure.properties, node, item);
-    }
+      }
+    });
+    item.children = formatVariableData(newStructure.properties, node, item);
+  }
 }
 
 /**
@@ -317,92 +314,94 @@ export function nextFindTypeChild(typeKey: string, item: any, node: SynatxNode)
 }>`
  */
 function getAStructureScopeType(type: string, parent: any, node: SynatxNode) {
-    let newType = type.replaceAll(' ', '').replaceAll('\n', '').replace(/__name:"AStructure_\w{8}";/g, '');
-
-    const parentItem: any = parent;
-    // 如果没有父节点就是Identifier
-    // value需要拼接生成
-    const identifier = new 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 Structure(StructureJson);
-    const children = newStructure.properties;
-    if (children && children.length) {
-        const newChildren = children.map((structureProperty) => {
-            const structureItem: any = structureProperty;
-            // 如果没有父节点就是Identifier
-            structureItem.value = `${parentItem.value}.${structureItem.name}`;
-            const memberExpression = new MemberExpression({
-                object: parentItem.expression,
-                property: new Identifier({ name: structureItem.name }),
-            });
-            structureItem.expression = memberExpression;
-            // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-            structureItem.concept = 'CompletionProperty';
-            const completionProperty = new CompletionProperty(structureItem);
-            completionProperty.icon = 'refProperty';
-
-            if (structureItem.name === 'item') {
-                const context = /\{([^()]+)\}/.exec(newType);
-                newType = context[1];
-                let res: any[] = [];
-                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: any = item;
-                    // 如果没有父节点就是Identifier
-                    newItem.value = `${structureItem.value}.${newItem.name}`;
-                    const memberExpression = new MemberExpression({
-                        object: structureItem.expression,
-                        property: new Identifier({ name: newItem.name }),
-                    });
-                    newItem.expression = memberExpression;
-                    // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-                    newItem.concept = 'CompletionProperty';
-                    // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
-                    if (item.typeKey && !isNoChildType(item.typeKey)) {
-                        newItem.children = nextObjectTypeChild(item.typeKey, newItem, node);
-                    }
-                    newItem.typeAnnotation = displayString2TypeAnnotation(newItem.typeKey);
-                    const completionProperty = new CompletionProperty(newItem);
-                    completionProperty.icon = 'refProperty';
-                    return completionProperty;
-                });
-                completionProperty.children = res;
-                return completionProperty;
-            } else {
-                return completionProperty;
+  let newType = type
+    .replaceAll(' ', '')
+    .replaceAll('\n', '')
+    .replace(/__name:"AStructure_\w{8}";/g, '');
+
+  const parentItem: any = parent;
+  // 如果没有父节点就是Identifier
+  // value需要拼接生成
+  const identifier = new 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 Structure(StructureJson);
+  const children = newStructure.properties;
+  if (children && children.length) {
+    const newChildren = children.map((structureProperty) => {
+      const structureItem: any = structureProperty;
+      // 如果没有父节点就是Identifier
+      structureItem.value = `${parentItem.value}.${structureItem.name}`;
+      const memberExpression = new MemberExpression({
+        object: parentItem.expression,
+        property: new Identifier({ name: structureItem.name }),
+      });
+      structureItem.expression = memberExpression;
+      // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+      structureItem.concept = 'CompletionProperty';
+      const completionProperty = new CompletionProperty(structureItem);
+      completionProperty.icon = 'refProperty';
+
+      if (structureItem.name === 'item') {
+        const context = /\{([^()]+)\}/.exec(newType);
+        newType = context[1];
+        let res: any[] = [];
+        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,
+            });
+          }
         });
-        parentItem.children = newChildren;
-    }
-    const completionProperty = new CompletionProperty(parentItem);
-    // 变量 param return 在这里添加图标
-    completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
-    return completionProperty;
+        res = res.map((item) => {
+          const newItem: any = item;
+          // 如果没有父节点就是Identifier
+          newItem.value = `${structureItem.value}.${newItem.name}`;
+          const memberExpression = new MemberExpression({
+            object: structureItem.expression,
+            property: new Identifier({ name: newItem.name }),
+          });
+          newItem.expression = memberExpression;
+          // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+          newItem.concept = 'CompletionProperty';
+          // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+          if (item.typeKey && !isNoChildType(item.typeKey)) {
+            newItem.children = nextObjectTypeChild(item.typeKey, newItem, node);
+          }
+          newItem.typeAnnotation = displayString2TypeAnnotation(newItem.typeKey);
+          const completionProperty = new CompletionProperty(newItem);
+          completionProperty.icon = 'refProperty';
+          return completionProperty;
+        });
+        completionProperty.children = res;
+        return completionProperty;
+      }
+      return completionProperty;
+    });
+    parentItem.children = newChildren;
+  }
+  const completionProperty = new CompletionProperty(parentItem);
+  // 变量 param return 在这里添加图标
+  completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
+  return completionProperty;
 }
 /**
  * 获取对象类型的下一级展示
@@ -418,344 +417,344 @@ function getAStructureScopeType(type: string, parent: any, node: SynatxNode) {
 }`
  */
 function getAStructureObjectStringType(type: string, parent: any, node: SynatxNode) {
-    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 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: any[] = [];
+  newType.split(';').forEach((item) => {
+    if (item) {
+      const itemArr = item.split(':');
+      const name = itemArr[0];
+      const typeKey = itemArr[1];
+      res.push({
+        name,
+        typeKey,
+      });
     }
-    let res: any[] = [];
-    newType.split(';').forEach((item) => {
-        if (item) {
-            const itemArr = item.split(':');
-            const name = itemArr[0];
-            const typeKey = itemArr[1];
-            res.push({
-                name,
-                typeKey,
-            });
-        }
-    });
-    const parentItem: any = parent;
+  });
+  const parentItem: any = parent;
+  // 如果没有父节点就是Identifier
+  // value需要拼接生成
+  const identifier = new Identifier({ name: parentItem.text });
+  parentItem.expression = identifier;
+  parentItem.value = parentItem.text;
+  parentItem.name = parentItem.text;
+
+  // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+  parentItem.concept = 'CompletionProperty';
+
+  res = res.map((item) => {
+    const newItem: any = item;
     // 如果没有父节点就是Identifier
-    // value需要拼接生成
-    const identifier = new Identifier({ name: parentItem.text });
-    parentItem.expression = identifier;
-    parentItem.value = parentItem.text;
-    parentItem.name = parentItem.text;
-
-    // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-    parentItem.concept = 'CompletionProperty';
-
-    res = res.map((item) => {
-        const newItem: any = item;
-        // 如果没有父节点就是Identifier
-        newItem.value = `${parentItem.value}.${newItem.name}`;
-        const memberExpression = new MemberExpression({
-            object: parentItem.expression,
-            property: new Identifier({ name: newItem.name }),
-        });
-        newItem.expression = memberExpression;
-        // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-        newItem.concept = 'CompletionProperty';
-        // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
-        if (item.typeKey && !isNoChildType(item.typeKey)) {
-            newItem.children = nextObjectTypeChild(getPlatformType(item.typeKey), newItem, node);
-        }
-        newItem.typeAnnotation = displayString2TypeAnnotation(newItem.typeKey);
-        const completionProperty = new CompletionProperty(newItem);
-
-        completionProperty.icon = 'refProperty';
-        return completionProperty;
+    newItem.value = `${parentItem.value}.${newItem.name}`;
+    const memberExpression = new MemberExpression({
+      object: parentItem.expression,
+      property: new Identifier({ name: newItem.name }),
     });
-    parentItem.children = res;
-    const completionProperty = new CompletionProperty(parentItem);
+    newItem.expression = memberExpression;
+    // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+    newItem.concept = 'CompletionProperty';
+    // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+    if (item.typeKey && !isNoChildType(item.typeKey)) {
+      newItem.children = nextObjectTypeChild(getPlatformType(item.typeKey), newItem, node);
+    }
+    newItem.typeAnnotation = displayString2TypeAnnotation(newItem.typeKey);
+    const completionProperty = new CompletionProperty(newItem);
 
-    // 变量 param return 在这里添加图标
-    completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
+    completionProperty.icon = 'refProperty';
     return completionProperty;
+  });
+  parentItem.children = res;
+  const completionProperty = new CompletionProperty(parentItem);
+
+  // 变量 param return 在这里添加图标
+  completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
+  return completionProperty;
 }
 function nextObjectTypeChild(typeKey: string, item: any, node: SynatxNode) {
-    const newType = findNode(typeKey, node);
-    if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
-        // 处理泛型的内容要取到值
-        const StructureJson = newType.toJSON();
-        const newStructure = new Structure(StructureJson);
-        newStructure.properties.forEach((item: StructureProperty | EntityProperty) => {
-            const itemType = item?.typeAnnotation?.typeKey;
-            if (itemType === 'T' && /<([^()]+)>/g.exec(typeKey)) {
-                const newTypes = /<([^()]+)>/g.exec(typeKey);
-                // 找到当前原来的类型
-                const contentType = getPlatformType(newTypes[1]);
-                const typeNamespace = contentType.substring(0, contentType.lastIndexOf('.'));
-                const typeName = contentType.substring(contentType.lastIndexOf('.') + 1, contentType.length);
-                item.typeAnnotation = new TypeAnnotation({
-                    typeKind: 'reference',
-                    typeNamespace,
-                    typeName,
-                });
-            }
+  const newType = findNode(typeKey, node);
+  if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
+    // 处理泛型的内容要取到值
+    const StructureJson = newType.toJSON();
+    const newStructure = new Structure(StructureJson);
+    newStructure.properties.forEach((item: StructureProperty | EntityProperty) => {
+      const itemType = item?.typeAnnotation?.typeKey;
+      if (itemType === 'T' && /<([^()]+)>/g.exec(typeKey)) {
+        const newTypes = /<([^()]+)>/g.exec(typeKey);
+        // 找到当前原来的类型
+        const contentType = getPlatformType(newTypes[1]);
+        const typeNamespace = contentType.substring(0, contentType.lastIndexOf('.'));
+        const typeName = contentType.substring(contentType.lastIndexOf('.') + 1, contentType.length);
+        item.typeAnnotation = new TypeAnnotation({
+          typeKind: 'reference',
+          typeNamespace,
+          typeName,
         });
-        return formatVariableData(newStructure.properties, node, item);
-    }
+      }
+    });
+    return formatVariableData(newStructure.properties, node, item);
+  }
 }
 
 function getNodeTypeVariableData(nodeType: any, item: any, node: SynatxNode) {
-    item.value = item.text;
-    item.name = item.text;
-    const parentExpression = new Identifier({ name: item.text });
-    item.expression = parentExpression;
-    if (nodeType) {
-        const typeAnnotation = type2TypeAnnotation(nodeType);
-        const typeKeyMap = new Map();
-        const app = (node.rootNode) as App;
-        let structure: any = {};
-
-        // 偶尔会报这个错误，先跳过吧
-        if (!typeAnnotation) {
-            return;
-        }
-
-        // 数据查询没有输出参数，特殊处理
-        if (typeAnnotation.typeKind === 'anonymousStructure') {
-            structure = { properties: typeAnnotation.properties };
-        } else if (typeAnnotation.typeArguments) {
-            structure = { properties: app.getSelectRef(typeAnnotation, true) };
-        } else {
-            structure = app.findNodeByCompleteName(typeAnnotation.typeNamespace + '.' + typeAnnotation.typeName);
-        }
-        structure?.properties?.forEach((structureProperty: StructureProperty) => {
-            const { name, typeAnnotation } = structureProperty;
-            const expression = new MemberExpression({
-                object: parentExpression,
-                property: new Identifier({ name }),
-            });
-            const completionData = new CompletionProperty({
-                name,
-                value: name,
-                expression,
-                children: [],
-            });
-            completionData.icon = 'refProperty';
-
-            item.children.push(completionData);
-            recursionProperty(typeAnnotation, completionData, node, typeKeyMap);
-        });
+  item.value = item.text;
+  item.name = item.text;
+  const parentExpression = new Identifier({ name: item.text });
+  item.expression = parentExpression;
+  if (nodeType) {
+    const typeAnnotation = type2TypeAnnotation(nodeType);
+    const typeKeyMap = new Map();
+    const app = node.rootNode as App;
+    let structure: any = {};
+
+    // 偶尔会报这个错误，先跳过吧
+    if (!typeAnnotation) {
+      return;
     }
 
-    const completionData = new CompletionProperty(item);
-    // 变量 param return 在这里添加图标
-    completionData.icon = getNodeiconFromLogic(completionData, node);
-    return completionData;
-}
-function recursionProperty(structureTypeAnnotation: TypeAnnotation, parentCompletion: CompletionProperty, node: BaseNode, typeKeyMap: Map<string, number>) {
-    const app = (node.rootNode) as App;
-    let structure;
-    if (structureTypeAnnotation.typeArguments) {
-        structure = { properties: app.getSelectRef(structureTypeAnnotation, true) };
+    // 数据查询没有输出参数，特殊处理
+    if (typeAnnotation.typeKind === 'anonymousStructure') {
+      structure = { properties: typeAnnotation.properties };
+    } else if (typeAnnotation.typeArguments) {
+      structure = { properties: app.getSelectRef(typeAnnotation, true) };
     } else {
-        if (structureTypeAnnotation.typeKind === 'anonymousStructure') {
-            structure = { properties: structureTypeAnnotation.properties };
-        } else {
-            structure = app.findNodeByCompleteName(structureTypeAnnotation.typeNamespace + '.' + structureTypeAnnotation.typeName);
-        }
+      structure = app.findNodeByCompleteName(`${typeAnnotation.typeNamespace}.${typeAnnotation.typeName}`);
     }
-
     structure?.properties?.forEach((structureProperty: StructureProperty) => {
-        const { name, typeAnnotation } = structureProperty;
-        const object = (BaseNode.from({ ...parentCompletion.expression.toJSON() }) as any);
-        const expression = new MemberExpression({
-            object,
-            property: new Identifier({ name }),
-        });
-        const completionData = new CompletionProperty({
-            name,
-            value: name,
-            expression,
-            children: [],
-        });
-        completionData.icon = 'refProperty';
-        parentCompletion.children.push(completionData);
-        if (getNextFlag(typeAnnotation.typeKey, typeKeyMap)) {
-            recursionProperty(typeAnnotation, completionData, node, typeKeyMap);
-        }
+      const { name, typeAnnotation } = structureProperty;
+      const expression = new MemberExpression({
+        object: parentExpression,
+        property: new Identifier({ name }),
+      });
+      const completionData = new CompletionProperty({
+        name,
+        value: name,
+        expression,
+        children: [],
+      });
+      completionData.icon = 'refProperty';
+
+      item.children.push(completionData);
+      recursionProperty(typeAnnotation, completionData, node, typeKeyMap);
     });
+  }
+
+  const completionData = new CompletionProperty(item);
+  // 变量 param return 在这里添加图标
+  completionData.icon = getNodeiconFromLogic(completionData, node);
+  return completionData;
+}
+function recursionProperty(
+  structureTypeAnnotation: TypeAnnotation,
+  parentCompletion: CompletionProperty,
+  node: BaseNode,
+  typeKeyMap: Map<string, number>
+) {
+  const app = node.rootNode as App;
+  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: StructureProperty) => {
+    const { name, typeAnnotation } = structureProperty;
+    const object = BaseNode.from({ ...parentCompletion.expression.toJSON() }) as any;
+    const expression = new MemberExpression({
+      object,
+      property: new Identifier({ name }),
+    });
+    const completionData = new 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: string, typeKeyMap: Map<string, number>) {
-    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;
+  if (['nasl.core.String', 'nasl.collection.List', 'nasl.collection.Map'].includes(typeKey)) return true;
+  if (typeKeyMap.get(typeKey) === 3) {
+    return false;
+  }
+  if (typeKeyMap.get(typeKey) > 0) {
+    typeKeyMap.set(typeKey, typeKeyMap.get(typeKey) + 1);
+  } else {
+    typeKeyMap.set(typeKey, 1);
+  }
+  return true;
 }
 // 格式化变量数据
 export function formatVariableData(data: unknown | variableItem[], node: SynatxNode, parent?: any) {
-    if (Array.isArray(data)) {
-        let result = data.map((item) => {
-            item.children = [];
-            // 当前的类型如 app.entitys.entity1 nasl.core.String
-            let typeKey: string;
-            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: string = formatTs2TypeString(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
-                    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 StructureProperty || item instanceof 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 Identifier({ name: item.name });
-                item.expression = identifier;
-                item.typeKey = typeKey;
-            } else {
-                item.value = `${parent.value}.${item.name}`;
-                const object: any = BaseNode.from(parent.expression.toJSON());
-                const memberExpression = new MemberExpression({
-                    object,
-                    property: new 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);
-                }
+  if (Array.isArray(data)) {
+    let result = data.map((item) => {
+      item.children = [];
+      // 当前的类型如 app.entitys.entity1 nasl.core.String
+      let typeKey: string;
+      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;
+        }
+        // 当前节点的完整类型，主要是在有T的内容使用 nasl.list<Enum1> 内部匹配内容给里面子集的T赋值类型
+        let currentType: string = formatTs2TypeString(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
+        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;
             }
-            // 如果是从实体或者数据结构取的属性，就需要重置一下类型
-            item.concept = 'CompletionProperty';
-            const completionProperty = new CompletionProperty(item);
-            completionProperty.jsonName = item.jsonName;
-            // 标记实体属性是否是符合类型
-            if (typeof item.isComplexType === 'boolean') {
-                Object.assign(completionProperty, { isComplexType: item.isComplexType });
+            if (newCurrentType.startsWith('nasl.ui.Current<{')) {
+              const completionProperty = getAStructureScopeType(newCurrentType, item, node);
+              return completionProperty;
             }
-            if (!parent) {
-                // 变量 param return 在这里添加图标
-                completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
-            } else {
-                completionProperty.icon = 'refProperty';
+            if (newCurrentType.startsWith('nasl.collection.List<{') && newCurrentType.endsWith('}>')) {
+              currentType = 'nasl.collection.List<nasl.core.Any>';
             }
-            return completionProperty;
+          }
+        }
+        typeKey = getPlatformType(currentType);
+        item.typeAnnotation = displayString2TypeAnnotation(typeKey);
+      } else if (item instanceof StructureProperty || item instanceof 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 Identifier({ name: item.name });
+        item.expression = identifier;
+        item.typeKey = typeKey;
+      } else {
+        item.value = `${parent.value}.${item.name}`;
+        const object: any = BaseNode.from(parent.expression.toJSON());
+        const memberExpression = new MemberExpression({
+          object,
+          property: new Identifier({ name: item.name }),
         });
-
-        /**
-         * 排序result
-         * 如果没有父级就是第一集就排序一下当前result，用户体验优化
-        */
-        if (!parent) {
-            result = sortFirstVariableData(result, node);
+        item.expression = memberExpression;
+        item.variableParent = parent;
+        item.typeKey = typeKey;
+        // 标记实体属性是否是符合类型
+        item.isComplexType = item.typeAnnotation?.isComplexType();
+      }
+      // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
+      if (typeKey && !isNoChildType(typeKey)) {
+        let currentParent = item;
+        let typeKeyIndex = 0;
+        while (currentParent.variableParent) {
+          currentParent = currentParent.variableParent;
+          if (currentParent.typeKey === typeKey) {
+            typeKeyIndex++;
+          }
         }
+        // 向上找到3次一样的就结束
+        if (typeKeyIndex < 3) {
+          nextFindTypeChild(typeKey, item, node);
+        }
+      }
+      // 如果是从实体或者数据结构取的属性，就需要重置一下类型
+      item.concept = 'CompletionProperty';
+      const completionProperty = new 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;
+    });
 
-        return result.filter(Boolean);
+    /**
+     * 排序result
+     * 如果没有父级就是第一集就排序一下当前result，用户体验优化
+     */
+    if (!parent) {
+      result = sortFirstVariableData(result, node);
     }
+
+    return result.filter(Boolean);
+  }
 }
 
 // 从logic获取节点的icon
 function getNodeiconFromLogic(completionProperty: CompletionProperty, node: SynatxNode): string {
-    const { name: propName } = completionProperty;
-    const { view } = node as Param;
-    const logic = (node as Param).logic || (node as Param).OverriddenLogic || (node as Param).AuthLogic || (node as Param).AuthLogicForCallInterface;
-
+  const { name: propName } = completionProperty;
+  const { view } = node as Param;
+  const logic = (node as Param).logic || (node as Param).OverriddenLogic || (node as Param).AuthLogic || (node as Param).AuthLogicForCallInterface;
 
-    if (node.concept === 'Identifier' || node.concept === 'BindAttribute' || node.concept === 'MemberExpression') {
-        const callLogic = node.getAncestor<CallLogic>('CallLogic');
-        const originLogic = callLogic?.getCallNode() as Logic;
+  if (node.concept === 'Identifier' || node.concept === 'BindAttribute' || node.concept === 'MemberExpression') {
+    const callLogic = node.getAncestor<CallLogic>('CallLogic');
+    const originLogic = callLogic?.getCallNode() as Logic;
 
-        if (originLogic?.params.find((item) => item.name === propName)) {
-            return 'param';
-        }
+    if (originLogic?.params.find((item) => item.name === propName)) {
+      return 'param';
     }
+  }
 
-    if (view) {
-        // 前端逻辑调用
-        const { params } = view;
+  if (view) {
+    // 前端逻辑调用
+    const { params } = view;
 
-        if (params.find((item) => item.name === propName)) {
-            return 'param';
-        }
+    if (params.find((item) => item.name === propName)) {
+      return 'param';
     }
+  }
 
-    if (logic) {
-        const { params, returns } = logic;
-
-        if (logic instanceof 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 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 (logic) {
+    const { params, returns } = logic;
 
-        if (params.find((item) => item.name === propName)) {
-            return 'param';
-        } else if (returns.find((item) => item.name === propName)) {
-            return 'return';
-        } else {
-            return 'variable';
-        }
+    if (logic instanceof 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 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';
+    }
+    if (returns.find((item) => item.name === propName)) {
+      return 'return';
     }
+    return 'variable';
+  }
 
-    const bindAttr = node.getAncestor<BindAttribute>('BindAttribute');
+  const bindAttr = node.getAncestor<BindAttribute>('BindAttribute');
 
-    if (bindAttr) {
-        const interfaceInstance = bindAttr.getAncestor<Interface>('Interface');
+  if (bindAttr) {
+    const interfaceInstance = bindAttr.getAncestor<Interface>('Interface');
 
-        if (interfaceInstance?.params.find((item) => item.name === propName)) {
-            return 'param';
-        }
+    if (interfaceInstance?.params.find((item) => item.name === propName)) {
+      return 'param';
     }
+  }
 
-    return 'variable';
+  return 'variable';
 }
 
 /**
@@ -768,113 +767,113 @@ function getNodeiconFromLogic(completionProperty: CompletionProperty, node: Syna
  * 流程的韬哥自己解决了，所以先解决这两部分
  */
 function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
-    const newResult: CompletionProperty[] = [];
-    const logic = (node as Param).logic;
-    const view = (node as Param).view;
-    if (view) {
-        const { params, variables } = view;
-        const list = [...params, ...variables];
-        list.forEach((item) => {
-            const findIndex = result.findIndex((findItem) => findItem.name === item.name);
-            if (findIndex !== -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;
+  const newResult: CompletionProperty[] = [];
+  const { logic } = node as Param;
+  const { view } = node as Param;
+  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;
 }
 export function formatBackendVariables(variables: Array<BackendVariable>) {
-    const result = variables.map((itemNode) => {
-        const namespace = itemNode.getNamespace();
-        const newItem: any = {
-            name: itemNode.name,
-            value: itemNode.name,
-            expression: new Identifier({
-                name: itemNode.name,
-                namespace,
-            }),
-        };
-        const noChildType = isNoChildType(itemNode.typeAnnotation?.typeKey);
-
-        if (!noChildType) {
-            nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
-        }
-        const completionProperty = new CompletionProperty(newItem);
-        completionProperty.icon = 'backendVariable';
-        return completionProperty;
-    });
-    return result;
+  const result = variables.map((itemNode) => {
+    const namespace = itemNode.getNamespace();
+    const newItem: any = {
+      name: itemNode.name,
+      value: itemNode.name,
+      expression: new Identifier({
+        name: itemNode.name,
+        namespace,
+      }),
+    };
+    const noChildType = isNoChildType(itemNode.typeAnnotation?.typeKey);
+
+    if (!noChildType) {
+      nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
+    }
+    const completionProperty = new CompletionProperty(newItem);
+    completionProperty.icon = 'backendVariable';
+    return completionProperty;
+  });
+  return result;
 }
 export function formatFrontEndVariables(frontEndVariables: Array<Variable>) {
-    const result = frontEndVariables.map((itemNode) => {
-        const namespace = itemNode.getNamespace();
-        const newItem: any = {
-            name: itemNode.name,
-            value: itemNode.name,
-            expression: new Identifier({
-                name: itemNode.name,
-                namespace,
-            }),
-        };
-        const noChildType = isNoChildType(itemNode.typeAnnotation?.typeKey);
-
-        if (!noChildType) {
-            nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
-        }
-        const completionProperty = new CompletionProperty(newItem);
-        completionProperty.icon = 'frontendVariable';
-        return completionProperty;
-    });
-    return result;
+  const result = frontEndVariables.map((itemNode) => {
+    const namespace = itemNode.getNamespace();
+    const newItem: any = {
+      name: itemNode.name,
+      value: itemNode.name,
+      expression: new Identifier({
+        name: itemNode.name,
+        namespace,
+      }),
+    };
+    const noChildType = isNoChildType(itemNode.typeAnnotation?.typeKey);
+
+    if (!noChildType) {
+      nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
+    }
+    const completionProperty = new CompletionProperty(newItem);
+    completionProperty.icon = 'frontendVariable';
+    return completionProperty;
+  });
+  return result;
 }
 
 export function formatConfigProperties(configProperties: Array<ConfigProperty>, isView: Boolean) {
-    const result = configProperties.reduce((pre: any, item) => {
-        const { isPrivate = false } = item;
-
-        if (!isPrivate || !isView) {
-            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,
-            };
-
-            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;
+  const result = configProperties.reduce((pre: any, item) => {
+    const { isPrivate = false } = item;
+
+    if (!isPrivate || !isView) {
+      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,
+      };
+
+      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;
 }