@lcap/nasl 2.16.1 → 2.17.1

package/src/concepts/index__.ts

@@ -30,9 +30,11 @@ export * from './Variable__';
 export * from './Constant__';
 export * from './LogicItem__';
 export * from './Function__';
+export * from './AnonymousFunction__';
 export * from './Interface__';
 export * from './InterfaceParam__';
 export * from './Transactional__';
+export * from './ConstructArgument__';
 export * from './Start__';
 export * from './End__';
 export * from './IfStatement__';
@@ -41,6 +43,7 @@ export * from './SwitchCase__';
 export * from './ForEachStatement__';
 export * from './WhileStatement__';
 export * from './Assignment__';
+export * from './BatchAssignment__';
 export * from './Comment__';
 export * from './CallLogic__';
 export * from './CallFunction__';
@@ -50,12 +53,15 @@ export * from './ValidationRule__';
 export * from './Argument__';
 export * from './Anchor__';
 export * from './JSBlock__';
+export * from './Construct__';
 export * from './Identifier__';
 export * from './NullLiteral__';
 export * from './BooleanLiteral__';
 export * from './StringLiteral__';
 export * from './NumericLiteral__';
 export * from './BinaryExpression__';
+export * from './MatchCase__';
+export * from './Match__';
 export * from './UnaryExpression__';
 export * from './MemberExpression__';
 export * from './Unparsed__';
@@ -83,3 +89,5 @@ export * from './CompletionProperty__';
 export * from './UseComponent__';
 export * from './Point__';
 export * from './Rect__';
+export * from './SelectMembers__';
+export * from './AssignmentLine__';

package/src/server/createUiTs.ts

@@ -114,10 +114,10 @@ export default function formatUiTs(allComponent: any) {
             options?: {
               [propname: string]: any,
               bindAttr?: () => Array<any>,
-              slotDefault?: (scope: nasl.ui.ScopeOf<T>) => Array<any>,
+              slotDefault?: (current: nasl.ui.Current<T>) => Array<any>,
         }){super()}
     }
-    export type GetItemTypeFromDataSource<T> = T extends nasl.collection.PageOf<infer U> | nasl.collection.List<infer U> | ((...args: any) => nasl.collection.PageOf<infer U> | nasl.collection.List<infer U>) ? U : never;
+    export type GetItemTypeFromDataSource<T> = T extends { list: nasl.collection.List<infer U> } | nasl.collection.List<infer U> | ((...args: any) => { list: nasl.collection.List<infer U> } | nasl.collection.List<infer U>) ? U : never;
     \n`;
     for (const i in allComponent) {
         const item = allComponent[i];
@@ -148,10 +148,10 @@ export default function formatUiTs(allComponent: any) {
                         value += `slotDefault?: () => ${str} Array<any>,\n`;
                     } else if (slot.slotProps) {
                         const typeAnnotation = new TypeAnnotation(slot.slotProps.typeAnnotation);
-                        value += `slotDefault?: (scope: ${typeAnnotation.typeKey}) => Array<any>,\n`;
+                        value += `slotDefault?: (current: ${typeAnnotation.typeKey}) => Array<any>,\n`;
                     } else if (item.attrs && item.attrs.find((item: any) => item.name === 'data-source')) {
                         // 没有插槽的
-                        value += `slotDefault?: (scope: nasl.ui.ScopeOf<T>)=> Array<any>,\n`;
+                        value += `slotDefault?: (current: nasl.ui.Current<T>)=> Array<any>,\n`;
                     } else {
                         // 没有插槽的
                         value += `slotDefault?: ()=> Array<any>,\n`;
@@ -159,16 +159,16 @@ export default function formatUiTs(allComponent: any) {
                 } else if (!slot.advanced) {
                     if (slot.slotProps) {
                         const typeAnnotation = new TypeAnnotation(slot.slotProps.typeAnnotation);
-                        value += `${slotName}?: (scope: ${typeAnnotation.typeKey}) => Array<any>,\n`;
+                        value += `${slotName}?: (current: ${typeAnnotation.typeKey}) => Array<any>,\n`;
                     } else {
                         value += `${slotName}?: ()=> Array<any>,\n`;
                     }
                     // if (Array.isArray(slot.props) && slot.props.length === 5) {
                     //     value += indent(3);
-                    //     value += slotName + `?: (scope: nasl.ui.ScopeOf<T>) => Array<any>,\n`;
+                    //     value += slotName + `?: (current: nasl.ui.Current<T>) => Array<any>,\n`;
                     // } else if (Array.isArray(slot.props)) {
                     //     value += indent(3);
-                    //     value += slotName + `?: (scope: {`;
+                    //     value += slotName + `?: (current: {`;
                     //     slot.props.forEach((prop: any) => {
                     //         const type = prop.type || '';
                     //         value += `${prop.name}: ${type}, `;
@@ -176,8 +176,8 @@ export default function formatUiTs(allComponent: any) {
                     //     value += `}) => Array<any>,\n`;
                     // } else {
                     //     value += indent(3);
-                    //     // 这里应该是有类型区分的，但是目前scope只有一个 类型就先都是这个
-                    //     value += slotName + `?: (scope: nasl.ui.ScopeOf<T>) => Array<any>,\n`;
+                    //     // 这里应该是有类型区分的，但是目前 current 只有一个 类型就先都是这个
+                    //     value += slotName + `?: (current: nasl.ui.Current<T>) => Array<any>,\n`;
                     // }
                 }
             });

package/src/server/extendBaseNode.ts

@@ -67,8 +67,6 @@ BaseNode.prototype.findUsage = function findUsage() {
     }
 };
 BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
-    console.log(newValue);
-    console.log(this);
     try {
         /**
          * 查找这个节点是不是有依赖
@@ -343,3 +341,16 @@ BaseNode.prototype.addParamsPrepare = async function addParamsPrepare(needAdd =
     }
 };
 
+/**
+ * 在原型上增加方法来调用
+ */
+BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnotation() {
+    try {
+        /**
+         * 查找这个节点是不是有依赖
+         */
+        return naslServer.getCurrentTypeAnnotation(this);
+    } catch (err) {
+        console.log(err);
+    }
+};

package/src/server/formatTsUtils.ts

@@ -29,6 +29,79 @@ function formatTs2TypeString(displayParts: Array<{ text: string; kind: string }>
     });
     return str;
 }
+/**
+ * 解析 Completion 和 QuickInfo 的 displayString
+ * 生成 TypeAnnotation
+ * @param displayString
+ * @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' && Array.isArray(properties) && properties.length) {
+            // 自定义类型
+            const newProperties: StructureProperty[] = [];
+            properties.forEach((item) => {
+                if (!item?.name?.startsWith('__')) {
+                    const itemType = type2TypeAnnotation(item.typeInfo);
+                    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') {
+            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 && typeNamespace.startsWith('nasl.collection')) {
+            // nasl的泛型类型
+            typeAnnotation = TypeAnnotation.createGeneric(typeName, {
+                typeNamespace,
+            });
+        } else if (typeNamespace && typeNamespace.startsWith('nasl.')) {
+            // nasl的引用类型
+            typeAnnotation = TypeAnnotation.createReference(typeName, {
+                typeNamespace,
+            });
+        } else {
+            typeAnnotation = TypeAnnotation.createReference(typeName, {
+                typeNamespace,
+            });
+        }
+        // 如果有泛型处理泛型
+        if (Array.isArray(typeArguments)) {
+            typeAnnotation.typeArguments = [];
+            typeArguments.forEach((item: any) => {
+                const typeItem = type2TypeAnnotation(item);
+                if (typeItem) {
+                    typeAnnotation.typeArgumentsPush(typeItem);
+                }
+            });
+        }
+    } catch (err) {
+        console.log(err, type);
+    }
+    return typeAnnotation;
+}
+
 /**
  * 解析 Completion 和 QuickInfo 的 displayString
  * 生成 TypeAnnotation
@@ -132,6 +205,7 @@ function createType2Annotation(type: string, parentPrefix?: string): TypeAnnotat
 }
 export function getPlatformType(type: string): string {
     let tsType = '';
+
     if (type?.includes(': ')) {
         const lastIndexOf = type.lastIndexOf(': ');
         tsType = type.substring(lastIndexOf + 2, type.length);
@@ -186,8 +260,8 @@ export function nextFindTypeChild(typeKey: string, item: any, parent: any, node:
     // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
     const nodeMap = parent ? parent.nodeMap : new Map();
     item.nodeMap = nodeMap;
-    const newType = findNode(typeKey, node) as Structure;
-    if (newType?.properties && newType.properties.length) {
+    const newType = findNode(typeKey, node);
+    if ((newType as Structure)?.properties && (newType as Structure).properties.length) {
         // 处理泛型的内容要取到值
         const StructureJson = newType.toJSON();
         const newStructure = new Structure(StructureJson);
@@ -219,21 +293,242 @@ export function nextFindTypeChild(typeKey: string, item: any, parent: any, node:
     }
 }
 
+/**
+ * 获取scope下一级的展示
+ * @param type 返回的字符串如下展示
+ *  `nasl.ui.Current<{
+    __name: "AStructure_dc8bcbaf";
+    entity1: dataSources.defaultDS.entities.Entity1;
+    lCAPRolePerMapping: dataSources.defaultDS.entities.LCAPRolePerMapping;
+}>`
+ */
+function getAStructureScopeType(type: string, parent: any, node: BaseNode) {
+    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;
+                        }
+                        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, parentItem, node);
+                    }
+                    const completionProperty = new CompletionProperty(newItem);
+                    completionProperty.icon = 'refProperty';
+                    return completionProperty;
+                });
+                completionProperty.children = res;
+                return completionProperty;
+            } else {
+                return completionProperty;
+            }
+        });
+        parentItem.children = newChildren;
+    }
+    const completionProperty = new CompletionProperty(parentItem);
+
+    // 变量 param return 在这里添加图标
+    completionProperty.icon = getNodeiconFromLogic(completionProperty, node);
+    return completionProperty;
+}
+/**
+ * 获取对象类型的下一级展示
+ * @param type 返回的字符串如下展示
+ *  `{
+    __name: "AStructure_bf19c4d5";
+    list: nasl.collection.List<{
+        __name: "AStructure_dc8bcbaf";
+        entity1: app.dataSources.defaultDS.entities.Entity1;
+        lCAPRolePerMapping: app.dataSources.defaultDS.entities.LCAPRolePerMapping;
+    }>;
+    total: nasl.core.Integer;
+}`
+ */
+function getAStructureObjectStringType(type: string, parent: any, node: BaseNode) {
+    let newType = type.replaceAll(' ', '').replaceAll('\n', '').replace(/__name:"AStructure_\w{8}";/g, '');
+    newType = newType.substring(1, newType.length - 1);
+    if (!parent.keyMap) {
+        parent.keyMap = new Map();
+    }
+    if (/\{([^()]+)\}/.exec(newType)) {
+        newType = newType.replace(/\{([^()]+)\}/, '');
+    }
+    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;
+    // 如果没有父节点就是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, parentItem, node);
+        }
+        const completionProperty = new CompletionProperty(newItem);
+
+        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, parent: any, node: BaseNode) {
+    // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
+    const nodeMap = parent.nodeMap || new Map();
+    item.nodeMap = nodeMap; // 有一个当前树分支的全部节点的node map，用作防止数据无限递归，只保留3层
+
+    const keyMap = parent.keyMap;
+    item.keyMap = keyMap;
+    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 index = nodeMap.get(newType) || 0;
+        if (index) {
+            nodeMap.set(newType, index + 1);
+        } else {
+            nodeMap.set(newType, 1);
+        }
+        // 最多保留3层
+        if (index < 3) {
+            return formatVariableData(newStructure.properties, node, item);
+        }
+    }
+}
+
 // 格式化变量数据
 export function formatVariableData(data: unknown | variableItem[], node: BaseNode, parent?: any) {
     if (Array.isArray(data)) {
         let result = data.map((item) => {
             item.children = [];
-            // 当前结构的typeAnnotation
-            let typeAnnotation;
             // 当前的类型如 app.entitys.entity1 nasl.core.String
             let typeKey: string;
-
             if (item.completionDetail) {
-                // 当前节点的完整类型，主要是在有T的内容使用 nasl.list<Enum1> 内部匹配内容给里面子集的T赋值类型
-                const currentType: string = formatTs2TypeString(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
-                typeAnnotation = displayString2TypeAnnotation(currentType);
-                typeKey = getPlatformType(currentType);
+                if (item.completionDetail.nodeType) {
+                    const typeAnnotation = type2TypeAnnotation(item.completionDetail.nodeType);
+                    typeKey = typeAnnotation?.typeKey;
+                } 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);
+                }
             } else if (item instanceof StructureProperty) {
                 typeKey = item?.typeAnnotation?.typeKey;
             }
@@ -243,8 +538,6 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                 item.value = parent ? `${parent.value}.${item.text}` : item.text;
                 item.name = item.text;
                 const identifier = new Identifier({ name: item.name });
-                // 携带上当前的类型
-                identifier.typeAnnotation = typeAnnotation;
                 item.expression = identifier;
             } else {
                 item.value = `${parent.value}.${item.name}`;
@@ -252,15 +545,13 @@ export function formatVariableData(data: unknown | variableItem[], node: BaseNod
                     object: parent.expression,
                     property: new Identifier({ name: item.name }),
                 });
-                // 携带上当前的类型
-                memberExpression.typeAnnotation = typeAnnotation;
                 item.expression = memberExpression;
             }
             // 如果有类型而且类型不是没有子集的类型，就把他当前的类型拿到
             if (typeKey && !isNoChildType(typeKey)) {
                 nextFindTypeChild(typeKey, item, parent, node);
             }
-            // 如果是从实体或者数据结构取的字段，就需要重置一下类型
+            // 如果是从实体或者数据结构取的属性，就需要重置一下类型
             item.concept = 'CompletionProperty';
             const completionProperty = new CompletionProperty(item);
             if (!parent) {
@@ -326,7 +617,7 @@ function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
         const list = [...params, ...variables];
         list.forEach((item) => {
             const findIndex = result.findIndex((findItem) => findItem.name === item.name);
-            if (findIndex === 0 || findIndex) {
+            if (findIndex !== -1) {
                 newResult.push(result[findIndex]);
                 result.splice(findIndex, 1);
             }
@@ -337,7 +628,7 @@ function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
         const list = [...params, ...returns, ...variables];
         list.forEach((item) => {
             const findIndex = result.findIndex((findItem) => findItem.name === item.name);
-            if (findIndex === 0 || findIndex) {
+            if (findIndex !== -1) {
                 newResult.push(result[findIndex]);
                 result.splice(findIndex, 1);
             }

package/src/server/getLogics.ts

@@ -146,7 +146,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
         });
 
         if (node.view && node.view.logics) {
-            // 获取组件逻辑, 获取传入字段的子集
+            // 获取组件逻辑, 获取传入属性的子集
             const elements: Array<ViewElement> = [];
             node.view.elementsMethods(node.view.elements, elements);
             const viewElements: Array<Namespace> = [];
@@ -232,7 +232,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                         name: 'category',
                         path: `configuration`,
                         title: '配置',
-                        logics: stdlibNamespace.findChild('configuration').logics,
+                        logics: stdlibNamespace.findChild('configuration').logics.filter((item) => item.name !== 'getCurrentIp'),
                         expanded: false,
                     }),
                     new Namespace({
@@ -252,7 +252,6 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             systemTree.children.forEach((child) => (child.expanded = false));
             result.push(systemTree);
         }
-        console.log(result);
         return result;
     }
 }

package/src/server/getMemberIdentifier.ts

@@ -3,7 +3,7 @@ import naslServer from './naslServer';
 import { formatVariableData, formatFrontEndVariables } from './formatTsUtils';
 
 // 简单实现一版本的格式化nums
-function formatEnums(enums: Array<Enum>) {
+export function formatEnums(enums: Array<Enum>) {
     const result = enums.map((item) => {
         const namespace = item.getNamespace();
         const newItem: any = {
@@ -225,7 +225,17 @@ export function getEnumsIdentifier(node: BaseNode): CompletionProperty[] {
     const app = node.rootNode as App;
     const enums = app?.enums;
     const newEnums = enums ? formatEnums(enums) : [];
-    return newEnums;
+    // 添加依赖库的枚举选择
+    const modules = app?.dependencies?.filter((module) => module.type === 'extension') || [];
+    const extensionEnums: any[] = [];
+    modules.forEach((module) => {
+        extensionEnums.push({
+            name: module.name,
+            concept: 'Module',
+            children: formatEnums(module.enums),
+        });
+    });
+    return newEnums.concat(extensionEnums);
 }
 
 // 获取变量

package/src/server/getProcesses.ts

@@ -1,4 +1,4 @@
-import Constant from '@nasl/concepts/Constant__';
+import Constant from '../concepts/Constant__';
 import { CompletionProperty, Process, ProcessElement, Namespace, Logic, TypeAnnotation, Return, Variable, StructureProperty, Param, Identifier, MemberExpression, LogicItem, App, BaseNode, Structure, Entity, EntityProperty } from '..';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
 import { isNoChildType, nextFindTypeChild } from './formatTsUtils';
@@ -202,7 +202,6 @@ export function syncMemberExpression(elem: ProcessElement | Process, callback: (
         if (el.type === 'ExclusiveGateway' || el.type === 'AutoTask') {
             travelDown(el.logic, (node) => {
                 if (node instanceof MemberExpression) {
-                    console.log('ExclusiveGateway', node.getValue());
                     callback(node);
                 }
             });
@@ -276,7 +275,7 @@ export function genCompletionProperty(prefix: string[] = []):(v: Variable | Para
         if (t.length) {
             prevalue = `${t.join('.')}.`;
         }
-        const noChildType = isNoChildType(v.typeAnnotation.typeKey);
+        const noChildType = v.typeAnnotation ? isNoChildType(v.typeAnnotation.typeKey) : true;
         const item = {
             expression: m || p,
             name: v.name,