@lcap/nasl 3.7.0-alpha.1 → 3.7.0-beta.1

package/out/concepts/Logic__.js

@@ -50,8 +50,12 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
      * @param source 需要合并的部分参数
      */
     constructor(source) {
-        source = { ...Logic_1.getDefaultOptions(), ...source };
+        source = Object.assign({}, Logic_1.getDefaultOptions(), source);
         super(source);
+        /**
+         * 逻辑名称
+         */
+        this.name = '';
         /**
          * 类型参数列表
          */
@@ -84,62 +88,9 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         this.virtualParams = [];
         super.subConstructor(source);
     }
-    /**
-     * 祖先 Module
-     */
-    get module() {
-        return this.getAncestor('Module');
-    }
-    /**
-     * 祖先 App
-     */
-    get app() {
-        return this.getAncestor('App');
-    }
-    /**
-     * 祖先 Connector
-     */
-    get connector() {
-        return this.getAncestor('Connector');
-    }
-    /**
-     * 祖先 View
-     */
-    get view() {
-        return this.getAncestor('View');
-    }
-    /**
-     * 祖先 Frontend
-     */
-    get frontend() {
-        return this.getAncestor('Frontend');
-    }
-    /**
-     * 祖先 ProcessElement
-     */
-    get processElement() {
-        return this.getAncestor('ProcessElement');
-    }
-    /**
-     * 祖先 Process
-     */
-    get process() {
-        return this.getAncestor('Process');
-    }
     static from(source, parentNode, parentKey) {
         return super.from(source, parentNode, parentKey);
     }
-    /**
-     * 从父级删除该节点
-     * @internal
-     */
-    _delete() {
-        let params = null;
-        if (this.parentNode) {
-            params = this.parentNode?.__removeLogic?.(this);
-        }
-        return params;
-    }
     /**
      * 设置逻辑名称
      */
@@ -223,7 +174,7 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
     }
     getTypeParamExistingNames(excludedList = []) {
         const excludedSet = new Set(excludedList);
-        return (this.typeParams || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+        return (this.typeParams || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getTypeParamUniqueName(name = 'typeParam1') {
         return utils.unique(name, this.getTypeParamExistingNames(), undefined, false);
@@ -537,56 +488,12 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         });
         return node;
     }
-    removeTransactional(options) {
-        let transactional;
-        if (typeof options === 'string') {
-            transactional = this.transactional;
-            if (!transactional) {
-                throw new Error(`找不到事务 ${options}`);
-            }
-        }
-        else {
-            transactional = options;
-        }
-        return transactional.delete();
-    }
-    __removeTransactional(transactional) {
-        const { parentKey } = transactional;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: transactional,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = transactional.__v_raw || transactional;
-            if (Array.isArray(t[parentKey])) {
-                // @ts-ignore
-                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else {
-                const q = t[parentKey];
-                if ((q.__v_raw || q) === n) {
-                    params.index = 0;
-                    this[parentKey] = undefined;
-                }
-            }
-        }
-        return params;
-    }
     removeTypeParam(options) {
         let typeParam;
         if (typeof options === 'string') {
             typeParam = this.typeParams.find((item) => item.name === options);
             if (!typeParam) {
-                throw new Error(`找不到类型参数 ${options}`);
+                throw new Error('找不到类型参数 ' + options);
             }
         }
         else {
@@ -594,43 +501,12 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         }
         return typeParam.delete();
     }
-    __removeTypeParam(typeParam) {
-        const { parentKey } = typeParam;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: typeParam,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = typeParam.__v_raw || typeParam;
-            if (Array.isArray(t[parentKey])) {
-                // @ts-ignore
-                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else {
-                const q = t[parentKey];
-                if ((q.__v_raw || q) === n) {
-                    params.index = 0;
-                    this[parentKey] = undefined;
-                }
-            }
-        }
-        return params;
-    }
     removeParam(options) {
         let param;
         if (typeof options === 'string') {
             param = this.params.find((item) => item.name === options);
             if (!param) {
-                throw new Error(`找不到输入参数 ${options}`);
+                throw new Error('找不到输入参数 ' + options);
             }
         }
         else {
@@ -638,43 +514,12 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         }
         return param.delete();
     }
-    __removeParam(param) {
-        const { parentKey } = param;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: param,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = param.__v_raw || param;
-            if (Array.isArray(t[parentKey])) {
-                // @ts-ignore
-                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else {
-                const q = t[parentKey];
-                if ((q.__v_raw || q) === n) {
-                    params.index = 0;
-                    this[parentKey] = undefined;
-                }
-            }
-        }
-        return params;
-    }
     removeReturn(options) {
         let ret;
         if (typeof options === 'string') {
             ret = this.returns.find((item) => item.name === options);
             if (!ret) {
-                throw new Error(`找不到输出参数 ${options}`);
+                throw new Error('找不到输出参数 ' + options);
             }
         }
         else {
@@ -682,43 +527,12 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         }
         return ret.delete();
     }
-    __removeReturn(ret) {
-        const { parentKey } = ret;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: ret,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = ret.__v_raw || ret;
-            if (Array.isArray(t[parentKey])) {
-                // @ts-ignore
-                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else {
-                const q = t[parentKey];
-                if ((q.__v_raw || q) === n) {
-                    params.index = 0;
-                    this[parentKey] = undefined;
-                }
-            }
-        }
-        return params;
-    }
     removeVariable(options) {
         let variable;
         if (typeof options === 'string') {
             variable = this.variables.find((item) => item.name === options);
             if (!variable) {
-                throw new Error(`找不到变量 ${options}`);
+                throw new Error('找不到变量 ' + options);
             }
         }
         else {
@@ -726,80 +540,54 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         }
         return variable.delete();
     }
-    __removeVariable(variable) {
-        const { parentKey } = variable;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: variable,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = variable.__v_raw || variable;
-            if (Array.isArray(t[parentKey])) {
-                // @ts-ignore
-                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else {
-                const q = t[parentKey];
-                if ((q.__v_raw || q) === n) {
-                    params.index = 0;
-                    this[parentKey] = undefined;
-                }
-            }
-        }
-        return params;
-    }
     removeItemInBody(options) {
-        const logicItem = options;
+        let logicItem = options;
         return logicItem.delete();
     }
     removeItemInPlayground(options) {
-        const logicItem = options;
+        let logicItem = options;
         return logicItem.delete();
     }
-    __removeLogicItem(logicItem) {
-        const { parentKey } = logicItem;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: logicItem,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            // @ts-ignore
-            const t = this.__v_raw || this;
-            // @ts-ignore
-            const n = logicItem.__v_raw || logicItem;
-            if (Array.isArray(t[parentKey])) {
-                // @ts-ignore
-                const index = t[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else {
-                const q = t[parentKey];
-                if ((q.__v_raw || q) === n) {
-                    params.index = 0;
-                    this[parentKey] = undefined;
-                }
-            }
-        }
-        return params;
-    }
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+    /**
+     * 祖先 Module
+     */
+    get module() {
+        return this.getAncestor('Module');
+    }
+    /**
+     * 祖先 Connector
+     */
+    get connector() {
+        return this.getAncestor('Connector');
+    }
+    /**
+     * 祖先 View
+     */
+    get view() {
+        return this.getAncestor('View');
+    }
+    /**
+     * 祖先 Frontend
+     */
+    get frontend() {
+        return this.getAncestor('Frontend');
+    }
+    /**
+     * 祖先 ProcessElement
+     */
+    get processElement() {
+        return this.getAncestor('ProcessElement');
+    }
+    /**
+     * 祖先 Process
+     */
+    get process() {
+        return this.getAncestor('Process');
+    }
     // 用于calllogic树中定位是那个logic，回显
     get calleewholeKey() {
         return `${this.getNamespace()}.${this.name}`;
@@ -953,11 +741,11 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         // 本此考虑将return 的类型 生成到 returnType: {}  字段
         // 在运行时根据类型直接生成mock数据
         const mockService = this.toService();
-        mockService.returns = this.returns?.map(re => {
+        mockService.returns = this.returns?.map((re) => {
             // if(!re?.typeAnnotation){debugger}
             let tA = re?.typeAnnotation || re?.__TypeAnnotation;
             return {
-                typeAnnotation: tA?.toJS()
+                typeAnnotation: tA?.toJS(),
             };
         });
         return mockService;
@@ -1098,6 +886,7 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         return code;
     }
     toEmbeddedTSNoExport(state) {
+        return (0, time_slicing_1.runGeneratorSync)(this.toEmbeddedTS(state, 'noExport'));
     }
     get tsName() {
         // 来自集成中心，且是连接内部的逻辑，则认为是编辑态的，需要加上后缀
@@ -1151,16 +940,30 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         const advanceMap = new Map();
         // const needGetSourceMapOqlList: Promise<any>[] = [];
         yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-            if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
-                if (asserts.isAssignment(el)) {
-                    const advanceVar = self.variables?.find((variable) => !variable.typeAnnotation && el.left?.name === variable.name);
+            if (el && (
+            // 批量赋值
+            asserts.isBatchAssignment(el)
+                // 赋值
+                || (asserts.isAssignment(el) && el.left?.name)
+                // 内置函数对集合类型的推导
+                || (asserts.isCallFunction(el) && el.derivablecollection?.name))) {
+                if (asserts.isAssignment(el) || asserts.isCallFunction(el)) {
+                    let expression;
+                    if (asserts.isAssignment(el)) {
+                        // 需要被推导的赋值左侧
+                        expression = el.left;
+                    }
+                    else if (asserts.isCallFunction(el)) {
+                        // 需要被推导的集合
+                        expression = el.derivablecollection;
+                    }
+                    // 宽泛意义上的变量（变量+出参）
+                    const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
+                        return !variable.typeAnnotation && expression?.name === variable.name;
+                    });
                     if (advanceVar && !advanceMap.get(advanceVar)) {
                         advanceMap.set(advanceVar, el);
                     }
-                    const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-                    if (advanceRn && !advanceMap.get(advanceRn)) {
-                        advanceMap.set(advanceRn, el);
-                    }
                 }
                 else if (asserts.isBatchAssignment(el)) {
                     yield* (0, time_slicing_1.wrapForEachToGenerator)(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
@@ -1187,10 +990,6 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
                 (0, time_slicing_1.returnOrigin)('');
         }
         code += '{\n';
-        if (self.exportInterface) {
-            code += (0, translator_1.indent)((state?.tabSize || 0) + 1);
-            code += `let exportInterface = app.interfaces.${self.exportInterface.name};\n`;
-        }
         // 用于虚拟节点的查找引用
         if (Array.isArray(self.virtualParams)) {
             for (const param of self.virtualParams) {
@@ -1229,6 +1028,26 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
                 return;
             }
             code += `${(0, translator_1.indent)((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
+            if (asserts.isCallFunction(assignment)) {
+                yield* (0, time_slicing_1.wrapForEachToGenerator)([
+                    {
+                        key: 'key',
+                        node: assignment.keyOfCollection
+                    },
+                    {
+                        key: 'item',
+                        node: assignment.itemOfCollection
+                    }
+                ], function* warpForEachGenerator({ key, node: itemNode }) {
+                    if (itemNode) {
+                        code += `const __${key}_${node?.name} = `;
+                        const itemCode = yield* itemNode?.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true })) ??
+                            (0, time_slicing_1.returnOrigin)('');
+                        code += yield* self.getRightCode(itemCode, assignment, itemNode);
+                        code += ';\n';
+                    }
+                });
+            }
             code += `${(0, translator_1.indent)((state?.tabSize || 0) + 1)}let `;
             code += yield* node.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true }));
             if (asserts.isBatchAssignment(assignment)) {
@@ -1284,6 +1103,17 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
                 code += ' = ';
                 code += yield* rightNode.getNewCompositeCode((0, translator_1.shiftState)(state, code, { inline: true }));
             }
+            else if (asserts.isCallFunction(assignment)) {
+                const nodeName = node?.name;
+                const keyNode = assignment.keyOfCollection;
+                const itemNode = assignment.itemOfCollection;
+                if (assignment.isDerivableMap && keyNode && itemNode) {
+                    code += `: nasl.collection.Map<typeof __key_${nodeName}, typeof __item_${nodeName}>`;
+                }
+                else if (assignment.isDerivableList && itemNode) {
+                    code += `: nasl.collection.List<typeof __item_${nodeName}>;`;
+                }
+            }
             else {
                 const rightNode = assignment.right;
                 // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
@@ -1383,6 +1213,9 @@ ${(0, translator_1.indent)(state.tabSize)} */\n`;
             else if (parentNode?.concept === 'BindEvent') {
                 logicName = `on_${parentNode?.parentNode?.name}_${name}`;
             }
+            else if (this?.concept === 'BusinessLogic') {
+                logicName = `businessLogic_${name}`;
+            }
             else {
                 logicName = this.name;
             }
@@ -1480,8 +1313,11 @@ ${(0, translator_1.indent)(state.tabSize)} */\n`;
     }
     *getRightCode(code, assignment, rightNode) {
         code = code.replaceAll('\n', ' ');
-        if (asserts.isAssignment(assignment) && !assignment.right)
+        // 赋值语句的右侧或者集合内置函数的参数
+        if ((asserts.isAssignment(assignment) && !assignment.right)
+            || (asserts.isCallFunction(assignment) && ((assignment.isDerivableList && !assignment.itemOfCollection) || (assignment.isDerivableMap && !(assignment.keyOfCollection && assignment.itemOfCollection))))) {
             return code;
+        }
         // 调用接口，参数替换成 null
         if (asserts.isCallInterface(rightNode)) {
             const { _interface } = rightNode.getModuleInterface();
@@ -1500,6 +1336,12 @@ ${(0, translator_1.indent)(state.tabSize)} */\n`;
         if (forEachStatement) {
             code = yield* this.handleForEachCode(code, forEachStatement);
         }
+        // 可迭代的集合
+        const callFunction = assignment.getAncestor('CallFunction');
+        if (callFunction && callFunction.isLoopCollection) {
+            const anonymousFunction = assignment.getAncestor('AnonymousFunction');
+            code = yield* this.handleCollectionCode(code, anonymousFunction, callFunction);
+        }
         // Match 需要针对分支缩小类型范围
         const matchCase = assignment.getAncestor('MatchCase');
         if (matchCase) {
@@ -1550,6 +1392,26 @@ ${(0, translator_1.indent)(state.tabSize)} */\n`;
         }
         return code;
     }
+    *handleCollectionCode(code, anonymousFunction, callFunction) {
+        const { collection } = callFunction;
+        const self = this;
+        yield* (0, time_slicing_1.wrapForEachToGenerator)(anonymousFunction.params, function* warpForEachGenerator(param, index) {
+            if (code.includes(param?.name)) {
+                const collectionTSCode = collection ? yield* collection.toEmbeddedTS() : '__IDENTIFIER__';
+                code = self.handleReplaceCode(code, param.name, collectionTSCode === '__IDENTIFIER__' ? collectionTSCode : callFunction.isLoopMap && index === 0 ? `${collectionTSCode}.__getKey(0)` : `${collectionTSCode}.__get(0)`);
+            }
+        });
+        const parentForEachStatement = callFunction.getAncestor('ForEachStatement');
+        if (parentForEachStatement) {
+            code = yield* this.handleForEachCode(code, parentForEachStatement);
+        }
+        const parentCallFunction = callFunction.getAncestor('CallFunction');
+        if (parentCallFunction?.isLoopCollection) {
+            const parentAnonymousFunction = callFunction.getAncestor('AnonymousFunction');
+            code = yield* this.handleCollectionCode(code, parentAnonymousFunction, parentCallFunction);
+        }
+        return code;
+    }
     *handleMatchCaseCode(code, matchCase) {
         const match = matchCase.getAncestor('Match');
         const expressionTsCode = yield* match.expression.toEmbeddedTS();
@@ -1848,28 +1710,45 @@ ${(0, translator_1.indent)(state.tabSize)} */\n`;
 };
 /** 类名 */
 Logic.ConceptName = 'Logic';
+/**
+ * 是否为抽象类
+ * 抽象类不能产生 concept: string
+ */
+Logic.isAbstract = false;
 /** 继承链 */
 Logic.inheritanceChain = ['BaseNode'];
 __decorate([
     (0, decorators_1.property)('concept')
 ], Logic.prototype, "concept", void 0);
 __decorate([
-    (0, decorators_1.property)()
+    (0, decorators_1.property)({
+        objectRef: '',
+    })
 ], Logic.prototype, "name", void 0);
 __decorate([
-    (0, decorators_1.property)()
+    (0, decorators_1.property)({
+        objectRef: '',
+    })
 ], Logic.prototype, "title", void 0);
 __decorate([
-    (0, decorators_1.property)()
+    (0, decorators_1.property)({
+        objectRef: '',
+    })
 ], Logic.prototype, "description", void 0);
 __decorate([
-    (0, decorators_1.property)()
+    (0, decorators_1.property)({
+        objectRef: '',
+    })
 ], Logic.prototype, "triggerType", void 0);
 __decorate([
-    (0, decorators_1.property)()
+    (0, decorators_1.property)({
+        objectRef: '',
+    })
 ], Logic.prototype, "cron", void 0);
 __decorate([
-    (0, decorators_1.property)()
+    (0, decorators_1.property)({
+        objectRef: '',
+    })
 ], Logic.prototype, "overridable", void 0);
 __decorate([
     (0, decorators_1.property)({