@lcap/nasl 1.0.1 → 2.12.0-beta.1

package/src/concepts/Namespace__.ts

@@ -10,7 +10,6 @@ import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import Process from './Process__';
-import Entity from './Entity__';
 import Structure from './Structure__';
 import Enum from './Enum__';
 import Logic from './Logic__';
@@ -68,12 +67,6 @@ export class Namespace extends BaseNode {
     @property('Process')
     processes: Array<Process> = [];
 
-    /**
-     * 实体列表
-     */
-    @property('Entity')
-    entities: Array<Entity> = [];
-
     /**
      * 数据结构列表
      */
@@ -440,148 +433,6 @@ export class Namespace extends BaseNode {
     }
 
 
-    getEntityExistingNames(excludedList: Array<Entity> = []) {
-        const excludedSet = new Set(excludedList);
-        return (this.entities || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getEntityUniqueName(name = 'Entity1') {
-        return utils.unique(name, this.getEntityExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入实体
-    * @internal
-    * @param name 实体名称，如果不填会自动生成一个唯一名称
-    */
-    _insertEntityAt(name: string, index: number): Entity;
-
-    /**
-    * 插入实体
-    * @internal
-    * @param entityOptions 实体参数
-    */
-    _insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
-
-    /**
-    * 插入实体
-    * @internal
-    * @param entity 已有的实体实例
-    */
-    _insertEntityAt(entity: Entity, index: number): Entity;
-
-    _insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
-        const entityOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'entities' };
-        let entity: Entity;
-        if (!options) {
-            entity = Entity.from({
-                ...entityOptions,
-                name: this.getEntityUniqueName(),
-            }, this, 'entities');
-        } else if (typeof options === 'string') {
-            entity = Entity.from({
-                ...entityOptions,
-                name: options,
-            }, this, 'entities');
-        } else if (options instanceof Entity) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            entity = options;
-            Object.assign(entity, relationOptions);
-        } else {
-            entity = Entity.from({
-                ...entityOptions,
-                ...options,
-            }, this, 'entities');
-        }
-        this.entities.splice(index, 0, entity);
-        return entity;
-    }
-
-    /**
-     * 插入实体
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
-     */
-    insertEntityAt(name: string, index: number): Entity;
-
-    /**
-     * 插入实体
-     * @param entityOptions 实体参数
-     */
-    insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
-
-    /**
-     * 插入实体
-     * @param entity 已有的实体实例
-     */
-    insertEntityAt(entity: Entity, index: number): Entity;
-
-    insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
-        const node = this._insertEntityAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'entities',
-        });
-        return node;
-    }
-
-    /**
-     * 添加实体
-     * @internal
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
-     */
-    _addEntity(name?: string): Entity;
-
-    /**
-     * 添加实体
-     * @internal
-     * @param entityOptions 实体参数
-     */
-    _addEntity(entityOptions: Partial<Entity>): Entity;
-
-    /**
-     * 添加实体
-     * @internal
-     * @param entity 已有的实体实例
-     */
-    _addEntity(entity: Entity): Entity;
-
-    _addEntity(options?: string | Partial<Entity> | Entity) {
-        const index = 0;
-        return this._insertEntityAt(options as any, index);
-    }
-
-    /**
-     * 添加实体
-     * @internal
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
-     */
-    addEntity(name?: string): Entity;
-
-    /**
-     * 添加实体
-     * @param entityOptions 实体参数
-     */
-    addEntity(entityOptions: Partial<Entity>): Entity;
-
-    /**
-     * 添加实体
-     * @param entity 已有的实体实例
-     */
-    addEntity(entity: Entity): Entity;
-
-    addEntity(options?: string | Partial<Entity> | Entity) {
-        const node = this._addEntity(options as any);
-        const index = this.entities.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'entities',
-        });
-        return node;
-    }
-
-
     getStructureExistingNames(excludedList: Array<Structure> = []) {
         const excludedSet = new Set(excludedList);
         return (this.structures || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -1962,56 +1813,6 @@ export class Namespace extends BaseNode {
 
 
 
-    /**
-    * 删除实体
-    * @param name 实体名称
-    */
-    removeEntity(name: string): void;
-
-    /**
-     * 删除实体
-     * @param entity 已有的实体实例
-     */
-    removeEntity(entity: Entity): void;
-
-    removeEntity(options: string | Entity) {
-        let entity: Entity;
-        if (typeof options === 'string') {
-            entity = this.entities.find((item) => item.name === options);
-            if (!entity) {
-                throw new Error('找不到实体 ' + options);
-            }
-        } else {
-            entity = options;
-        }
-        return entity.delete();
-    }
-
-    __removeEntity(entity: Entity) {
-        const parentKey = entity.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: entity,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(entity);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === entity) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
     /**
     * 删除数据结构
     * @param name 数据结构名称
@@ -2465,10 +2266,6 @@ export class Namespace extends BaseNode {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
-    findEntityByName(name: string) {
-        return this.entities.find((entity) => entity.name === name);
-    }
-
     findEnumByName(name: string) {
         return this.enums.find((enumItem) => enumItem.name === name);
     }
@@ -2491,7 +2288,7 @@ export class Namespace extends BaseNode {
         if (this.path)
             return this.path;
         else if (this.parentNode && (this.parentNode as Namespace).getNamespace)
-            return `${(this.parentNode as Namespace).getNamespace()}.${this.name}`;
+            return `${(this.parentNode as Namespace).getNamespace()}`;
         else
             throw new Error('无法获取命名空间，请设置 parentNode 或临时的 path！');
     }

package/src/concepts/Param__.ts

@@ -7,6 +7,7 @@ import EntityProperty from './EntityProperty__';
 import Structure from './Structure__';
 import StructureProperty from './StructureProperty__';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
+import Function from './Function__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -237,7 +238,7 @@ export class Param extends BaseNode {
 
     @excludedInJSON()
     @property()
-    defaultExpression: LogicItem = undefined;
+    defaultExpression: LogicItem | Function = undefined;
     @excludedInJSON()
     @property()
     options: Array<{ text?: string; value: string }> = undefined;
@@ -305,7 +306,7 @@ export class Param extends BaseNode {
             typeAnnotation,
         };
         try {
-            this.completionChildren = this.getSelectRef();
+            this.completionChildren = this.getSelectRef(typeAnnotation);
         } catch (err) {
             this.completionChildren = [];
             console.log(err);
@@ -350,12 +351,12 @@ export class Param extends BaseNode {
     get isTreeLeaf() {
         return !this.hasChildren;
     }
-    getSelectRef() {
+    getSelectRef(newTypeAnnotation: TypeAnnotation) {
         try {
-            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
             let completionChildren;
             if (typeKind === 'reference') {
-                if (typeNamespace === 'nasl.ui') {
+                if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process') {
                     const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
                     const properties = node.properties || [];
                     completionChildren = properties;
@@ -367,11 +368,18 @@ export class Param extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
+                // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
+                // }
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                for (let i = 0; i < properties.length; i++) {
+                    const item = properties[i];
+                    if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                        properties[i].typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        properties[i].parentNode = this;
+                    }
                 }
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }

package/src/concepts/ProcessElement__.ts

@@ -1,5 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
-import { constantToParam, genUserTaskLogic, returnToParam, getPreviousTask, syncMemberExpression } from '../server/getProcesses';
+import { constantToParam, genUserTaskLogic, returnToParam, getPreviousTask, syncMemberExpression, getFlowAfterElements, isFromStartNode, getFlowBeforeElements } from '../server/getProcesses';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1327,12 +1327,12 @@ export class ProcessElement extends BaseNode {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         // this.syncLogic();
-        const tab0 = indent(state.tabSize);
-        const tab1 = indent(state.tabSize + 1);
-        const tab3 = indent(state.tabSize + 2);
-        const tab4 = indent(state.tabSize + 3);
-        const tab5 = indent(state.tabSize + 4);
-        const tab6 = indent(state.tabSize + 5);
+        const tab0 = indent((state?.tabSize || 0));
+        const tab1 = indent((state?.tabSize || 0) + 1);
+        const tab3 = indent((state?.tabSize || 0) + 2);
+        const tab4 = indent((state?.tabSize || 0) + 3);
+        const tab5 = indent((state?.tabSize || 0) + 4);
+        const tab6 = indent((state?.tabSize || 0) + 5);
         let code = `${this.name}: {\n`;
         this.variables.forEach((property) => {
             code += `${tab1}`;
@@ -1346,9 +1346,11 @@ export class ProcessElement extends BaseNode {
             code += `${tab1}`;
             code += `${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
         });
-
+        const afterLinks = getFlowAfterElements(this);
+        const beforeLinks = getFlowBeforeElements(this);
         if (this.type === 'UserTask'
-            || this.type === 'ExclusiveGateway') {
+            || this.type === 'ExclusiveGateway'
+            || this.type === 'AutoTask') {
             const prevTasks = getPreviousTask(this);
             let prevCode = `${tab3}const ${this.process.name} = {\n`;
             const processName = this.process.name;
@@ -1372,24 +1374,49 @@ export class ProcessElement extends BaseNode {
                 code += `${tab1}logics: {\n`;
                 this.bindAttrs.forEach((attr) => {
                     if (attr.name === 'destination') {
-                        code += `${attr.destination.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode)},\n`;
+                        code += `${attr.destination.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }), prevCode)},\n`;
+                    }
+                    if (attr.name === 'assignee') {
+                        code += `assignee: function(): string[] {\n`
+                        code += `${attr.assignee.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode)}\n`;
+                        code += `},\n`;
                     }
                 });
                 const logic = genUserTaskLogic(this);
                 // sourceMap 映射
                 logic.parentNode = this.process;
 
-                code += logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }));
+                code += logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }));
                 code += ',\n';
-                code += `${tab1}}`;
+                code += `${tab1}},\n`;
             }
 
-            if (this.type === 'ExclusiveGateway') {
-                prevCode += `\n${tab5}${this.name}:  elements.${this.name},\n`;
+            if(this.type === 'ExclusiveGateway' || this.type === 'AutoTask') {
+                prevCode += `\n${tab5}${this.name}:  elements.${this.name},\n`
                 prevCode += `${tab3}}\n`;
-                code += `${tab1}logic: ${this.logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode, true)},`;
+                code += `${tab1}logic: `;
+                code += `${this.logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }), prevCode, true)},\n`;
+            }
+        }
+        if(this.type === 'UserTask' || this.type === 'AutoTask' || this.type === 'StartNoneEvent') {
+            code += '_constraints: function() {\n'
+            code += `${tab1}nasl.process.oneOutcomeFlow(${afterLinks.map(l => `'${l.name}'`).join(',')})\n`
+            code += '},\n'
+        }
+        if(this.type === 'ExclusiveGateway' || this.type === 'ParallelGateway') {
+            code += '_constraints: function() {\n'
+            code += `${tab1}nasl.process.atLeastOneOutcomeFlow(${afterLinks.map(l => `'${l.name}'`).join(',')})\n`
+            code += `${tab1}nasl.process.atLeastOneOutcomeFlow(${beforeLinks.map(l => `'${l.name}'`).join(',')})\n`
+            if(afterLinks.length > 0 && beforeLinks.length > 0) {
+                code += `${tab1}nasl.process.atLeastThreeOutcomeFlow(${beforeLinks.concat(afterLinks).map(l => `'${l.name}'`).join(',')})\n`
             }
+            code += '},\n'
+        }
+
+        if(!isFromStartNode(this)){
+            code += '__outOfProcess__,';
         }
+
         code += `${tab0}\n},`;
         // let code = '';
         // this.variables.forEach((property) => {

package/src/concepts/Process__.ts

@@ -949,15 +949,21 @@ export class Process extends BaseNode {
         return params;
     }
 
-    getVarExistingNames(excludedList: Array<Param | Return | Constant> = []) {
+    getVarExistingNames(excludedList: Array<Param | Return | Constant | ProcessElement> = []) {
         const excludedSet = new Set(excludedList);
-        return [...this.params, ...this.returns, ...this.constants].filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return [...this.params, ...this.returns, ...this.constants, ...this.elements].filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
 
     getNamespace(ns: string) {
-        if (this.parentNode && (this.parentNode as Namespace).getNamespace)
-            return `${(this.parentNode as Namespace).getNamespace()}.${ns}`;
-        else
+        if (this.parentNode && (this.parentNode as Namespace).getNamespace) {
+            const parentNamespace = (this.parentNode as Namespace).getNamespace();
+            const parentName = this.parentNode.name;
+            const arr = [parentNamespace];
+            if (this.parentNode.concept !== 'App' && parentName) {
+                arr.push(parentName);
+            }
+            return `${arr.join('.')}.${ns || 'processes'}`;
+        } else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
 
@@ -1003,17 +1009,17 @@ export class Process extends BaseNode {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = `export namespace ${this.name} {\n`;
-        const tab0 = indent(state.tabSize);
-        const tab1 = indent(state.tabSize + 1);
-        const tab2 = indent(state.tabSize + 2);
-        const tab3 = indent(state.tabSize + 3);
+        const tab0 = indent((state?.tabSize || 0));
+        const tab1 = indent((state?.tabSize || 0) + 1);
+        const tab2 = indent((state?.tabSize || 0) + 2);
+        const tab3 = indent((state?.tabSize || 0) + 3);
         // code += `${tab1}namespace variables{\n`;
 
         code += `${tab1}export namespace logics {\n`;
         const logic = genLaunchProcess(this);
         // sourceMap 映射
         logic.parentNode = this;
-        code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 2 }));
+        code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 2 }));
         code += `${tab1}}\n`;
 
         this.params.forEach((property) => {
@@ -1037,8 +1043,8 @@ export class Process extends BaseNode {
 
         this.elements.forEach((ele) => {
             code += '\n';
-            if (ele.type === 'UserTask' || ele.type === 'ExclusiveGateway' || ele.type === 'AutoTask') {
-                code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+            if (ele.type !== 'EndNoneEvent' && ele.type !== 'SequenceFlow') {
+                code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
             }
         });
         code += `${tab1}}\n`;

package/src/concepts/QueryAggregateExpression__.ts

@@ -138,7 +138,7 @@ export class QueryAggregateExpression extends LogicItem {
         //     code += `[__EMPTY_AGGREGATE_NAME__, '']`;
 
         // return code;
-        return `__${this.asName || '__EMPTY_AGGREGATE_ALIAS__'}`;
+        return `__${this.asName || 'EMPTY_AGGREGATE_ALIAS__'}`;
     }
 
     setName(asName: string) {

package/src/concepts/QueryFieldExpression__.ts

@@ -1,4 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
+import CallQueryComponent from './CallQueryComponent__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -103,6 +104,10 @@ export class QueryFieldExpression extends LogicItem {
         };
     }
 
+    setName(asName: string) {
+        this.update({ asName });
+    }
+
     getValue() {
         const { entityAsName, propertyName } = this;
         return `${entityAsName}.${propertyName}`;
@@ -111,7 +116,14 @@ export class QueryFieldExpression extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         const { entityAsName, propertyName } = this;
-        return entityAsName && propertyName ? `new app.entities.${entityAsName}().${propertyName}` : '__QueryFieldExpression__';
+        const callQueryComponent = this.getAncestor('CallQueryComponent') as CallQueryComponent;
+        if (callQueryComponent) {
+            const entityNamespace = callQueryComponent?.from?.entityNamespace;
+            if (entityNamespace && entityAsName && propertyName) {
+                return `new ${entityNamespace}.${entityAsName}().${propertyName}`;
+            }
+        }
+        return '__QueryFieldExpression__';
     }
 
     //================================================================================

package/src/concepts/QueryFromExpression__.ts

@@ -224,6 +224,17 @@ export class QueryFromExpression extends LogicItem {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
+    /**
+     * 设置实体namespace字段
+     */
+    setEntityNamespace(entityNamespace: string) {
+        const object = {
+            entityNamespace,
+        };
+        this.update({
+            ...object,
+        });
+    }
     get entityKey(): string {
         return `${this.entityNamespace}.${this.entityName}`;
     }
@@ -235,10 +246,10 @@ export class QueryFromExpression extends LogicItem {
         if (this.joinParts.length) {
             code += '\n';
             this.joinParts.forEach((joinPart) => {
-                code += joinPart.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+                code += joinPart.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
             });
         }
-        code += `${indent(state.tabSize)})\n`;
+        code += `${indent((state?.tabSize || 0))})\n`;
         return code;
     }
 

package/src/concepts/QueryGroupByExpression__.ts

@@ -1,3 +1,7 @@
+import { withSourceMap } from '../translator';
+import type CallQueryComponent from './CallQueryComponent__';
+import type QueryFieldExpression from './QueryFieldExpression__';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -125,6 +129,25 @@ export class QueryGroupByExpression extends LogicItem {
         };
     }
 
+    setEntityAsName(name: string) {
+        (this.groupElement as QueryFieldExpression).setEntityAsName(name);
+    }
+
+    setPropertyName(name: string) {
+        (this.groupElement as QueryFieldExpression).setPropertyName(name);
+    }
+
+    @withSourceMap()
+    toEmbeddedTS(): string {
+        // 判断老应用
+        if ((this.parentNode as CallQueryComponent).isAutoInfer()) {
+            // 2.11版本后 分组使用别名
+            return `__${(this.groupElement as QueryFieldExpression).asName || 'EMPTY_GROUP_BY_ALIAS__'}`;
+        } else {
+            return (this.groupElement as QueryFieldExpression).toEmbeddedTS();
+        }
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/QueryJoinExpression__.ts

@@ -406,19 +406,30 @@ export class QueryJoinExpression extends LogicItem {
         return `${this.entityNamespace}.${this.entityName}`;
     }
 
+    /**
+     * 设置实体namespace字段
+     */
+    setEntityNamespace(entityNamespace: string) {
+        const object = {
+            entityNamespace,
+        };
+        this.update({
+            ...object,
+        });
+    }
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '';
         code += `.${this.joinType}_JOIN(new nasl.langUtil.Collection<[${this.entityKey}]>())\n`;
         if (this.onExpressions.length > 0) {
-            code += indent(state.tabSize) + `.ON(() => `;
+            code += indent((state?.tabSize || 0)) + `.ON(() => `;
             this.onExpressions.forEach((expression, index) => {
                 if (index > 0)
-                    code += `\n${indent(state.tabSize + 1)}&& `;
+                    code += `\n${indent((state?.tabSize || 0) + 1)}&& `;
                 code += expression.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
             });
             if (this.onExpressions.length > 1)
-                code += `\n${indent(state.tabSize)}`;
+                code += `\n${indent((state?.tabSize || 0))}`;
             code += ')\n';
         }
         if (this.joinParts.length > 0) {

package/src/concepts/Return__.ts

@@ -252,9 +252,9 @@ export class Return extends BaseNode {
             code += ': undefined as ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        if (this.defaultValue) {
-            code += `: ${this.defaultValue}`;
-        }
+        // if (this.defaultValue) {
+        //     code += `: ${this.defaultValue}`;
+        // }
         return code;
     }
 
@@ -284,7 +284,7 @@ export class Return extends BaseNode {
         }
         // 处理下拉属性
         try {
-            this.completionChildren = this.getSelectRef();
+            this.completionChildren = this.getSelectRef(typeAnnotation);
         } catch (err) {
             this.completionChildren = [];
             console.log(err);
@@ -327,12 +327,12 @@ export class Return extends BaseNode {
     get isTreeLeaf() {
         return !this.hasChildren;
     }
-    getSelectRef() {
+    getSelectRef(newTypeAnnotation: TypeAnnotation) {
         try {
-            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
             let completionChildren;
             if (typeKind === 'reference') {
-                if (typeNamespace === 'nasl.ui') {
+                if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process') {
                     const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
                     const properties = node.properties || [];
                     completionChildren = properties;
@@ -344,11 +344,16 @@ export class Return extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                for (let i = 0; i < properties.length; i++) {
+                    const item = properties[i];
+                    if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                        properties[i].typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        properties[i].parentNode = this;
+                    }
                 }
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }