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

package/src/concepts/Logic__.ts

@@ -82,7 +82,7 @@ export class Logic extends BaseNode {
      * 编译器信息
      */
     @property()
-    compilerInfoMap: { java?: { packageName: string; className: string } } = undefined;
+    compilerInfoMap: { java?: { packageName: string, className: string } } = undefined;
 
     /**
      * 类型参数列表
@@ -254,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) {
@@ -391,24 +391,24 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 插入输入参数
-     * @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) {
@@ -528,24 +528,24 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 插入输出参数
-     * @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) {
@@ -665,24 +665,24 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 插入变量
-     * @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) {
@@ -798,17 +798,17 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 插入逻辑项
-     * @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) {
@@ -894,17 +894,17 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 插入逻辑项
-     * @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) {
@@ -990,9 +990,9 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 删除事务
-     * @param name 事务名称
-     */
+    * 删除事务
+    * @param name 事务名称
+    */
     removeTransactional(name: string): void;
 
     /**
@@ -1038,9 +1038,9 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 删除类型参数
-     * @param name 类型参数名称
-     */
+    * 删除类型参数
+    * @param name 类型参数名称
+    */
     removeTypeParam(name: string): void;
 
     /**
@@ -1086,9 +1086,9 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 删除输入参数
-     * @param name 输入参数名称
-     */
+    * 删除输入参数
+    * @param name 输入参数名称
+    */
     removeParam(name: string): void;
 
     /**
@@ -1134,9 +1134,9 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 删除输出参数
-     * @param name 输出参数名称
-     */
+    * 删除输出参数
+    * @param name 输出参数名称
+    */
     removeReturn(name: string): void;
 
     /**
@@ -1182,9 +1182,9 @@ export class Logic extends BaseNode {
     }
 
     /**
-     * 删除变量
-     * @param name 变量名称
-     */
+    * 删除变量
+    * @param name 变量名称
+    */
     removeVariable(name: string): void;
 
     /**
@@ -1360,6 +1360,8 @@ export class Logic extends BaseNode {
     }
 
     toJSContent(code: string, state?: TranslatorState): string {
+        // 兼容前端事件逻辑参数中的 current event，deleteBy updateBy 需要对 current、event 进行预处理
+        code += `var __currentArg;var __eventArg;try {__currentArg = current;__eventArg = event;} catch(e) {}`;
         // params
         if (Array.isArray(this.params)) {
             this.params.forEach((param) => {
@@ -1609,12 +1611,17 @@ export class Logic extends BaseNode {
         const needGetSourceMapOqlList: Promise<any>[] = [];
         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} = `));
+                let jsCode = '';
+                try {
+                    jsCode = el.toJS();
+                } catch (error) {
+
+                }
+                const advanceVar = this.variables?.find((variable) => !variable.typeAnnotation && jsCode.startsWith(`${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.startsWith(`${ret.name} = `));
                 if (advanceRn && !advanceMap.get(advanceRn)) {
                     advanceMap.set(advanceRn, el);
                 }
@@ -1699,6 +1706,10 @@ export class Logic extends BaseNode {
                 const rightNode: any = assignment.right;
                 code += ' = ';
                 code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
+            } else if (assignment.right.concept === 'NewComposite' && (assignment.right as any).typeAnnotation?.typeKind === 'anonymousStructure') {
+                const rightNode: any = assignment.right;
+                code += ' = ';
+                code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
             } else {
                 const rightNode: any = assignment.right;
                 // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
@@ -1748,6 +1759,7 @@ export class Logic extends BaseNode {
     }
 
     getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any): string {
+        code = code.replaceAll('\n', ' ');
         if (assignment instanceof Assignment && !assignment.right)
             return code;
 

package/src/concepts/Match__.ts

@@ -49,6 +49,8 @@ export class Match extends LogicItem {
     @property('MatchCase')
     cases: Array<MatchCase> = [];
 
+    
+
     /**
      * @param source 需要合并的部分参数
      */
@@ -62,6 +64,13 @@ export class Match extends LogicItem {
         return super.from(source, parentNode, parentKey) as Match;
     }
 
+    
+    
+
+    
+
+    
+
     /**
     * 插入匹配分支
     * @internal
@@ -94,6 +103,8 @@ export class Match extends LogicItem {
         return matchCase;
     }
 
+    
+
     /**
      * 插入匹配分支
      * @param matchCaseOptions 匹配分支参数
@@ -116,6 +127,8 @@ export class Match extends LogicItem {
         return node;
     }
 
+    
+
     /**
      * 添加匹配分支
      * @internal
@@ -135,6 +148,8 @@ export class Match extends LogicItem {
         return this._insertMatchCaseAt(options as any, index);
     }
 
+    
+
     /**
      * 添加匹配分支
      * @param matchCaseOptions 匹配分支参数
@@ -158,6 +173,9 @@ export class Match extends LogicItem {
         return node;
     }
 
+
+    
+
     /**
     * 删除逻辑项
     * @param name 逻辑项名称
@@ -183,6 +201,8 @@ export class Match extends LogicItem {
         return expression.delete();
     }
 
+    
+
     /**
      * 删除匹配分支
      * @param matchCase 已有的匹配分支实例
@@ -190,7 +210,7 @@ export class Match extends LogicItem {
     removeMatchCaseInCases(matchCase: MatchCase): void;
 
     removeMatchCaseInCases(options: MatchCase) {
-        const matchCase: MatchCase = options;
+        let matchCase: MatchCase = options;
         return matchCase.delete();
     }
 
@@ -407,51 +427,6 @@ export class Match extends LogicItem {
         return false;
     }
 
-    // 获取在页面中的名字
-    get inViewName() {
-        const nameList: string[] = [];
-        let node: BaseNode = this;
-        while (node) {
-            if (node === this) {
-                nameList.unshift('viewMatchExpression');
-            } else {
-                nameList.unshift(node.name);
-            }
-            if (node.concept === 'ViewElement') {
-                node = null;
-            } else {
-                nameList.unshift(node.parentKey);
-                node = node.parentNode;
-            }
-        }
-        return nameList.join('_').replace(/-/g, '_');
-    }
-
-    getViewMatchExpressionBuilder() {
-        return `gen${this.inViewName}`;
-    }
-
-    getInViewMethod(state?: TranslatorState) {
-        const viewElement = this?.getAncestor('ViewElement');
-        const argsList = [];
-        let parent = viewElement?.parentNode;
-        let index = 0;
-        while (parent && parent.concept !== 'View') {
-            if ((parent as ViewElement).slotScope) {
-                argsList.unshift(index === 0 ? 'current' : 'current' + index);
-                index++;
-            }
-            parent = parent.parentNode;
-        }
-
-        let code = '';
-        code += `${this.getViewMatchExpressionBuilder()} (${argsList.join(', ')}) {\n`;
-        code += `return ${this.toJS()}`;
-        code += `;\n`;
-        code += '}';
-        return code;
-    }
-
     onChange($event?: EventPayload): void {
         const { action, object, eventList } = $event || {};
         // expression修改时，通知tsserver，让tsserver重新生成ts文件，为了后续能获取expression的类型
@@ -467,18 +442,14 @@ export class Match extends LogicItem {
         if (state?.finalCode === false) {
             return this.toUI();
         } else {
-            const viewElement = this?.getAncestor('ViewElement');
-            const argsList = [];
-            let parent = viewElement?.parentNode;
-            let index = 0;
-            while (parent && parent.concept !== 'View') {
-                if ((parent as ViewElement).slotScope) {
-                    argsList.unshift(index === 0 ? 'current' : 'current' + index);
-                    index++;
-                }
-                parent = parent.parentNode;
-            }
-            return `${this.getViewMatchExpressionBuilder()}(${argsList.join(', ')})`;
+            //        let code = 'await (async () => {\n';
+            //        if (this.expression && Array.isArray(this.cases)) {
+            //            this.cases.forEach((item, index) => {
+            //                code += item?.toJS?.(this.expression, index, this.cases.length);
+            //            });
+            //        }
+            //        code += `})()`;
+            //        return code;
         }
     }
 
@@ -498,20 +469,13 @@ export class Match extends LogicItem {
     }
 
     toJS(state?: TranslatorState): string {
-        let code = '';
-        // 祖先逻辑
-        const ancestorLogic = this.getAncestor('Logic');
-        if (ancestorLogic) {
-            code += 'await (async () => {\n';
-        } else {
-            code += '(() => {\n';
-        }
+        let code = 'await (async () => {\n';
         if (this.expression && Array.isArray(this.cases)) {
             this.cases.forEach((item, index) => {
                 code += item?.toJS?.(this.expression, index, this.cases.length);
             });
         }
-        code += '})()';
+        code += `})()`;
         return code;
     }
 

package/src/concepts/MemberExpression__.ts

@@ -151,6 +151,8 @@ export class MemberExpression extends LogicItem {
         //  如果是枚举取值
         if (this.object?.concept === 'Identifier' && (this.object as Identifier)?.isEnum() && this.property?.concept === 'Identifier') {
             return `"${this.property?.name}"`;
+        } else if (this.object?.__TypeAnnotation?.sortedTypeKey?.startsWith('nasl.collection.Map') && this.property?.name === 'length') {
+            return `Object.keys(${this.object?.toJS()}).length`;
         }
         const object = String(this.object?.toVue(options)); // undefined 也让正常展示
         const property = String(this.property?.toVue(options));
@@ -169,6 +171,8 @@ export class MemberExpression extends LogicItem {
         //  如果是枚举取值
         if (this.object?.concept === 'Identifier' && (this.object as Identifier)?.isEnum() && this.property?.concept === 'Identifier') {
             return `${this.object?.name}.${this.property?.name}`;
+        } else if (this.object?.__TypeAnnotation?.sortedTypeKey?.startsWith('nasl.collection.Map') && this.property?.name === 'length') {
+            return `Object.keys(${this.object?.toJS()}).length`;
         }
         const object: string = this.object?.toUI();
         const property = this.property?.toUI();
@@ -180,6 +184,8 @@ export class MemberExpression extends LogicItem {
         //  如果是枚举取值
         if (this.object?.concept === 'Identifier' && (this.object as Identifier)?.isEnum() && this.property?.concept === 'Identifier') {
             return `"${this.property?.name}"`;
+        } else if (this.object?.__TypeAnnotation?.sortedTypeKey?.startsWith('nasl.collection.Map') && this.property?.name === 'length') {
+            return `Object.keys(${this.object?.toJS()}).length`;
         }
         const object: string = this.object?.toJS();
         const property = this.property?.toJS();

package/src/concepts/Module__.ts

@@ -25,6 +25,7 @@ import View from './View__';
 import Variable from './Variable__';
 import Process from './Process__';
 import ViewComponent from './ViewComponent__';
+import Configuration from './Configuration__';
 import App from './App__';
 
 /**
@@ -134,6 +135,12 @@ export class Module extends BaseNode {
     @property('ViewComponent')
     viewComponents: Array<ViewComponent> = [];
 
+    /**
+     * 配置管理
+     */
+    @property('Configuration')
+    configuration: Configuration = undefined;
+
     /**
      * 祖先 App
      */
@@ -1895,6 +1902,56 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
+    /**
+    * 删除配置管理
+    * @param name 配置管理名称
+    */
+    removeConfiguration(name: string): void;
+
+    /**
+     * 删除配置管理
+     * @param configuration 已有的配置管理实例
+     */
+    removeConfiguration(configuration: Configuration): void;
+
+    removeConfiguration(options: string | Configuration) {
+        let configuration: Configuration;
+        if (typeof options === 'string') {
+            configuration = this.configuration;
+            if (!configuration) {
+                throw new Error('找不到配置管理 ' + options);
+            }
+        } else {
+            configuration = options;
+        }
+        return configuration.delete();
+    }
+
+    __removeConfiguration(configuration: Configuration) {
+        const parentKey = configuration.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: configuration,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(configuration);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === configuration) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。