@lcap/nasl 1.0.0-alpha → 1.0.0-alpha.3

package/src/concepts/ProcessElement__.ts

@@ -1,4 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
+import { constantToParam, returnToParam } from '../server/getProcesses';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -7,6 +8,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import Rect from './Rect__';
@@ -246,33 +248,33 @@ export class ProcessElement extends BaseNode {
         });
     }
 
-        getPointExistingNames(excludedList: Array<Point> = []) {
+    getPointExistingNames(excludedList: Array<Point> = []) {
         const excludedSet = new Set(excludedList);
-        return this.waypoints.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.waypoints || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getPointUniqueName(name = 'point1') {
         return utils.unique(name, this.getPointExistingNames());
     }
 
     /**
-    * 插入点信息
-    * @internal
-    * @param name 点信息名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入点信息
+     * @internal
+     * @param name 点信息名称，如果不填会自动生成一个唯一名称
+     */
     _insertPointAt(name: string, index: number): Point;
 
     /**
-    * 插入点信息
-    * @internal
-    * @param pointOptions 点信息参数
-    */
+     * 插入点信息
+     * @internal
+     * @param pointOptions 点信息参数
+     */
     _insertPointAt(pointOptions: Partial<Point>, index: number): Point;
 
     /**
-    * 插入点信息
-    * @internal
-    * @param point 已有的点信息实例
-    */
+     * 插入点信息
+     * @internal
+     * @param point 已有的点信息实例
+     */
     _insertPointAt(point: Point, index: number): Point;
 
     _insertPointAt(options: string | Partial<Point> | Point, index: number) {
@@ -283,22 +285,22 @@ export class ProcessElement extends BaseNode {
             point = Point.from({
                 ...pointOptions,
                 name: this.getPointUniqueName(),
-            }, this);
+            }, this, 'waypoints');
         } else if (typeof options === 'string') {
             point = Point.from({
                 ...pointOptions,
                 name: options,
-            }, this);
+            }, this, 'waypoints');
         } else if (options instanceof Point) {
             options.delete(); // 同一实例不支持多处存在
             point = options;
+            Object.assign(point, relationOptions);
         } else {
             point = Point.from({
                 ...pointOptions,
                 ...options,
-            }, this);
+            }, this, 'waypoints');
         }
-        Object.assign(point, relationOptions);
         this.waypoints.splice(index, 0, point);
         return point;
     }
@@ -387,34 +389,33 @@ export class ProcessElement extends BaseNode {
         return node;
     }
 
-
     getVariableExistingNames(excludedList: Array<Variable> = []) {
         const excludedSet = new Set(excludedList);
-        return this.variables.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.variables || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getVariableUniqueName(name = 'variable1') {
         return utils.unique(name, this.getVariableExistingNames());
     }
 
     /**
-    * 插入局部变量
-    * @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) {
@@ -425,22 +426,22 @@ export class ProcessElement extends BaseNode {
             variable = Variable.from({
                 ...variableOptions,
                 name: this.getVariableUniqueName(),
-            }, this);
+            }, this, 'variables');
         } else if (typeof options === 'string') {
             variable = Variable.from({
                 ...variableOptions,
                 name: options,
-            }, this);
+            }, this, 'variables');
         } else if (options instanceof Variable) {
             options.delete(); // 同一实例不支持多处存在
             variable = options;
+            Object.assign(variable, relationOptions);
         } else {
             variable = Variable.from({
                 ...variableOptions,
                 ...options,
-            }, this);
+            }, this, 'variables');
         }
-        Object.assign(variable, relationOptions);
         this.variables.splice(index, 0, variable);
         return variable;
     }
@@ -529,34 +530,33 @@ export class ProcessElement extends BaseNode {
         return node;
     }
 
-
     getReturnExistingNames(excludedList: Array<Return> = []) {
         const excludedSet = new Set(excludedList);
-        return this.returns.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.returns || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getReturnUniqueName(name = 'ret1') {
         return utils.unique(name, this.getReturnExistingNames());
     }
 
     /**
-    * 插入输出参数
-    * @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) {
@@ -567,22 +567,22 @@ export class ProcessElement extends BaseNode {
             ret = Return.from({
                 ...retOptions,
                 name: this.getReturnUniqueName(),
-            }, this);
+            }, this, 'returns');
         } else if (typeof options === 'string') {
             ret = Return.from({
                 ...retOptions,
                 name: options,
-            }, this);
+            }, this, 'returns');
         } else if (options instanceof Return) {
             options.delete(); // 同一实例不支持多处存在
             ret = options;
+            Object.assign(ret, relationOptions);
         } else {
             ret = Return.from({
                 ...retOptions,
                 ...options,
-            }, this);
+            }, this, 'returns');
         }
-        Object.assign(ret, relationOptions);
         this.returns.splice(index, 0, ret);
         return ret;
     }
@@ -671,34 +671,33 @@ export class ProcessElement extends BaseNode {
         return node;
     }
 
-
     getConstantExistingNames(excludedList: Array<Constant> = []) {
         const excludedSet = new Set(excludedList);
-        return this.constants.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.constants || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConstantUniqueName(name = 'constant1') {
         return utils.unique(name, this.getConstantExistingNames());
     }
 
     /**
-    * 插入常量
-    * @internal
-    * @param name 常量名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
     _insertConstantAt(name: string, index: number): Constant;
 
     /**
-    * 插入常量
-    * @internal
-    * @param constantOptions 常量参数
-    */
+     * 插入常量
+     * @internal
+     * @param constantOptions 常量参数
+     */
     _insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
 
     /**
-    * 插入常量
-    * @internal
-    * @param constant 已有的常量实例
-    */
+     * 插入常量
+     * @internal
+     * @param constant 已有的常量实例
+     */
     _insertConstantAt(constant: Constant, index: number): Constant;
 
     _insertConstantAt(options: string | Partial<Constant> | Constant, index: number) {
@@ -709,22 +708,22 @@ export class ProcessElement extends BaseNode {
             constant = Constant.from({
                 ...constantOptions,
                 name: this.getConstantUniqueName(),
-            }, this);
+            }, this, 'constants');
         } else if (typeof options === 'string') {
             constant = Constant.from({
                 ...constantOptions,
                 name: options,
-            }, this);
+            }, this, 'constants');
         } else if (options instanceof Constant) {
             options.delete(); // 同一实例不支持多处存在
             constant = options;
+            Object.assign(constant, relationOptions);
         } else {
             constant = Constant.from({
                 ...constantOptions,
                 ...options,
-            }, this);
+            }, this, 'constants');
         }
-        Object.assign(constant, relationOptions);
         this.constants.splice(index, 0, constant);
         return constant;
     }
@@ -813,34 +812,33 @@ export class ProcessElement extends BaseNode {
         return node;
     }
 
-
     getBindAttributeExistingNames(excludedList: Array<BindAttribute> = []) {
         const excludedSet = new Set(excludedList);
-        return this.bindAttrs.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.bindAttrs || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getBindAttributeUniqueName(name = 'bindAttribute1') {
         return utils.unique(name, this.getBindAttributeExistingNames());
     }
 
     /**
-    * 插入元素绑定属性
-    * @internal
-    * @param name 元素绑定属性名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入元素绑定属性
+     * @internal
+     * @param name 元素绑定属性名称，如果不填会自动生成一个唯一名称
+     */
     _insertBindAttributeAt(name: string, index: number): BindAttribute;
 
     /**
-    * 插入元素绑定属性
-    * @internal
-    * @param bindAttributeOptions 元素绑定属性参数
-    */
+     * 插入元素绑定属性
+     * @internal
+     * @param bindAttributeOptions 元素绑定属性参数
+     */
     _insertBindAttributeAt(bindAttributeOptions: Partial<BindAttribute>, index: number): BindAttribute;
 
     /**
-    * 插入元素绑定属性
-    * @internal
-    * @param bindAttribute 已有的元素绑定属性实例
-    */
+     * 插入元素绑定属性
+     * @internal
+     * @param bindAttribute 已有的元素绑定属性实例
+     */
     _insertBindAttributeAt(bindAttribute: BindAttribute, index: number): BindAttribute;
 
     _insertBindAttributeAt(options: string | Partial<BindAttribute> | BindAttribute, index: number) {
@@ -851,22 +849,22 @@ export class ProcessElement extends BaseNode {
             bindAttribute = BindAttribute.from({
                 ...bindAttributeOptions,
                 name: this.getBindAttributeUniqueName(),
-            }, this);
+            }, this, 'bindAttrs');
         } else if (typeof options === 'string') {
             bindAttribute = BindAttribute.from({
                 ...bindAttributeOptions,
                 name: options,
-            }, this);
+            }, this, 'bindAttrs');
         } else if (options instanceof BindAttribute) {
             options.delete(); // 同一实例不支持多处存在
             bindAttribute = options;
+            Object.assign(bindAttribute, relationOptions);
         } else {
             bindAttribute = BindAttribute.from({
                 ...bindAttributeOptions,
                 ...options,
-            }, this);
+            }, this, 'bindAttrs');
         }
-        Object.assign(bindAttribute, relationOptions);
         this.bindAttrs.splice(index, 0, bindAttribute);
         return bindAttribute;
     }
@@ -955,13 +953,10 @@ export class ProcessElement extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
-    * 删除矩形信息
-    * @param name 矩形信息名称
-    */
+     * 删除矩形信息
+     * @param name 矩形信息名称
+     */
     removeBounds(name: string): void;
 
     /**
@@ -1006,12 +1001,10 @@ export class ProcessElement extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除点信息
-    * @param name 点信息名称
-    */
+     * 删除点信息
+     * @param name 点信息名称
+     */
     removePoint(name: string): void;
 
     /**
@@ -1056,12 +1049,10 @@ export class ProcessElement extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除逻辑
-    * @param name 逻辑名称
-    */
+     * 删除逻辑
+     * @param name 逻辑名称
+     */
     removeLogic(name: string): void;
 
     /**
@@ -1106,12 +1097,10 @@ export class ProcessElement extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除局部变量
-    * @param name 局部变量名称
-    */
+     * 删除局部变量
+     * @param name 局部变量名称
+     */
     removeVariable(name: string): void;
 
     /**
@@ -1156,12 +1145,10 @@ export class ProcessElement extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除输出参数
-    * @param name 输出参数名称
-    */
+     * 删除输出参数
+     * @param name 输出参数名称
+     */
     removeReturn(name: string): void;
 
     /**
@@ -1206,12 +1193,10 @@ export class ProcessElement extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除常量
-    * @param name 常量名称
-    */
+     * 删除常量
+     * @param name 常量名称
+     */
     removeConstant(name: string): void;
 
     /**
@@ -1256,12 +1241,10 @@ export class ProcessElement extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除元素绑定属性
-    * @param name 元素绑定属性名称
-    */
+     * 删除元素绑定属性
+     * @param name 元素绑定属性名称
+     */
     removeBindAttribute(name: string): void;
 
     /**
@@ -1317,6 +1300,7 @@ export class ProcessElement extends BaseNode {
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
+        this.syncLogic();
         const tab0 = indent(state.tabSize);
         let code = '';
         this.variables.forEach((property) => {
@@ -1338,6 +1322,17 @@ export class ProcessElement extends BaseNode {
         return code;
     }
 
+    syncLogic() {
+        if (this.type === 'UserTask') {
+            if (!this.logic) {
+                this.logic = new Logic({
+                    name: `complete`,
+                });
+            }
+            this.logic.params = [...this.constants.map(constantToParam), ...this.returns.map(returnToParam)];
+        }
+    }
+
     /**
      * 设置流程元素名称
      */
@@ -1362,7 +1357,7 @@ export class ProcessElement extends BaseNode {
     //================================================================================
 }
 
-classMap['ProcessElement'] = ProcessElement;
+classMap.ProcessElement = ProcessElement;
 export default ProcessElement;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/ProcessOutcome__.ts

@@ -8,6 +8,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
@@ -23,12 +24,6 @@ export class ProcessOutcome extends LogicItem {
     @property()
     concept: 'ProcessOutcome' = 'ProcessOutcome';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Statement';
-
     /**
      * 判断结果标题
      */