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

package/src/templator/utils.ts

@@ -2,11 +2,10 @@ import { utils } from '..';
 import { App, Module, Entity, EntityProperty, Logic, View, Namespace } from '../concepts';
 
 export const filterProperty = (key: 'inTable' | 'inFilter' | 'inForm' | 'inDetail') => (property: EntityProperty) => {
-    if (property.display) {
-        return property.display[key];
-    } else {
-        return !['id', 'createdTime', 'updatedTime'].includes(property.name);
-    }
+  if (property.display) {
+    return property.display[key];
+  }
+  return !['id', 'createdTime', 'updatedTime'].includes(property.name);
 };
 
 /**
@@ -15,21 +14,17 @@ export const filterProperty = (key: 'inTable' | 'inFilter' | 'inForm' | 'inDetai
  * @param expression 表达式
  */
 export function getExpression(property: EntityProperty, expression: string) {
-    const { typeAnnotation } = property || {};
-    const { typeName: propertyTypeName, typeNamespace: propertyTypeNamespace } = typeAnnotation || {};
-    if (propertyTypeName === 'DateTime')
-        return `$utils['FormatDateTime'](${expression}, 'YYYY-MM-DD HH:mm:ss')`;
-    else if (propertyTypeName === 'Date')
-        return `$utils['FormatDate'](${expression}, 'YYYY-MM-DD')`;
-    else {
-        const namespaceArr = propertyTypeNamespace.split('.');
-        const type = namespaceArr.pop();
-        if (type === 'enums') {
-            return `$utils['EnumValueToText'](${expression}, '__enumTypeAnnotation_${propertyTypeNamespace}.${propertyTypeName}')`;
-        } else {
-            return `${expression || "''"}`;
-        }
-    }
+  const { typeAnnotation } = property || {};
+  const { typeName: propertyTypeName, typeNamespace: propertyTypeNamespace } = typeAnnotation || {};
+  if (propertyTypeName === 'DateTime') return `$utils['FormatDateTime'](${expression}, 'YYYY-MM-DD HH:mm:ss')`;
+  if (propertyTypeName === 'Date') return `$utils['FormatDate'](${expression}, 'YYYY-MM-DD')`;
+
+  const namespaceArr = propertyTypeNamespace.split('.');
+  const type = namespaceArr.pop();
+  if (type === 'enums') {
+    return `$utils['EnumValueToText'](${expression}, '__enumTypeAnnotation_${propertyTypeNamespace}.${propertyTypeName}')`;
+  }
+  return `${expression || "''"}`;
 }
 
 /**
@@ -38,33 +33,32 @@ export function getExpression(property: EntityProperty, expression: string) {
  * @param paramName
  */
 export function getParamFromLogic(logic: Logic, paramName: string) {
-    const params = logic.params;
-    return params.find((item) => item.name === paramName);
+  const { params } = logic;
+  return params.find((item) => item.name === paramName);
 }
 
 export function getFirstDisplayedProperty(entity: Entity) {
-    let property = entity.properties.find((property) => !property.readonly);
-    if (!property)
-        property = entity.properties[0];
-    return property;
+  let property = entity.properties.find((property) => !property.readonly);
+  if (!property) property = entity.properties[0];
+  return property;
 }
 
 function genArgumentMemberExpression(arr: string[]) {
-    let expressionNode: any;
-    const propertyName = arr.pop();
-    if (arr.length >= 1) {
-        expressionNode = NaslLogicItem.MemberExpression({
-            object: genArgumentMemberExpression(arr),
-            property: NaslLogicItem.Identifier({
-                name: propertyName,
-            }),
-        });
-    } else {
-        return NaslLogicItem.Identifier({
-            name: propertyName,
-        });
-    }
-    return expressionNode;
+  let expressionNode: any;
+  const propertyName = arr.pop();
+  if (arr.length >= 1) {
+    expressionNode = NaslLogicItem.MemberExpression({
+      object: genArgumentMemberExpression(arr),
+      property: NaslLogicItem.Identifier({
+        name: propertyName,
+      }),
+    });
+  } else {
+    return NaslLogicItem.Identifier({
+      name: propertyName,
+    });
+  }
+  return expressionNode;
 }
 
 /**
@@ -74,10 +68,10 @@ function genArgumentMemberExpression(arr: string[]) {
  * @param schemaChildren 数据结构
  */
 export function genLogicParam(paramIdOrName: string, expression: string) {
-    return NaslLogicItem.Argument({
-        keyword: paramIdOrName,
-        expression: genArgumentMemberExpression(expression.split('.')),
-    });
+  return NaslLogicItem.Argument({
+    keyword: paramIdOrName,
+    expression: genArgumentMemberExpression(expression.split('.')),
+  });
 }
 
 /**
@@ -87,47 +81,46 @@ export function genLogicParam(paramIdOrName: string, expression: string) {
  * @param schemaChildren 数据结构
  */
 export function genMemberExpression(expression: string, schemaRefs: Array<string> = []) {
-    const arr = expression.split('.');
+  const arr = expression.split('.');
 
-    let expressionNode: any;
-    arr.forEach((name, index) => {
-        const currentNode = NaslLogicItem.Identifier({
-            name,
-        });
-        if (expressionNode) {
-            expressionNode = NaslLogicItem.MemberExpression({
-                object: expressionNode,
-                property: NaslLogicItem.Identifier({
-                    name,
-                }),
-            });
-        } else {
-            expressionNode = currentNode;
-        }
+  let expressionNode: any;
+  arr.forEach((name, index) => {
+    const currentNode = NaslLogicItem.Identifier({
+      name,
     });
+    if (expressionNode) {
+      expressionNode = NaslLogicItem.MemberExpression({
+        object: expressionNode,
+        property: NaslLogicItem.Identifier({
+          name,
+        }),
+      });
+    } else {
+      expressionNode = currentNode;
+    }
+  });
 
-    return expressionNode;
+  return expressionNode;
 }
 
 /**
  * 命名组，主要承载一次 mergeBlock 中的逻辑名称
  */
 export interface NameGroup {
-    logic?: string;
-    structure?: string;
-    load?: string;
-    remove?: string;
-    modify?: string;
-    submit?: string;
-    lowerEntity?: string;
-    [key: string]: string;
+  logic?: string;
+  structure?: string;
+  load?: string;
+  remove?: string;
+  modify?: string;
+  submit?: string;
+  lowerEntity?: string;
+  [key: string]: string;
 }
 
 function capFirstLetter(word: string) {
-    if (!word)
-        return word;
+  if (!word) return word;
 
-    return word[0].toUpperCase() + word.slice(1);
+  return word[0].toUpperCase() + word.slice(1);
 }
 /**
  * 生成数据查询唯一的命名组
@@ -136,431 +129,464 @@ function capFirstLetter(word: string) {
  * @param suffix 其它后缀，比如实体名等等
  * @param defaultInView 是否在页面逻辑中用 load 简写
  */
-export function genUniqueQueryNameGroup(scope: App | Module | Namespace, view: View, componentName: string = '', defaultInView: boolean = true, suffix: string = '') {
-    const result: NameGroup = {};
-    result.viewLogicLoad = view.getLogicUniqueName(`load${defaultInView ? '' : capFirstLetter(componentName)}${suffix ? capFirstLetter(suffix) : ''}`);
-    result.logic = scope.getLogicUniqueName(`load${capFirstLetter(view.name)}${componentName ? capFirstLetter(componentName) : ''}${suffix ? capFirstLetter(suffix) : ''}`);
-    result.structure = scope.getStructureUniqueName(utils.firstUpperCase(result.logic + 'Structure'));
-    return result;
+export function genUniqueQueryNameGroup(
+  scope: App | Module | Namespace,
+  view: View,
+  componentName: string = '',
+  defaultInView: boolean = true,
+  suffix: string = ''
+) {
+  const result: NameGroup = {};
+  result.viewLogicLoad = view.getLogicUniqueName(`load${defaultInView ? '' : capFirstLetter(componentName)}${suffix ? capFirstLetter(suffix) : ''}`);
+  result.logic = scope.getLogicUniqueName(
+    `load${capFirstLetter(view.name)}${componentName ? capFirstLetter(componentName) : ''}${suffix ? capFirstLetter(suffix) : ''}`
+  );
+  result.structure = scope.getStructureUniqueName(utils.firstUpperCase(`${result.logic}Structure`));
+  return result;
 }
 
 function genNaslCoreTypeAnnotation(typeName: string, text: string = '') {
-    return {
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'primitive',
-        typeNamespace: 'nasl.core',
-        typeName,
-        text,
-    };
+  return {
+    concept: 'TypeAnnotation',
+    name: '',
+    typeKind: 'primitive',
+    typeNamespace: 'nasl.core',
+    typeName,
+    text,
+  };
 }
 
 function genNaslUITypeAnnotation(typeName: string) {
-    return {
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'reference',
-        typeNamespace: 'nasl.ui',
-        typeName,
-    };
+  return {
+    concept: 'TypeAnnotation',
+    name: '',
+    typeKind: 'reference',
+    typeNamespace: 'nasl.ui',
+    typeName,
+  };
 }
 
 function genNaslCollectionTypeAnnotation(typeName: string) {
-    return (typeArguments: any[]) => ({
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'generic',
-        typeNamespace: 'nasl.collection',
-        typeName,
-        typeArguments,
-    });
+  return (typeArguments: any[]) => ({
+    concept: 'TypeAnnotation',
+    name: '',
+    typeKind: 'generic',
+    typeNamespace: 'nasl.collection',
+    typeName,
+    typeArguments,
+  });
 }
 
 function genNaslUIGenericTypeAnnotation(typeName: string) {
-    return (typeArguments: any[]) => ({
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'generic',
-        typeNamespace: 'nasl.ui',
-        typeName,
-        typeArguments,
-    });
+  return (typeArguments: any[]) => ({
+    concept: 'TypeAnnotation',
+    name: '',
+    typeKind: 'generic',
+    typeNamespace: 'nasl.ui',
+    typeName,
+    typeArguments,
+  });
 }
 
 export const NaslCoreTypeAnnotation = {
-    Boolean: genNaslCoreTypeAnnotation('Boolean'),
-    // Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
-    // Double: genNaslCoreTypeAnnotation('Double'),
-    Decimal: genNaslCoreTypeAnnotation('Decimal'),
-    Long: genNaslCoreTypeAnnotation('Long', ' Integer 整数'),
-    String: genNaslCoreTypeAnnotation('String', 'String 文本'),
-    // Text: genNaslCoreTypeAnnotation('Text'),
-    Binary: genNaslCoreTypeAnnotation('Binary'),
-    Date: genNaslCoreTypeAnnotation('Date'),
-    Time: genNaslCoreTypeAnnotation('Time'),
-    DateTime: genNaslCoreTypeAnnotation('DateTime'),
-    // Email: genNaslCoreTypeAnnotation('Email'),
+  Boolean: genNaslCoreTypeAnnotation('Boolean'),
+  // Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
+  // Double: genNaslCoreTypeAnnotation('Double'),
+  Decimal: genNaslCoreTypeAnnotation('Decimal'),
+  Long: genNaslCoreTypeAnnotation('Long', ' Integer 整数'),
+  String: genNaslCoreTypeAnnotation('String', 'String 文本'),
+  // Text: genNaslCoreTypeAnnotation('Text'),
+  Binary: genNaslCoreTypeAnnotation('Binary'),
+  Date: genNaslCoreTypeAnnotation('Date'),
+  Time: genNaslCoreTypeAnnotation('Time'),
+  DateTime: genNaslCoreTypeAnnotation('DateTime'),
+  // Email: genNaslCoreTypeAnnotation('Email'),
 };
 
 export const NaslUITypeAnnotation = {
-    DataSourceParams: genNaslUITypeAnnotation('DataSourceParams'),
-    EventTarget: genNaslUITypeAnnotation('EventTarget'),
-    MouseEvent: genNaslUITypeAnnotation('MouseEvent'),
-    FocusEvent: genNaslUITypeAnnotation('FocusEvent'),
-    ChangeEvent: genNaslUITypeAnnotation('ChangeEvent'),
-    NavigateEvent: genNaslUITypeAnnotation('NavigateEvent'),
-    ChangeItemEvent: genNaslUITypeAnnotation('ChangeItemEvent'),
-    ChangeItemsEvent: genNaslUITypeAnnotation('ChangeItemsEvent'),
-    CascadeCapsulesEvent: genNaslUITypeAnnotation('CascadeCapsulesEvent'),
-    CollapseEvent: genNaslUITypeAnnotation('CollapseEvent'),
-    SliderEvent: genNaslUITypeAnnotation('SliderEvent'),
-    DateEvent: genNaslUITypeAnnotation('DateEvent'),
-    OperatorItemEvent: genNaslUITypeAnnotation('OperatorItemEvent'),
-    ValidateEvent: genNaslUITypeAnnotation('ValidateEvent'),
-    PaginationEvent: genNaslUITypeAnnotation('PaginationEvent'),
-    DurationEvent: genNaslUITypeAnnotation('DurationEvent'),
-    TransferEvent: genNaslUITypeAnnotation('TransferEvent'),
-    TreeChangeEvent: genNaslUITypeAnnotation('TreeChangeEvent'),
-    CheckedEvent: genNaslUITypeAnnotation('CheckedEvent'),
-    UploadEvent: genNaslUITypeAnnotation('UploadEvent'),
-    UploadErrorEvent: genNaslUITypeAnnotation('UploadErrorEvent'),
-    SortEvent: genNaslUITypeAnnotation('SortEvent'),
-    PoiInfo: genNaslUITypeAnnotation('PoiInfo'),
-    File: genNaslUITypeAnnotation('File'),
-    KeyboardEvent: genNaslUITypeAnnotation('KeyboardEvent'),
+  DataSourceParams: genNaslUITypeAnnotation('DataSourceParams'),
+  EventTarget: genNaslUITypeAnnotation('EventTarget'),
+  MouseEvent: genNaslUITypeAnnotation('MouseEvent'),
+  FocusEvent: genNaslUITypeAnnotation('FocusEvent'),
+  ChangeEvent: genNaslUITypeAnnotation('ChangeEvent'),
+  NavigateEvent: genNaslUITypeAnnotation('NavigateEvent'),
+  ChangeItemEvent: genNaslUITypeAnnotation('ChangeItemEvent'),
+  ChangeItemsEvent: genNaslUITypeAnnotation('ChangeItemsEvent'),
+  CascadeCapsulesEvent: genNaslUITypeAnnotation('CascadeCapsulesEvent'),
+  CollapseEvent: genNaslUITypeAnnotation('CollapseEvent'),
+  SliderEvent: genNaslUITypeAnnotation('SliderEvent'),
+  DateEvent: genNaslUITypeAnnotation('DateEvent'),
+  OperatorItemEvent: genNaslUITypeAnnotation('OperatorItemEvent'),
+  ValidateEvent: genNaslUITypeAnnotation('ValidateEvent'),
+  PaginationEvent: genNaslUITypeAnnotation('PaginationEvent'),
+  DurationEvent: genNaslUITypeAnnotation('DurationEvent'),
+  TransferEvent: genNaslUITypeAnnotation('TransferEvent'),
+  TreeChangeEvent: genNaslUITypeAnnotation('TreeChangeEvent'),
+  CheckedEvent: genNaslUITypeAnnotation('CheckedEvent'),
+  UploadEvent: genNaslUITypeAnnotation('UploadEvent'),
+  UploadErrorEvent: genNaslUITypeAnnotation('UploadErrorEvent'),
+  SortEvent: genNaslUITypeAnnotation('SortEvent'),
+  PoiInfo: genNaslUITypeAnnotation('PoiInfo'),
+  File: genNaslUITypeAnnotation('File'),
+  KeyboardEvent: genNaslUITypeAnnotation('KeyboardEvent'),
 
-    Current: genNaslUIGenericTypeAnnotation('Current'),
-    DragAndDropEvent: genNaslUIGenericTypeAnnotation('DragAndDropEvent'),
-    ExpandEvent: genNaslUIGenericTypeAnnotation('ExpandEvent'),
-    ScrollEvent: genNaslUIGenericTypeAnnotation('ScrollEvent'),
+  Current: genNaslUIGenericTypeAnnotation('Current'),
+  DragAndDropEvent: genNaslUIGenericTypeAnnotation('DragAndDropEvent'),
+  ExpandEvent: genNaslUIGenericTypeAnnotation('ExpandEvent'),
+  ScrollEvent: genNaslUIGenericTypeAnnotation('ScrollEvent'),
 };
 
 export const NaslTypeAnnotation = {
-    Reference: ({ typeNamespace, typeName }: { typeNamespace: string; typeName: string }) => ({
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'reference',
-        typeNamespace,
-        typeName,
-    }),
-    AnonymousStructure: (properties: any[]) => ({
-        concept: 'TypeAnnotation',
-        typeKind: 'anonymousStructure',
-        properties: [{
-            concept: 'StructureProperty',
-            name: 'list',
-            typeAnnotation: {
-                concept: 'TypeAnnotation',
-                typeKind: 'generic',
-                typeName: 'List',
-                typeNamespace: 'nasl.collection',
-                typeArguments: [{
-                    concept: 'TypeAnnotation',
-                    typeKind: 'anonymousStructure',
-                    properties,
-                }],
-            },
-        }, {
-            concept: 'StructureProperty',
-            name: 'total',
-            typeAnnotation: {
-                concept: 'TypeAnnotation',
-                typeKind: 'primitive',
-                typeNamespace: 'nasl.core',
-                typeName: 'Long',
+  Reference: ({ typeNamespace, typeName }: { typeNamespace: string; typeName: string }) => ({
+    concept: 'TypeAnnotation',
+    name: '',
+    typeKind: 'reference',
+    typeNamespace,
+    typeName,
+  }),
+  AnonymousStructure: (properties: any[]) => ({
+    concept: 'TypeAnnotation',
+    typeKind: 'anonymousStructure',
+    properties: [
+      {
+        concept: 'StructureProperty',
+        name: 'list',
+        typeAnnotation: {
+          concept: 'TypeAnnotation',
+          typeKind: 'generic',
+          typeName: 'List',
+          typeNamespace: 'nasl.collection',
+          typeArguments: [
+            {
+              concept: 'TypeAnnotation',
+              typeKind: 'anonymousStructure',
+              properties,
             },
-        }],
-    }),
+          ],
+        },
+      },
+      {
+        concept: 'StructureProperty',
+        name: 'total',
+        typeAnnotation: {
+          concept: 'TypeAnnotation',
+          typeKind: 'primitive',
+          typeNamespace: 'nasl.core',
+          typeName: 'Long',
+        },
+      },
+    ],
+  }),
 };
 
 export const NaslCollectionTypeAnnotation = {
-    List: genNaslCollectionTypeAnnotation('List'),
-    PageOf: genNaslCollectionTypeAnnotation('PageOf'),
+  List: genNaslCollectionTypeAnnotation('List'),
+  PageOf: genNaslCollectionTypeAnnotation('PageOf'),
 };
 
 export const NaslLogicItem = {
-    // 开始
-    Start: {
-        concept: 'Start',
-        name: '',
-        label: '开始',
-        kind: 'Statement',
-    },
-    // 结束
-    End: {
-        concept: 'End',
-        name: '',
-        label: '结束',
-        kind: 'Statement',
-    },
-    // 调用逻辑
-    CallLogic: ({
-        calleeNamespace,
-        calleeName,
-        label = '调用逻辑',
-        shortcut = false,
-        arguments: args,
-    }: {
-        calleeNamespace?: string;
-        calleeName: string;
-        label?: string;
-        shortcut?: boolean;
-        arguments: any[];
-    }) => ({
-        concept: 'CallLogic',
-        name: '',
-        label,
-        kind: 'Statement',
-        shortcut,
-        calleeNamespace,
-        calleeName,
-        arguments: args,
-    }),
-    // 内置函数
-    CallFunction: ({
-        calleeNamespace = 'nasl.util',
-        calleeName,
-        label = '内置函数',
-        shortcut = false,
-        arguments: args = [],
-        typeArguments: typeArgs = [],
-    }: {
-        calleeNamespace?: string;
-        calleeName: string;
-        label?: string;
-        shortcut?: boolean;
-        arguments?: any[];
-        typeArguments?: any[];
-    }) => ({
-        concept: 'CallFunction',
-        name: '',
-        label: '调用逻辑',
-        kind: 'Expression',
-        calleeNamespace,
-        calleeName,
-        arguments: args,
-        typeArguments: typeArgs,
-    }),
-    // 参数
-    Argument: ({ keyword, expression }: { keyword: string; expression: any }) => ({
-        concept: 'Argument',
-        name: '',
-        kind: 'Statement',
-        keyword,
-        expression,
-    }),
-    // 成员表达式
-    MemberExpression: ({ object, property }: { object: any; property: any }) => ({
-        concept: 'MemberExpression',
-        name: '',
-        kind: 'Expression',
-        object,
-        property,
-    }),
-    // 变量
-    Identifier: ({ name }: { name: string }) => ({
-        concept: 'Identifier',
-        kind: 'Expression',
-        name,
-    }),
-    // 字面量
-    StringLiteral: ({ value }: { value: string }) => ({
-        concept: 'StringLiteral',
-        name: '',
-        kind: 'Expression',
-        value,
-    }),
-    Assignment: ({ left, right }: { left: any; right: any }) => ({
-        concept: 'Assignment',
-        name: '',
-        label: '赋值',
-        kind: 'Statement',
-        left,
-        right,
-    }),
-    IfStatement: ({ test, consequent, alternate }: { test: any; consequent: any[]; alternate: any[] }) => ({
-        concept: 'IfStatement',
-        name: '',
-        kind: 'Statement',
-        test,
-        consequent,
-        alternate,
-    }),
+  // 开始
+  Start: {
+    concept: 'Start',
+    name: '',
+    label: '开始',
+    kind: 'Statement',
+  },
+  // 结束
+  End: {
+    concept: 'End',
+    name: '',
+    label: '结束',
+    kind: 'Statement',
+  },
+  // 调用逻辑
+  CallLogic: ({
+    calleeNamespace,
+    calleeName,
+    label = '调用逻辑',
+    shortcut = false,
+    arguments: args,
+  }: {
+    calleeNamespace?: string;
+    calleeName: string;
+    label?: string;
+    shortcut?: boolean;
+    arguments: any[];
+  }) => ({
+    concept: 'CallLogic',
+    name: '',
+    label,
+    kind: 'Statement',
+    shortcut,
+    calleeNamespace,
+    calleeName,
+    arguments: args,
+  }),
+  // 内置函数
+  CallFunction: ({
+    calleeNamespace = 'nasl.util',
+    calleeName,
+    label = '内置函数',
+    shortcut = false,
+    arguments: args = [],
+    typeArguments: typeArgs = [],
+  }: {
+    calleeNamespace?: string;
+    calleeName: string;
+    label?: string;
+    shortcut?: boolean;
+    arguments?: any[];
+    typeArguments?: any[];
+  }) => ({
+    concept: 'CallFunction',
+    name: '',
+    label: '调用逻辑',
+    kind: 'Expression',
+    calleeNamespace,
+    calleeName,
+    arguments: args,
+    typeArguments: typeArgs,
+  }),
+  // 参数
+  Argument: ({ keyword, expression }: { keyword: string; expression: any }) => ({
+    concept: 'Argument',
+    name: '',
+    kind: 'Statement',
+    keyword,
+    expression,
+  }),
+  // 成员表达式
+  MemberExpression: ({ object, property }: { object: any; property: any }) => ({
+    concept: 'MemberExpression',
+    name: '',
+    kind: 'Expression',
+    object,
+    property,
+  }),
+  // 变量
+  Identifier: ({ name }: { name: string }) => ({
+    concept: 'Identifier',
+    kind: 'Expression',
+    name,
+  }),
+  // 字面量
+  StringLiteral: ({ value }: { value: string }) => ({
+    concept: 'StringLiteral',
+    name: '',
+    kind: 'Expression',
+    value,
+  }),
+  Assignment: ({ left, right }: { left: any; right: any }) => ({
+    concept: 'Assignment',
+    name: '',
+    label: '赋值',
+    kind: 'Statement',
+    left,
+    right,
+  }),
+  IfStatement: ({ test, consequent, alternate }: { test: any; consequent: any[]; alternate: any[] }) => ({
+    concept: 'IfStatement',
+    name: '',
+    kind: 'Statement',
+    test,
+    consequent,
+    alternate,
+  }),
 
-    // 二元
-    BinaryExpression: ({ operator, left, label = '算术运算', right }: { operator: string; left?: any; right?: any; label?: string }) => ({
-        concept: 'BinaryExpression',
-        name: '',
-        kind: 'Expression',
-        label,
-        operator,
-        left,
-        right,
-    }),
+  // 二元
+  BinaryExpression: ({ operator, left, label = '算术运算', right }: { operator: string; left?: any; right?: any; label?: string }) => ({
+    concept: 'BinaryExpression',
+    name: '',
+    kind: 'Expression',
+    label,
+    operator,
+    left,
+    right,
+  }),
 };
 
 export const NaslQueryExpression = {
-    QueryFieldExpression: ({ label, isDotStar, entityAsName, propertyName }: { label: string; isDotStar: boolean; entityAsName: string; propertyName?: string }) => ({
-        concept: 'QueryFieldExpression',
-        name: '',
-        label,
-        kind: 'Expression',
-        isDotStar,
-        entityAsName,
-        propertyName,
-    }),
-    QueryFromExpression: ({ entityNamespace, entityName, joinParts }: { entityNamespace: string; entityName: string; joinParts: any[] }) => ({
-        concept: 'QueryFromExpression',
-        name: '',
-        kind: 'Expression',
-        entityNamespace,
-        entityName,
-        joinParts,
-    }),
-    QueryJoinExpression: ({
-        label,
-        entityNamespace,
-        entityName,
-        joinType,
-        onExpressions,
-        joinParts,
-    }: {
-        label?: string;
-        entityNamespace: string;
-        entityName: string;
-        joinType: string;
-        onExpressions: any[];
-        joinParts: any[];
-    }) => ({
-        concept: 'QueryJoinExpression',
-        label,
-        name: '',
-        kind: 'Expression',
-        entityNamespace,
-        entityName,
-        joinType,
-        onExpressions,
-        joinParts,
-    }),
-    QuerySelectExpression: ({ label, distinct, star, selectElements }: { label?: string; distinct?: boolean; star?: boolean; selectElements: any[] }) => ({
-        concept: 'QuerySelectExpression',
-        name: '',
-        kind: 'Expression',
-        label,
-        distinct,
-        star,
-        selectElements,
-    }),
-    QueryOrderByExpression: ({ label, order, orderElement }: { label?: string; order: any; orderElement: any }) => ({
-        concept: 'QueryOrderByExpression',
-        label,
-        order,
-        orderElement,
-    }),
-    QueryLimitExpression: ({ label, pageElement, pageSizeElement }: { label?: string; pageElement: any; pageSizeElement: any }) => ({
-        concept: 'QueryLimitExpression',
-        name: '',
-        kind: 'Expression',
-        label,
-        pageElement,
-        pageSizeElement,
-    }),
-    CallQueryComponent: ({
-        label,
-        typeAnnotation,
-        select,
-        from,
-        where,
-        limit,
-        groupBy,
-        having,
-        orderBy,
-        logicName,
-        structureName,
-        ideVersion,
-    }: {
-        label?: string;
-        typeAnnotation: any;
-        select: any;
-        from: any;
-        where: any;
-        limit: any;
-        groupBy: any[];
-        having: any;
-        orderBy: any[];
-        logicName: string;
-        structureName: string;
-        ideVersion: string
-    }) => ({
-        concept: 'CallQueryComponent',
-        name: '',
-        label,
-        kind: 'Statement',
-        typeAnnotation,
-        select,
-        from,
-        where,
-        limit,
-        groupBy,
-        having,
-        orderBy,
-        logicName,
-        structureName,
-        ideVersion,
-    }),
+  QueryFieldExpression: ({
+    label,
+    isDotStar,
+    entityAsName,
+    propertyName,
+  }: {
+    label: string;
+    isDotStar: boolean;
+    entityAsName: string;
+    propertyName?: string;
+  }) => ({
+    concept: 'QueryFieldExpression',
+    name: '',
+    label,
+    kind: 'Expression',
+    isDotStar,
+    entityAsName,
+    propertyName,
+  }),
+  QueryFromExpression: ({ entityNamespace, entityName, joinParts }: { entityNamespace: string; entityName: string; joinParts: any[] }) => ({
+    concept: 'QueryFromExpression',
+    name: '',
+    kind: 'Expression',
+    entityNamespace,
+    entityName,
+    joinParts,
+  }),
+  QueryJoinExpression: ({
+    label,
+    entityNamespace,
+    entityName,
+    joinType,
+    onExpressions,
+    joinParts,
+  }: {
+    label?: string;
+    entityNamespace: string;
+    entityName: string;
+    joinType: string;
+    onExpressions: any[];
+    joinParts: any[];
+  }) => ({
+    concept: 'QueryJoinExpression',
+    label,
+    name: '',
+    kind: 'Expression',
+    entityNamespace,
+    entityName,
+    joinType,
+    onExpressions,
+    joinParts,
+  }),
+  QuerySelectExpression: ({
+    label,
+    distinct,
+    star,
+    selectElements,
+  }: {
+    label?: string;
+    distinct?: boolean;
+    star?: boolean;
+    selectElements: any[];
+  }) => ({
+    concept: 'QuerySelectExpression',
+    name: '',
+    kind: 'Expression',
+    label,
+    distinct,
+    star,
+    selectElements,
+  }),
+  QueryOrderByExpression: ({ label, order, orderElement }: { label?: string; order: any; orderElement: any }) => ({
+    concept: 'QueryOrderByExpression',
+    label,
+    order,
+    orderElement,
+  }),
+  QueryLimitExpression: ({ label, pageElement, pageSizeElement }: { label?: string; pageElement: any; pageSizeElement: any }) => ({
+    concept: 'QueryLimitExpression',
+    name: '',
+    kind: 'Expression',
+    label,
+    pageElement,
+    pageSizeElement,
+  }),
+  CallQueryComponent: ({
+    label,
+    typeAnnotation,
+    select,
+    from,
+    where,
+    limit,
+    groupBy,
+    having,
+    orderBy,
+    logicName,
+    structureName,
+    ideVersion,
+  }: {
+    label?: string;
+    typeAnnotation: any;
+    select: any;
+    from: any;
+    where: any;
+    limit: any;
+    groupBy: any[];
+    having: any;
+    orderBy: any[];
+    logicName: string;
+    structureName: string;
+    ideVersion: string;
+  }) => ({
+    concept: 'CallQueryComponent',
+    name: '',
+    label,
+    kind: 'Statement',
+    typeAnnotation,
+    select,
+    from,
+    where,
+    limit,
+    groupBy,
+    having,
+    orderBy,
+    logicName,
+    structureName,
+    ideVersion,
+  }),
 };
 
 export const NaslNode = {
-    Logic: ({
-        name,
-        params,
-        returns,
-        variables,
-        body,
-        description,
-        playground,
-    }: {
-        name: string;
-        params?: any[];
-        returns?: any[];
-        variables?: any[];
-        body?: any[];
-        description?: string;
-        playground?: any[];
-    }) => ({
-        concept: 'Logic',
-        name,
-        params,
-        returns,
-        variables,
-        body,
-        description,
-        playground,
-    }),
-    Structure: ({ name, properties, origin }: { name: string; properties?: any[], origin?: 'CallQueryComponent' }) => ({
-        concept: 'Structure',
-        name,
-        properties,
-        origin,
-    }),
-    StructureProperty: ({ name, typeAnnotation }: { name: string; typeAnnotation?: any }) => ({
-        concept: 'StructureProperty',
-        name,
-        typeAnnotation,
-    }),
-    Variable: ({ name, typeAnnotation }: { name: string; typeAnnotation?: any }) => ({
-        concept: 'Variable',
-        name,
-        typeAnnotation,
-    }),
-    Param: ({ name, typeAnnotation }: { name: string; typeAnnotation?: any }) => ({
-        concept: 'Param',
-        name,
-        typeAnnotation,
-    }),
-    Return: ({ name, typeAnnotation }: { name: string; typeAnnotation?: any }) => ({
-        concept: 'Return',
-        name,
-        typeAnnotation,
-    }),
+  Logic: ({
+    name,
+    params,
+    returns,
+    variables,
+    body,
+    description,
+    playground,
+  }: {
+    name: string;
+    params?: any[];
+    returns?: any[];
+    variables?: any[];
+    body?: any[];
+    description?: string;
+    playground?: any[];
+  }) => ({
+    concept: 'Logic',
+    name,
+    params,
+    returns,
+    variables,
+    body,
+    description,
+    playground,
+  }),
+  Structure: ({ name, properties, origin }: { name: string; properties?: any[]; origin?: 'CallQueryComponent' }) => ({
+    concept: 'Structure',
+    name,
+    properties,
+    origin,
+  }),
+  StructureProperty: ({ name, typeAnnotation }: { name: string; typeAnnotation?: any }) => ({
+    concept: 'StructureProperty',
+    name,
+    typeAnnotation,
+  }),
+  Variable: ({ name, typeAnnotation }: { name: string; typeAnnotation?: any }) => ({
+    concept: 'Variable',
+    name,
+    typeAnnotation,
+  }),
+  Param: ({ name, typeAnnotation }: { name: string; typeAnnotation?: any }) => ({
+    concept: 'Param',
+    name,
+    typeAnnotation,
+  }),
+  Return: ({ name, typeAnnotation }: { name: string; typeAnnotation?: any }) => ({
+    concept: 'Return',
+    name,
+    typeAnnotation,
+  }),
 };