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

package/out/templator/utils.js

@@ -1,459 +1,459 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NaslNode = exports.NaslQueryExpression = exports.NaslLogicItem = exports.NaslCollectionTypeAnnotation = exports.NaslTypeAnnotation = exports.NaslUITypeAnnotation = exports.NaslCoreTypeAnnotation = exports.genUniqueQueryNameGroup = exports.genMemberExpression = exports.genLogicParam = exports.getFirstDisplayedProperty = exports.getParamFromLogic = exports.getExpression = exports.filterProperty = void 0;
-const __1 = require("..");
-const filterProperty = (key) => (property) => {
-    if (property.display) {
-        return property.display[key];
-    }
-    return !['id', 'createdTime', 'updatedTime'].includes(property.name);
-};
-exports.filterProperty = filterProperty;
-/**
- * 生成表达式的代码
- * @param property 实体属性
- * @param expression 表达式
- */
-function getExpression(property, 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 || "''"}`;
-}
-exports.getExpression = getExpression;
-/**
- * 从 Logic 中获取变量
- * @param resolver
- * @param paramName
- */
-function getParamFromLogic(logic, paramName) {
-    const { params } = logic;
-    return params.find((item) => item.name === paramName);
-}
-exports.getParamFromLogic = getParamFromLogic;
-function getFirstDisplayedProperty(entity) {
-    let property = entity.properties.find((property) => !property.readonly);
-    if (!property)
-        property = entity.properties[0];
-    return property;
-}
-exports.getFirstDisplayedProperty = getFirstDisplayedProperty;
-function genArgumentMemberExpression(arr) {
-    let expressionNode;
-    const propertyName = arr.pop();
-    if (arr.length >= 1) {
-        expressionNode = exports.NaslLogicItem.MemberExpression({
-            object: genArgumentMemberExpression(arr),
-            property: exports.NaslLogicItem.Identifier({
-                name: propertyName,
-            }),
-        });
-    }
-    else {
-        return exports.NaslLogicItem.Identifier({
-            name: propertyName,
-        });
-    }
-    return expressionNode;
-}
-/**
- * 生成逻辑 Param
- * @param paramIdOrName 参数 id 或引用名称
- * @param expression 表达式
- * @param schemaChildren 数据结构
- */
-function genLogicParam(paramIdOrName, expression) {
-    return exports.NaslLogicItem.Argument({
-        keyword: paramIdOrName,
-        expression: genArgumentMemberExpression(expression.split('.')),
-    });
-}
-exports.genLogicParam = genLogicParam;
-/**
- * 生成接口 Param
- * @param paramIdOrName 参数 id 或引用名称
- * @param expression 表达式
- * @param schemaChildren 数据结构
- */
-function genMemberExpression(expression, schemaRefs = []) {
-    const arr = expression.split('.');
-    let expressionNode;
-    arr.forEach((name, index) => {
-        const currentNode = exports.NaslLogicItem.Identifier({
-            name,
-        });
-        if (expressionNode) {
-            expressionNode = exports.NaslLogicItem.MemberExpression({
-                object: expressionNode,
-                property: exports.NaslLogicItem.Identifier({
-                    name,
-                }),
-            });
-        }
-        else {
-            expressionNode = currentNode;
-        }
-    });
-    return expressionNode;
-}
-exports.genMemberExpression = genMemberExpression;
-function capFirstLetter(word) {
-    if (!word)
-        return word;
-    return word[0].toUpperCase() + word.slice(1);
-}
-/**
- * 生成数据查询唯一的命名组
- * @param viewName 页面名称
- * @param componentName 组件名称
- * @param suffix 其它后缀，比如实体名等等
- * @param defaultInView 是否在页面逻辑中用 load 简写
- */
-function genUniqueQueryNameGroup(scope, view, componentName = '', defaultInView = true, suffix = '') {
-    const result = {};
-    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(__1.utils.firstUpperCase(`${result.logic}Structure`));
-    return result;
-}
-exports.genUniqueQueryNameGroup = genUniqueQueryNameGroup;
-function genNaslCoreTypeAnnotation(typeName, text = '') {
-    return {
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'primitive',
-        typeNamespace: 'nasl.core',
-        typeName,
-        text,
-    };
-}
-function genNaslUITypeAnnotation(typeName) {
-    return {
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'reference',
-        typeNamespace: 'nasl.ui',
-        typeName,
-    };
-}
-function genNaslCollectionTypeAnnotation(typeName) {
-    return (typeArguments) => ({
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'generic',
-        typeNamespace: 'nasl.collection',
-        typeName,
-        typeArguments,
-    });
-}
-function genNaslUIGenericTypeAnnotation(typeName) {
-    return (typeArguments) => ({
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'generic',
-        typeNamespace: 'nasl.ui',
-        typeName,
-        typeArguments,
-    });
-}
-exports.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'),
-};
-exports.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'),
-    Current: genNaslUIGenericTypeAnnotation('Current'),
-    DragAndDropEvent: genNaslUIGenericTypeAnnotation('DragAndDropEvent'),
-    ExpandEvent: genNaslUIGenericTypeAnnotation('ExpandEvent'),
-    ScrollEvent: genNaslUIGenericTypeAnnotation('ScrollEvent'),
-};
-exports.NaslTypeAnnotation = {
-    Reference: ({ typeNamespace, typeName }) => ({
-        concept: 'TypeAnnotation',
-        name: '',
-        typeKind: 'reference',
-        typeNamespace,
-        typeName,
-    }),
-    AnonymousStructure: (properties) => ({
-        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',
-                },
-            },
-        ],
-    }),
-};
-exports.NaslCollectionTypeAnnotation = {
-    List: genNaslCollectionTypeAnnotation('List'),
-    PageOf: genNaslCollectionTypeAnnotation('PageOf'),
-};
-exports.NaslLogicItem = {
-    // 开始
-    Start: {
-        concept: 'Start',
-        name: '',
-        label: '开始',
-        kind: 'Statement',
-    },
-    // 结束
-    End: {
-        concept: 'End',
-        name: '',
-        label: '结束',
-        kind: 'Statement',
-    },
-    // 调用逻辑
-    CallLogic: ({ calleeNamespace, calleeName, label = '调用逻辑', shortcut = false, arguments: args, }) => ({
-        concept: 'CallLogic',
-        name: '',
-        label,
-        kind: 'Statement',
-        shortcut,
-        calleeNamespace,
-        calleeName,
-        arguments: args,
-    }),
-    // 内置函数
-    CallFunction: ({ calleeNamespace = 'nasl.util', calleeName, label = '内置函数', shortcut = false, arguments: args = [], typeArguments: typeArgs = [], }) => ({
-        concept: 'CallFunction',
-        name: '',
-        label: '调用逻辑',
-        kind: 'Expression',
-        calleeNamespace,
-        calleeName,
-        arguments: args,
-        typeArguments: typeArgs,
-    }),
-    // 参数
-    Argument: ({ keyword, expression }) => ({
-        concept: 'Argument',
-        name: '',
-        kind: 'Statement',
-        keyword,
-        expression,
-    }),
-    // 成员表达式
-    MemberExpression: ({ object, property }) => ({
-        concept: 'MemberExpression',
-        name: '',
-        kind: 'Expression',
-        object,
-        property,
-    }),
-    // 变量
-    Identifier: ({ name }) => ({
-        concept: 'Identifier',
-        kind: 'Expression',
-        name,
-    }),
-    // 字面量
-    StringLiteral: ({ value }) => ({
-        concept: 'StringLiteral',
-        name: '',
-        kind: 'Expression',
-        value,
-    }),
-    Assignment: ({ left, right }) => ({
-        concept: 'Assignment',
-        name: '',
-        label: '赋值',
-        kind: 'Statement',
-        left,
-        right,
-    }),
-    IfStatement: ({ test, consequent, alternate }) => ({
-        concept: 'IfStatement',
-        name: '',
-        kind: 'Statement',
-        test,
-        consequent,
-        alternate,
-    }),
-    // 二元
-    BinaryExpression: ({ operator, left, label = '算术运算', right }) => ({
-        concept: 'BinaryExpression',
-        name: '',
-        kind: 'Expression',
-        label,
-        operator,
-        left,
-        right,
-    }),
-};
-exports.NaslQueryExpression = {
-    QueryFieldExpression: ({ label, isDotStar, entityAsName, propertyName, }) => ({
-        concept: 'QueryFieldExpression',
-        name: '',
-        label,
-        kind: 'Expression',
-        isDotStar,
-        entityAsName,
-        propertyName,
-    }),
-    QueryFromExpression: ({ entityNamespace, entityName, joinParts }) => ({
-        concept: 'QueryFromExpression',
-        name: '',
-        kind: 'Expression',
-        entityNamespace,
-        entityName,
-        joinParts,
-    }),
-    QueryJoinExpression: ({ label, entityNamespace, entityName, joinType, onExpressions, joinParts, }) => ({
-        concept: 'QueryJoinExpression',
-        label,
-        name: '',
-        kind: 'Expression',
-        entityNamespace,
-        entityName,
-        joinType,
-        onExpressions,
-        joinParts,
-    }),
-    QuerySelectExpression: ({ label, distinct, star, selectElements, }) => ({
-        concept: 'QuerySelectExpression',
-        name: '',
-        kind: 'Expression',
-        label,
-        distinct,
-        star,
-        selectElements,
-    }),
-    QueryOrderByExpression: ({ label, order, orderElement }) => ({
-        concept: 'QueryOrderByExpression',
-        label,
-        order,
-        orderElement,
-    }),
-    QueryLimitExpression: ({ label, pageElement, pageSizeElement }) => ({
-        concept: 'QueryLimitExpression',
-        name: '',
-        kind: 'Expression',
-        label,
-        pageElement,
-        pageSizeElement,
-    }),
-    CallQueryComponent: ({ label, typeAnnotation, select, from, where, limit, groupBy, having, orderBy, logicName, structureName, ideVersion, }) => ({
-        concept: 'CallQueryComponent',
-        name: '',
-        label,
-        kind: 'Statement',
-        typeAnnotation,
-        select,
-        from,
-        where,
-        limit,
-        groupBy,
-        having,
-        orderBy,
-        logicName,
-        structureName,
-        ideVersion,
-    }),
-};
-exports.NaslNode = {
-    Logic: ({ name, params, returns, variables, body, description, playground, }) => ({
-        concept: 'Logic',
-        name,
-        params,
-        returns,
-        variables,
-        body,
-        description,
-        playground,
-    }),
-    Structure: ({ name, properties, origin }) => ({
-        concept: 'Structure',
-        name,
-        properties,
-        origin,
-    }),
-    StructureProperty: ({ name, typeAnnotation }) => ({
-        concept: 'StructureProperty',
-        name,
-        typeAnnotation,
-    }),
-    Variable: ({ name, typeAnnotation }) => ({
-        concept: 'Variable',
-        name,
-        typeAnnotation,
-    }),
-    Param: ({ name, typeAnnotation }) => ({
-        concept: 'Param',
-        name,
-        typeAnnotation,
-    }),
-    Return: ({ name, typeAnnotation }) => ({
-        concept: 'Return',
-        name,
-        typeAnnotation,
-    }),
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NaslNode = exports.NaslQueryExpression = exports.NaslLogicItem = exports.NaslCollectionTypeAnnotation = exports.NaslTypeAnnotation = exports.NaslUITypeAnnotation = exports.NaslCoreTypeAnnotation = exports.genUniqueQueryNameGroup = exports.genMemberExpression = exports.genLogicParam = exports.getFirstDisplayedProperty = exports.getParamFromLogic = exports.getExpression = exports.filterProperty = void 0;
+const __1 = require("..");
+const filterProperty = (key) => (property) => {
+    if (property.display) {
+        return property.display[key];
+    }
+    return !['id', 'createdTime', 'updatedTime'].includes(property.name);
+};
+exports.filterProperty = filterProperty;
+/**
+ * 生成表达式的代码
+ * @param property 实体属性
+ * @param expression 表达式
+ */
+function getExpression(property, 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 || "''"}`;
+}
+exports.getExpression = getExpression;
+/**
+ * 从 Logic 中获取变量
+ * @param resolver
+ * @param paramName
+ */
+function getParamFromLogic(logic, paramName) {
+    const { params } = logic;
+    return params.find((item) => item.name === paramName);
+}
+exports.getParamFromLogic = getParamFromLogic;
+function getFirstDisplayedProperty(entity) {
+    let property = entity.properties.find((property) => !property.readonly);
+    if (!property)
+        property = entity.properties[0];
+    return property;
+}
+exports.getFirstDisplayedProperty = getFirstDisplayedProperty;
+function genArgumentMemberExpression(arr) {
+    let expressionNode;
+    const propertyName = arr.pop();
+    if (arr.length >= 1) {
+        expressionNode = exports.NaslLogicItem.MemberExpression({
+            object: genArgumentMemberExpression(arr),
+            property: exports.NaslLogicItem.Identifier({
+                name: propertyName,
+            }),
+        });
+    }
+    else {
+        return exports.NaslLogicItem.Identifier({
+            name: propertyName,
+        });
+    }
+    return expressionNode;
+}
+/**
+ * 生成逻辑 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+function genLogicParam(paramIdOrName, expression) {
+    return exports.NaslLogicItem.Argument({
+        keyword: paramIdOrName,
+        expression: genArgumentMemberExpression(expression.split('.')),
+    });
+}
+exports.genLogicParam = genLogicParam;
+/**
+ * 生成接口 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+function genMemberExpression(expression, schemaRefs = []) {
+    const arr = expression.split('.');
+    let expressionNode;
+    arr.forEach((name, index) => {
+        const currentNode = exports.NaslLogicItem.Identifier({
+            name,
+        });
+        if (expressionNode) {
+            expressionNode = exports.NaslLogicItem.MemberExpression({
+                object: expressionNode,
+                property: exports.NaslLogicItem.Identifier({
+                    name,
+                }),
+            });
+        }
+        else {
+            expressionNode = currentNode;
+        }
+    });
+    return expressionNode;
+}
+exports.genMemberExpression = genMemberExpression;
+function capFirstLetter(word) {
+    if (!word)
+        return word;
+    return word[0].toUpperCase() + word.slice(1);
+}
+/**
+ * 生成数据查询唯一的命名组
+ * @param viewName 页面名称
+ * @param componentName 组件名称
+ * @param suffix 其它后缀，比如实体名等等
+ * @param defaultInView 是否在页面逻辑中用 load 简写
+ */
+function genUniqueQueryNameGroup(scope, view, componentName = '', defaultInView = true, suffix = '') {
+    const result = {};
+    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(__1.utils.firstUpperCase(`${result.logic}Structure`));
+    return result;
+}
+exports.genUniqueQueryNameGroup = genUniqueQueryNameGroup;
+function genNaslCoreTypeAnnotation(typeName, text = '') {
+    return {
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'primitive',
+        typeNamespace: 'nasl.core',
+        typeName,
+        text,
+    };
+}
+function genNaslUITypeAnnotation(typeName) {
+    return {
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'reference',
+        typeNamespace: 'nasl.ui',
+        typeName,
+    };
+}
+function genNaslCollectionTypeAnnotation(typeName) {
+    return (typeArguments) => ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'generic',
+        typeNamespace: 'nasl.collection',
+        typeName,
+        typeArguments,
+    });
+}
+function genNaslUIGenericTypeAnnotation(typeName) {
+    return (typeArguments) => ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'generic',
+        typeNamespace: 'nasl.ui',
+        typeName,
+        typeArguments,
+    });
+}
+exports.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'),
+};
+exports.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'),
+    Current: genNaslUIGenericTypeAnnotation('Current'),
+    DragAndDropEvent: genNaslUIGenericTypeAnnotation('DragAndDropEvent'),
+    ExpandEvent: genNaslUIGenericTypeAnnotation('ExpandEvent'),
+    ScrollEvent: genNaslUIGenericTypeAnnotation('ScrollEvent'),
+};
+exports.NaslTypeAnnotation = {
+    Reference: ({ typeNamespace, typeName }) => ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'reference',
+        typeNamespace,
+        typeName,
+    }),
+    AnonymousStructure: (properties) => ({
+        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',
+                },
+            },
+        ],
+    }),
+};
+exports.NaslCollectionTypeAnnotation = {
+    List: genNaslCollectionTypeAnnotation('List'),
+    PageOf: genNaslCollectionTypeAnnotation('PageOf'),
+};
+exports.NaslLogicItem = {
+    // 开始
+    Start: {
+        concept: 'Start',
+        name: '',
+        label: '开始',
+        kind: 'Statement',
+    },
+    // 结束
+    End: {
+        concept: 'End',
+        name: '',
+        label: '结束',
+        kind: 'Statement',
+    },
+    // 调用逻辑
+    CallLogic: ({ calleeNamespace, calleeName, label = '调用逻辑', shortcut = false, arguments: args, }) => ({
+        concept: 'CallLogic',
+        name: '',
+        label,
+        kind: 'Statement',
+        shortcut,
+        calleeNamespace,
+        calleeName,
+        arguments: args,
+    }),
+    // 内置函数
+    CallFunction: ({ calleeNamespace = 'nasl.util', calleeName, label = '内置函数', shortcut = false, arguments: args = [], typeArguments: typeArgs = [], }) => ({
+        concept: 'CallFunction',
+        name: '',
+        label: '调用逻辑',
+        kind: 'Expression',
+        calleeNamespace,
+        calleeName,
+        arguments: args,
+        typeArguments: typeArgs,
+    }),
+    // 参数
+    Argument: ({ keyword, expression }) => ({
+        concept: 'Argument',
+        name: '',
+        kind: 'Statement',
+        keyword,
+        expression,
+    }),
+    // 成员表达式
+    MemberExpression: ({ object, property }) => ({
+        concept: 'MemberExpression',
+        name: '',
+        kind: 'Expression',
+        object,
+        property,
+    }),
+    // 变量
+    Identifier: ({ name }) => ({
+        concept: 'Identifier',
+        kind: 'Expression',
+        name,
+    }),
+    // 字面量
+    StringLiteral: ({ value }) => ({
+        concept: 'StringLiteral',
+        name: '',
+        kind: 'Expression',
+        value,
+    }),
+    Assignment: ({ left, right }) => ({
+        concept: 'Assignment',
+        name: '',
+        label: '赋值',
+        kind: 'Statement',
+        left,
+        right,
+    }),
+    IfStatement: ({ test, consequent, alternate }) => ({
+        concept: 'IfStatement',
+        name: '',
+        kind: 'Statement',
+        test,
+        consequent,
+        alternate,
+    }),
+    // 二元
+    BinaryExpression: ({ operator, left, label = '算术运算', right }) => ({
+        concept: 'BinaryExpression',
+        name: '',
+        kind: 'Expression',
+        label,
+        operator,
+        left,
+        right,
+    }),
+};
+exports.NaslQueryExpression = {
+    QueryFieldExpression: ({ label, isDotStar, entityAsName, propertyName, }) => ({
+        concept: 'QueryFieldExpression',
+        name: '',
+        label,
+        kind: 'Expression',
+        isDotStar,
+        entityAsName,
+        propertyName,
+    }),
+    QueryFromExpression: ({ entityNamespace, entityName, joinParts }) => ({
+        concept: 'QueryFromExpression',
+        name: '',
+        kind: 'Expression',
+        entityNamespace,
+        entityName,
+        joinParts,
+    }),
+    QueryJoinExpression: ({ label, entityNamespace, entityName, joinType, onExpressions, joinParts, }) => ({
+        concept: 'QueryJoinExpression',
+        label,
+        name: '',
+        kind: 'Expression',
+        entityNamespace,
+        entityName,
+        joinType,
+        onExpressions,
+        joinParts,
+    }),
+    QuerySelectExpression: ({ label, distinct, star, selectElements, }) => ({
+        concept: 'QuerySelectExpression',
+        name: '',
+        kind: 'Expression',
+        label,
+        distinct,
+        star,
+        selectElements,
+    }),
+    QueryOrderByExpression: ({ label, order, orderElement }) => ({
+        concept: 'QueryOrderByExpression',
+        label,
+        order,
+        orderElement,
+    }),
+    QueryLimitExpression: ({ label, pageElement, pageSizeElement }) => ({
+        concept: 'QueryLimitExpression',
+        name: '',
+        kind: 'Expression',
+        label,
+        pageElement,
+        pageSizeElement,
+    }),
+    CallQueryComponent: ({ label, typeAnnotation, select, from, where, limit, groupBy, having, orderBy, logicName, structureName, ideVersion, }) => ({
+        concept: 'CallQueryComponent',
+        name: '',
+        label,
+        kind: 'Statement',
+        typeAnnotation,
+        select,
+        from,
+        where,
+        limit,
+        groupBy,
+        having,
+        orderBy,
+        logicName,
+        structureName,
+        ideVersion,
+    }),
+};
+exports.NaslNode = {
+    Logic: ({ name, params, returns, variables, body, description, playground, }) => ({
+        concept: 'Logic',
+        name,
+        params,
+        returns,
+        variables,
+        body,
+        description,
+        playground,
+    }),
+    Structure: ({ name, properties, origin }) => ({
+        concept: 'Structure',
+        name,
+        properties,
+        origin,
+    }),
+    StructureProperty: ({ name, typeAnnotation }) => ({
+        concept: 'StructureProperty',
+        name,
+        typeAnnotation,
+    }),
+    Variable: ({ name, typeAnnotation }) => ({
+        concept: 'Variable',
+        name,
+        typeAnnotation,
+    }),
+    Param: ({ name, typeAnnotation }) => ({
+        concept: 'Param',
+        name,
+        typeAnnotation,
+    }),
+    Return: ({ name, typeAnnotation }) => ({
+        concept: 'Return',
+        name,
+        typeAnnotation,
+    }),
+};
 //# sourceMappingURL=utils.js.map