@lcap/nasl 2.18.0 → 2.20.0-beta.2

package/src/concepts/Logic__.ts

@@ -34,6 +34,7 @@ import Module from './Module__';
 import View from './View__';
 import ProcessElement from './ProcessElement__';
 import App from './App__';
+import Frontend from './Frontend__';
 import Process from './Process__';
 
 /**
@@ -81,7 +82,7 @@ export class Logic extends BaseNode {
      * 编译器信息
      */
     @property()
-    compilerInfoMap: { java?: { packageName: string, className: string } } = undefined;
+    compilerInfoMap: { java?: { packageName: string; className: string } } = undefined;
 
     /**
      * 类型参数列表
@@ -137,6 +138,12 @@ export class Logic extends BaseNode {
     get view() {
         return this.getAncestor('View') as View;
     }
+    /**
+     * 祖先 Frontend
+     */
+    get frontend() {
+        return this.getAncestor('Frontend') as Frontend;
+    }
     /**
      * 祖先 ProcessElement
      */
@@ -238,7 +245,7 @@ export class Logic extends BaseNode {
         });
     }
 
-        getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
+    getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.typeParams as TypeParam[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -247,24 +254,24 @@ export class Logic extends BaseNode {
     }
 
     /**
-    * 插入类型参数
-    * @internal
-    * @param name 类型参数名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
     _insertTypeParamAt(name: string, index: number): TypeParam;
 
     /**
-    * 插入类型参数
-    * @internal
-    * @param typeParamOptions 类型参数参数
-    */
+     * 插入类型参数
+     * @internal
+     * @param typeParamOptions 类型参数参数
+     */
     _insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
 
     /**
-    * 插入类型参数
-    * @internal
-    * @param typeParam 已有的类型参数实例
-    */
+     * 插入类型参数
+     * @internal
+     * @param typeParam 已有的类型参数实例
+     */
     _insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
 
     _insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
@@ -379,30 +386,29 @@ export class Logic extends BaseNode {
         return node;
     }
 
-
     getParamUniqueName(name = 'param1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
 
     /**
-    * 插入输入参数
-    * @internal
-    * @param name 输入参数名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
     _insertParamAt(name: string, index: number): Param;
 
     /**
-    * 插入输入参数
-    * @internal
-    * @param paramOptions 输入参数参数
-    */
+     * 插入输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
     _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
 
     /**
-    * 插入输入参数
-    * @internal
-    * @param param 已有的输入参数实例
-    */
+     * 插入输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
     _insertParamAt(param: Param, index: number): Param;
 
     _insertParamAt(options: string | Partial<Param> | Param, index: number) {
@@ -517,30 +523,29 @@ export class Logic extends BaseNode {
         return node;
     }
 
-
     getReturnUniqueName(name = 'result') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
 
     /**
-    * 插入输出参数
-    * @internal
-    * @param name 输出参数名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
     _insertReturnAt(name: string, index: number): Return;
 
     /**
-    * 插入输出参数
-    * @internal
-    * @param retOptions 输出参数参数
-    */
+     * 插入输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
     _insertReturnAt(retOptions: Partial<Return>, index: number): Return;
 
     /**
-    * 插入输出参数
-    * @internal
-    * @param ret 已有的输出参数实例
-    */
+     * 插入输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
     _insertReturnAt(ret: Return, index: number): Return;
 
     _insertReturnAt(options: string | Partial<Return> | Return, index: number) {
@@ -655,30 +660,29 @@ export class Logic extends BaseNode {
         return node;
     }
 
-
     getVariableUniqueName(name = 'variable1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
 
     /**
-    * 插入变量
-    * @internal
-    * @param name 变量名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入变量
+     * @internal
+     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     */
     _insertVariableAt(name: string, index: number): Variable;
 
     /**
-    * 插入变量
-    * @internal
-    * @param variableOptions 变量参数
-    */
+     * 插入变量
+     * @internal
+     * @param variableOptions 变量参数
+     */
     _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
 
     /**
-    * 插入变量
-    * @internal
-    * @param variable 已有的变量实例
-    */
+     * 插入变量
+     * @internal
+     * @param variable 已有的变量实例
+     */
     _insertVariableAt(variable: Variable, index: number): Variable;
 
     _insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
@@ -793,23 +797,18 @@ export class Logic extends BaseNode {
         return node;
     }
 
-
-
-
-
-
     /**
-    * 插入逻辑项
-    * @internal
-    * @param logicItemOptions 逻辑项参数
-    */
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
     _insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
 
     /**
-    * 插入逻辑项
-    * @internal
-    * @param logicItem 已有的逻辑项实例
-    */
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
     _insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
 
     _insertItemInBodyAt(options: Partial<LogicItem> | LogicItem, index: number) {
@@ -830,8 +829,6 @@ export class Logic extends BaseNode {
         return logicItem;
     }
 
-
-
     /**
      * 插入逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -854,8 +851,6 @@ export class Logic extends BaseNode {
         return node;
     }
 
-
-
     /**
      * 添加逻辑项
      * @internal
@@ -875,8 +870,6 @@ export class Logic extends BaseNode {
         return this._insertItemInBodyAt(options as any, index);
     }
 
-
-
     /**
      * 添加逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -900,20 +893,18 @@ export class Logic extends BaseNode {
         return node;
     }
 
-
-
     /**
-    * 插入逻辑项
-    * @internal
-    * @param logicItemOptions 逻辑项参数
-    */
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
     _insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
 
     /**
-    * 插入逻辑项
-    * @internal
-    * @param logicItem 已有的逻辑项实例
-    */
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
     _insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
 
     _insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
@@ -934,8 +925,6 @@ export class Logic extends BaseNode {
         return logicItem;
     }
 
-
-
     /**
      * 插入逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -958,8 +947,6 @@ export class Logic extends BaseNode {
         return node;
     }
 
-
-
     /**
      * 添加逻辑项
      * @internal
@@ -979,8 +966,6 @@ export class Logic extends BaseNode {
         return this._insertItemInPlaygroundAt(options as any, index);
     }
 
-
-
     /**
      * 添加逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -1004,13 +989,10 @@ export class Logic extends BaseNode {
         return node;
     }
 
-
-
-
     /**
-    * 删除事务
-    * @param name 事务名称
-    */
+     * 删除事务
+     * @param name 事务名称
+     */
     removeTransactional(name: string): void;
 
     /**
@@ -1055,12 +1037,10 @@ export class Logic extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除类型参数
-    * @param name 类型参数名称
-    */
+     * 删除类型参数
+     * @param name 类型参数名称
+     */
     removeTypeParam(name: string): void;
 
     /**
@@ -1105,12 +1085,10 @@ export class Logic extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除输入参数
-    * @param name 输入参数名称
-    */
+     * 删除输入参数
+     * @param name 输入参数名称
+     */
     removeParam(name: string): void;
 
     /**
@@ -1155,12 +1133,10 @@ export class Logic extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除输出参数
-    * @param name 输出参数名称
-    */
+     * 删除输出参数
+     * @param name 输出参数名称
+     */
     removeReturn(name: string): void;
 
     /**
@@ -1205,12 +1181,10 @@ export class Logic extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除变量
-    * @param name 变量名称
-    */
+     * 删除变量
+     * @param name 变量名称
+     */
     removeVariable(name: string): void;
 
     /**
@@ -1255,8 +1229,6 @@ export class Logic extends BaseNode {
         return params;
     }
 
-
-
     /**
      * 删除逻辑项
      * @param logicItem 已有的逻辑项实例
@@ -1264,12 +1236,10 @@ export class Logic extends BaseNode {
     removeItemInBody(logicItem: LogicItem): void;
 
     removeItemInBody(options: LogicItem) {
-        let logicItem: LogicItem = options;
+        const logicItem: LogicItem = options;
         return logicItem.delete();
     }
 
-
-
     /**
      * 删除逻辑项
      * @param logicItem 已有的逻辑项实例
@@ -1277,7 +1247,7 @@ export class Logic extends BaseNode {
     removeItemInPlayground(logicItem: LogicItem): void;
 
     removeItemInPlayground(options: LogicItem) {
-        let logicItem: LogicItem = options;
+        const logicItem: LogicItem = options;
         return logicItem.delete();
     }
 
@@ -1625,15 +1595,10 @@ export class Logic extends BaseNode {
             code += '(';
             this.params.forEach((param, index) => {
                 code += param.toEmbeddedTS(shiftState(state, code));
-                code += ',';
-            });
-            code += '\n,  __defaultValues?: { \n';
-            this.params.forEach((param, index) => {
-                code += `${param.name}: "${param.defaultValue || ''}"`;
                 if (index !== this.params.length - 1)
-                    code += ',\n';
+                    code += ', ';
             });
-            code += '})';
+            code += ')';
         } else {
             // 没有参数的
             code += '()';
@@ -1645,13 +1610,11 @@ export class Logic extends BaseNode {
         this.traverseChildren((el) => {
             if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
                 const jsCode = el.toJS();
-                const advanceVar = this.variables?.find((variable) =>
-                    !variable.typeAnnotation && jsCode.includes(`${variable.name} = `));
+                const advanceVar = this.variables?.find((variable) => !variable.typeAnnotation && jsCode.includes(`${variable.name} = `));
                 if (advanceVar && !advanceMap.get(advanceVar)) {
                     advanceMap.set(advanceVar, el);
                 }
-                const advanceRn = this.returns?.find((ret) =>
-                    !ret.typeAnnotation && jsCode.includes(`${ret.name} = `));
+                const advanceRn = this.returns?.find((ret) => !ret.typeAnnotation && jsCode.includes(`${ret.name} = `));
                 if (advanceRn && !advanceMap.get(advanceRn)) {
                     advanceMap.set(advanceRn, el);
                 }
@@ -1668,12 +1631,14 @@ export class Logic extends BaseNode {
             Promise.all(needGetSourceMapOqlList).then(() => {
                 // 触发一下更新重新生成代码
                 (this.app as any)?.naslServer?.embeddedTSEmitter.emit('change', {
-                    value: [{
-                        originEvent: {
-                            action: 'update',
-                            target: this,
+                    value: [
+                        {
+                            originEvent: {
+                                action: 'update',
+                                target: this,
+                            },
                         },
-                    }],
+                    ],
                 });
             });
         }
@@ -1685,11 +1650,13 @@ export class Logic extends BaseNode {
         code += '{\n';
 
         // 用于虚拟节点的查找引用
-        this.virtualParams && Array.isArray(this.virtualParams) && this.virtualParams.forEach((param) => {
-            code += indent((state?.tabSize || 0) + 1);
-            code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
-            code += '\n';
-        });
+        this.virtualParams
+            && Array.isArray(this.virtualParams)
+            && this.virtualParams.forEach((param) => {
+                code += indent((state?.tabSize || 0) + 1);
+                code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
+                code += '\n';
+            });
 
         this.variables.forEach((variable) => {
             if (!advanceMap.get(variable)) {
@@ -1713,12 +1680,12 @@ export class Logic extends BaseNode {
             code += node.toEmbeddedTS(shiftState(state, code, { inline: true }));
             if (assignment instanceof BatchAssignment) {
                 assignment.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
-                    const leftCode = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                    const leftCode
+                        = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
                     if (leftCode === node.name) {
                         const rightNode: any = rightIndex.length === 1 ? assignment.rights[rightIndex[0]]?.expression : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
                         // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-                        if (rightNode?.typeAnnotation
-                            && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
+                        if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
                             code += ': ';
                             code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
                         } else {
@@ -1728,11 +1695,14 @@ export class Logic extends BaseNode {
                         }
                     }
                 });
+            } else if (['NewList', 'NewMap'].includes(assignment.right.concept) && !(assignment.right as any).typeAnnotation) {
+                const rightNode: any = assignment.right;
+                code += ' = ';
+                code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
             } else {
                 const rightNode: any = assignment.right;
                 // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-                if (rightNode?.typeAnnotation
-                    && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
+                if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
                     code += ': ';
                     code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
                 } else {
@@ -1742,7 +1712,7 @@ export class Logic extends BaseNode {
                     if (rightNode && rightNode instanceof Identifier && rightNode.namespace && rightNode.namespace.endsWith('enums')) {
                         rightCode += 'new ';
                     }
-                    rightCode += (rightNode && rightNode.toEmbeddedTS) ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
+                    rightCode += rightNode && rightNode.toEmbeddedTS ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
                     code += this.getRightCode(rightCode, assignment, rightNode);
                 }
             }
@@ -1815,6 +1785,10 @@ export class Logic extends BaseNode {
                 return replaceCode;
 
             let fnCode = $1;
+            if ($1.startsWith(`${variable}.`))
+                fnCode = $1.replaceAll(`${variable}.`, `${replaceCode}.`);
+            if ($1.startsWith(`${variable},`))
+                fnCode = $1.replaceAll(`${variable},`, `${replaceCode},`);
             if ($1.includes(`(${variable},`))
                 fnCode = $1.replaceAll(`(${variable},`, `(${replaceCode},`);
             if ($1.includes(`(${variable}.`))
@@ -1882,7 +1856,10 @@ export class Logic extends BaseNode {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
+            if (
+                !['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
+                && !namespace.includes('.logics')
+            ) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -1899,7 +1876,10 @@ export class Logic extends BaseNode {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
+            if (
+                !['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
+                && !namespace.includes('.logics')
+            ) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -2039,6 +2019,11 @@ export class Logic extends BaseNode {
     // 虚拟输入参数列表
     virtualParams: Array<Param> = [];
 
+    get getLogicBelongTo() {
+        const [, belongTo] = this.calleewholeKey.split('.');
+        return belongTo;
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓