@lcap/nasl 0.3.15 → 1.0.0-alpha.10

package/src/concepts/Process__.ts

@@ -0,0 +1,1154 @@
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
+import { process2LogicNamespace, genLaunchProcess, genUserTaskLogic, userTask2LogicNamespace } from '../server/getProcesses';
+
+import Namespace from './Namespace__';
+import Logic from './Logic__';
+import Variable from './Variable__';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+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 Param from './Param__';
+import Return from './Return__';
+import Constant from './Constant__';
+import ProcessElement from './ProcessElement__';
+import Module from './Module__';
+import App from './App__';
+
+/**
+ * 流程
+ */
+@concept('流程')
+export class Process extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'Process' = 'Process';
+
+    /**
+     * 流程名称
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 流程标题
+     */
+    @property()
+    title: string = undefined;
+
+    /**
+     * 流程描述
+     */
+    @property()
+    description: string = undefined;
+
+    /**
+     * 输入参数列表
+     */
+    @property('Param')
+    params: Array<Param> = [];
+
+    /**
+     * 输出参数列表
+     */
+    @property('Return')
+    returns: Array<Return> = [];
+
+    /**
+     * 常量列表
+     */
+    @property('Constant')
+    constants: Array<Constant> = [];
+
+    /**
+     * 流程元素列表
+     */
+    @property('ProcessElement')
+    elements: Array<ProcessElement> = [];
+
+    /**
+     * 祖先 Module
+     */
+    get module() {
+        return this.getAncestor('Module') as Module;
+    }
+    /**
+     * 祖先 App
+     */
+    get app() {
+        return this.getAncestor('App') as App;
+    }
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Process>) {
+        source = Object.assign({}, Process.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): Process {
+        return super.from(source, parentNode, parentKey) as Process;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeProcess?.(this);
+        }
+        return params;
+    }
+    /**
+     * 设置流程名称
+     */
+    setName(name: string) {
+        const object = {
+            name,
+        };
+        this.update({
+            ...object,
+            field: 'name',
+        });
+    }
+
+    /**
+     * 设置流程标题
+     */
+    setTitle(title: string) {
+        const object = {
+            title,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置流程描述
+     */
+    setDescription(description: string) {
+        const object = {
+            description,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+        getParamExistingNames(excludedList: Array<Param> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.params || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getParamUniqueName(name = 'param1') {
+        return utils.unique(name, this.getParamExistingNames());
+    }
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertParamAt(name: string, index: number): Param;
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param paramOptions 输入参数参数
+    */
+    _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+    /**
+    * 插入输入参数
+    * @internal
+    * @param param 已有的输入参数实例
+    */
+    _insertParamAt(param: Param, index: number): Param;
+
+    _insertParamAt(options: string | Partial<Param> | Param, index: number) {
+        const paramOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'params' };
+        let param: Param;
+        if (!options) {
+            param = Param.from({
+                ...paramOptions,
+                name: this.getParamUniqueName(),
+            }, this, 'params');
+        } else if (typeof options === 'string') {
+            param = Param.from({
+                ...paramOptions,
+                name: options,
+            }, this, 'params');
+        } else if (options instanceof Param) {
+            options.delete(); // 同一实例不支持多处存在
+            param = options;
+            Object.assign(param, relationOptions);
+        } else {
+            param = Param.from({
+                ...paramOptions,
+                ...options,
+            }, this, 'params');
+        }
+        this.params.splice(index, 0, param);
+        return param;
+    }
+
+    /**
+     * 插入输入参数
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertParamAt(name: string, index: number): Param;
+
+    /**
+     * 插入输入参数
+     * @param paramOptions 输入参数参数
+     */
+    insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+    /**
+     * 插入输入参数
+     * @param param 已有的输入参数实例
+     */
+    insertParamAt(param: Param, index: number): Param;
+
+    insertParamAt(options: string | Partial<Param> | Param, index: number) {
+        const node = this._insertParamAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'params',
+        });
+        return node;
+    }
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addParam(name?: string): Param;
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
+    _addParam(paramOptions: Partial<Param>): Param;
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
+    _addParam(param: Param): Param;
+
+    _addParam(options?: string | Partial<Param> | Param) {
+        const index = this.params.length;
+        return this._insertParamAt(options as any, index);
+    }
+
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    addParam(name?: string): Param;
+
+    /**
+     * 添加输入参数
+     * @param paramOptions 输入参数参数
+     */
+    addParam(paramOptions: Partial<Param>): Param;
+
+    /**
+     * 添加输入参数
+     * @param param 已有的输入参数实例
+     */
+    addParam(param: Param): Param;
+
+    addParam(options?: string | Partial<Param> | Param) {
+        const node = this._addParam(options as any);
+        const index = this.params.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'params',
+        });
+        return node;
+    }
+
+
+    getReturnExistingNames(excludedList: Array<Return> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.returns || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getReturnUniqueName(name = 'ret1') {
+        return utils.unique(name, this.getReturnExistingNames());
+    }
+
+    /**
+    * 插入输出参数
+    * @internal
+    * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertReturnAt(name: string, index: number): Return;
+
+    /**
+    * 插入输出参数
+    * @internal
+    * @param retOptions 输出参数参数
+    */
+    _insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+
+    /**
+    * 插入输出参数
+    * @internal
+    * @param ret 已有的输出参数实例
+    */
+    _insertReturnAt(ret: Return, index: number): Return;
+
+    _insertReturnAt(options: string | Partial<Return> | Return, index: number) {
+        const retOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'returns' };
+        let ret: Return;
+        if (!options) {
+            ret = Return.from({
+                ...retOptions,
+                name: this.getReturnUniqueName(),
+            }, this, 'returns');
+        } else if (typeof options === 'string') {
+            ret = Return.from({
+                ...retOptions,
+                name: options,
+            }, this, 'returns');
+        } else if (options instanceof Return) {
+            options.delete(); // 同一实例不支持多处存在
+            ret = options;
+            Object.assign(ret, relationOptions);
+        } else {
+            ret = Return.from({
+                ...retOptions,
+                ...options,
+            }, this, 'returns');
+        }
+        this.returns.splice(index, 0, ret);
+        return ret;
+    }
+
+    /**
+     * 插入输出参数
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertReturnAt(name: string, index: number): Return;
+
+    /**
+     * 插入输出参数
+     * @param retOptions 输出参数参数
+     */
+    insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+
+    /**
+     * 插入输出参数
+     * @param ret 已有的输出参数实例
+     */
+    insertReturnAt(ret: Return, index: number): Return;
+
+    insertReturnAt(options: string | Partial<Return> | Return, index: number) {
+        const node = this._insertReturnAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'returns',
+        });
+        return node;
+    }
+
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addReturn(name?: string): Return;
+
+    /**
+     * 添加输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
+    _addReturn(retOptions: Partial<Return>): Return;
+
+    /**
+     * 添加输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
+    _addReturn(ret: Return): Return;
+
+    _addReturn(options?: string | Partial<Return> | Return) {
+        const index = this.returns.length;
+        return this._insertReturnAt(options as any, index);
+    }
+
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    addReturn(name?: string): Return;
+
+    /**
+     * 添加输出参数
+     * @param retOptions 输出参数参数
+     */
+    addReturn(retOptions: Partial<Return>): Return;
+
+    /**
+     * 添加输出参数
+     * @param ret 已有的输出参数实例
+     */
+    addReturn(ret: Return): Return;
+
+    addReturn(options?: string | Partial<Return> | Return) {
+        const node = this._addReturn(options as any);
+        const index = this.returns.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'returns',
+        });
+        return node;
+    }
+
+
+    getConstantExistingNames(excludedList: Array<Constant> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.constants || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getConstantUniqueName(name = 'constant1') {
+        return utils.unique(name, this.getConstantExistingNames());
+    }
+
+    /**
+    * 插入常量
+    * @internal
+    * @param name 常量名称，如果不填会自动生成一个唯一名称
+    */
+    _insertConstantAt(name: string, index: number): Constant;
+
+    /**
+    * 插入常量
+    * @internal
+    * @param constantOptions 常量参数
+    */
+    _insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
+
+    /**
+    * 插入常量
+    * @internal
+    * @param constant 已有的常量实例
+    */
+    _insertConstantAt(constant: Constant, index: number): Constant;
+
+    _insertConstantAt(options: string | Partial<Constant> | Constant, index: number) {
+        const constantOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'constants' };
+        let constant: Constant;
+        if (!options) {
+            constant = Constant.from({
+                ...constantOptions,
+                name: this.getConstantUniqueName(),
+            }, this, 'constants');
+        } else if (typeof options === 'string') {
+            constant = Constant.from({
+                ...constantOptions,
+                name: options,
+            }, this, 'constants');
+        } else if (options instanceof Constant) {
+            options.delete(); // 同一实例不支持多处存在
+            constant = options;
+            Object.assign(constant, relationOptions);
+        } else {
+            constant = Constant.from({
+                ...constantOptions,
+                ...options,
+            }, this, 'constants');
+        }
+        this.constants.splice(index, 0, constant);
+        return constant;
+    }
+
+    /**
+     * 插入常量
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    insertConstantAt(name: string, index: number): Constant;
+
+    /**
+     * 插入常量
+     * @param constantOptions 常量参数
+     */
+    insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
+
+    /**
+     * 插入常量
+     * @param constant 已有的常量实例
+     */
+    insertConstantAt(constant: Constant, index: number): Constant;
+
+    insertConstantAt(options: string | Partial<Constant> | Constant, index: number) {
+        const node = this._insertConstantAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'constants',
+        });
+        return node;
+    }
+
+    /**
+     * 添加常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    _addConstant(name?: string): Constant;
+
+    /**
+     * 添加常量
+     * @internal
+     * @param constantOptions 常量参数
+     */
+    _addConstant(constantOptions: Partial<Constant>): Constant;
+
+    /**
+     * 添加常量
+     * @internal
+     * @param constant 已有的常量实例
+     */
+    _addConstant(constant: Constant): Constant;
+
+    _addConstant(options?: string | Partial<Constant> | Constant) {
+        const index = this.constants.length;
+        return this._insertConstantAt(options as any, index);
+    }
+
+    /**
+     * 添加常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    addConstant(name?: string): Constant;
+
+    /**
+     * 添加常量
+     * @param constantOptions 常量参数
+     */
+    addConstant(constantOptions: Partial<Constant>): Constant;
+
+    /**
+     * 添加常量
+     * @param constant 已有的常量实例
+     */
+    addConstant(constant: Constant): Constant;
+
+    addConstant(options?: string | Partial<Constant> | Constant) {
+        const node = this._addConstant(options as any);
+        const index = this.constants.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'constants',
+        });
+        return node;
+    }
+
+
+    getElementExistingNames(excludedList: Array<ProcessElement> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.elements || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getElementUniqueName(name = 'element1') {
+        return utils.unique(name, this.getElementExistingNames());
+    }
+
+    /**
+    * 插入流程元素
+    * @internal
+    * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+    */
+    _insertElementAt(name: string, index: number): ProcessElement;
+
+    /**
+    * 插入流程元素
+    * @internal
+    * @param elementOptions 流程元素参数
+    */
+    _insertElementAt(elementOptions: Partial<ProcessElement>, index: number): ProcessElement;
+
+    /**
+    * 插入流程元素
+    * @internal
+    * @param element 已有的流程元素实例
+    */
+    _insertElementAt(element: ProcessElement, index: number): ProcessElement;
+
+    _insertElementAt(options: string | Partial<ProcessElement> | ProcessElement, index: number) {
+        const elementOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'elements' };
+        let element: ProcessElement;
+        if (!options) {
+            element = ProcessElement.from({
+                ...elementOptions,
+                name: this.getElementUniqueName(),
+            }, this, 'elements');
+        } else if (typeof options === 'string') {
+            element = ProcessElement.from({
+                ...elementOptions,
+                name: options,
+            }, this, 'elements');
+        } else if (options instanceof ProcessElement) {
+            options.delete(); // 同一实例不支持多处存在
+            element = options;
+            Object.assign(element, relationOptions);
+        } else {
+            element = ProcessElement.from({
+                ...elementOptions,
+                ...options,
+            }, this, 'elements');
+        }
+        this.elements.splice(index, 0, element);
+        return element;
+    }
+
+    /**
+     * 插入流程元素
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    insertElementAt(name: string, index: number): ProcessElement;
+
+    /**
+     * 插入流程元素
+     * @param elementOptions 流程元素参数
+     */
+    insertElementAt(elementOptions: Partial<ProcessElement>, index: number): ProcessElement;
+
+    /**
+     * 插入流程元素
+     * @param element 已有的流程元素实例
+     */
+    insertElementAt(element: ProcessElement, index: number): ProcessElement;
+
+    insertElementAt(options: string | Partial<ProcessElement> | ProcessElement, index: number) {
+        const node = this._insertElementAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'elements',
+        });
+        return node;
+    }
+
+    /**
+     * 添加流程元素
+     * @internal
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    _addElement(name?: string): ProcessElement;
+
+    /**
+     * 添加流程元素
+     * @internal
+     * @param elementOptions 流程元素参数
+     */
+    _addElement(elementOptions: Partial<ProcessElement>): ProcessElement;
+
+    /**
+     * 添加流程元素
+     * @internal
+     * @param element 已有的流程元素实例
+     */
+    _addElement(element: ProcessElement): ProcessElement;
+
+    _addElement(options?: string | Partial<ProcessElement> | ProcessElement) {
+        const index = this.elements.length;
+        return this._insertElementAt(options as any, index);
+    }
+
+    /**
+     * 添加流程元素
+     * @internal
+     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
+     */
+    addElement(name?: string): ProcessElement;
+
+    /**
+     * 添加流程元素
+     * @param elementOptions 流程元素参数
+     */
+    addElement(elementOptions: Partial<ProcessElement>): ProcessElement;
+
+    /**
+     * 添加流程元素
+     * @param element 已有的流程元素实例
+     */
+    addElement(element: ProcessElement): ProcessElement;
+
+    addElement(options?: string | Partial<ProcessElement> | ProcessElement) {
+        const node = this._addElement(options as any);
+        const index = this.elements.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'elements',
+        });
+        return node;
+    }
+
+
+    
+
+    /**
+    * 删除输入参数
+    * @param name 输入参数名称
+    */
+    removeParam(name: string): void;
+
+    /**
+     * 删除输入参数
+     * @param param 已有的输入参数实例
+     */
+    removeParam(param: Param): void;
+
+    removeParam(options: string | Param) {
+        let param: Param;
+        if (typeof options === 'string') {
+            param = this.params.find((item) => item.name === options);
+            if (!param) {
+                throw new Error('找不到输入参数 ' + options);
+            }
+        } else {
+            param = options;
+        }
+        return param.delete();
+    }
+
+    __removeParam(param: Param) {
+        const parentKey = param.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: param,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(param);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === param) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除输出参数
+    * @param name 输出参数名称
+    */
+    removeReturn(name: string): void;
+
+    /**
+     * 删除输出参数
+     * @param ret 已有的输出参数实例
+     */
+    removeReturn(ret: Return): void;
+
+    removeReturn(options: string | Return) {
+        let ret: Return;
+        if (typeof options === 'string') {
+            ret = this.returns.find((item) => item.name === options);
+            if (!ret) {
+                throw new Error('找不到输出参数 ' + options);
+            }
+        } else {
+            ret = options;
+        }
+        return ret.delete();
+    }
+
+    __removeReturn(ret: Return) {
+        const parentKey = ret.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: ret,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(ret);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === ret) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除常量
+    * @param name 常量名称
+    */
+    removeConstant(name: string): void;
+
+    /**
+     * 删除常量
+     * @param constant 已有的常量实例
+     */
+    removeConstant(constant: Constant): void;
+
+    removeConstant(options: string | Constant) {
+        let constant: Constant;
+        if (typeof options === 'string') {
+            constant = this.constants.find((item) => item.name === options);
+            if (!constant) {
+                throw new Error('找不到常量 ' + options);
+            }
+        } else {
+            constant = options;
+        }
+        return constant.delete();
+    }
+
+    __removeConstant(constant: Constant) {
+        const parentKey = constant.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: constant,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(constant);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === constant) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除流程元素
+    * @param name 流程元素名称
+    */
+    removeElement(name: string): void;
+
+    /**
+     * 删除流程元素
+     * @param element 已有的流程元素实例
+     */
+    removeElement(element: ProcessElement): void;
+
+    removeElement(options: string | ProcessElement) {
+        let element: ProcessElement;
+        if (typeof options === 'string') {
+            element = this.elements.find((item) => item.name === options);
+            if (!element) {
+                throw new Error('找不到流程元素 ' + options);
+            }
+        } else {
+            element = options;
+        }
+        return element.delete();
+    }
+
+    __removeProcessElement(element: ProcessElement) {
+        const parentKey = element.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: element,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(element);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === element) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    onChange($event?: EventPayload): void {
+        this.emit('change', $event);
+    }
+
+    _removeElement(element: ProcessElement) {
+        const params = {
+            propertyName: 'elements',
+            index: -1,
+        };
+        const id = element.id;
+        const index = this.elements.indexOf(element);
+        ~index && this.elements.splice(index, 1);
+        if (element.type !== 'SequenceFlow') {
+            const links: Array<ProcessElement> = [];
+            this.elements.forEach((c) => {
+                if (c.type === 'SequenceFlow' && (c.sourceRef === id || c.targetRef === id)) {
+                    links.push(c);
+                }
+            });
+            links.forEach((l) => {
+                l.delete();
+            });
+        }
+        params.index = index;
+        return params;
+    }
+
+    getVarExistingNames(excludedList: Array<Param | Return | Constant> = []) {
+        const excludedSet = new Set(excludedList);
+        return [...this.params, ...this.returns, ...this.constants].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
+            throw new Error('无法获取命名空间，请设置 parentNode！');
+    }
+
+    getEmbeddedFilePath(name = this.name) {
+        return `/embedded/${this.app.name}/processes/${name}.ts`;
+    }
+
+    genExclusiveGatewayLogic(elem: ProcessElement) {
+        const l = BaseNode.from(elem.logic) as Logic;
+        elem.variables.forEach((v) => {
+            const pv = BaseNode.from(v) as Variable;
+            l._addVariable(pv);
+        });
+        return l;
+    }
+
+    get logics() {
+        return [genLaunchProcess(this)];
+    }
+
+    @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);
+        // code += `${tab1}namespace variables{\n`;
+        this.params.forEach((property) => {
+            code += `${tab1}export let `;
+            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+
+        this.returns.forEach((property) => {
+            code += `${tab1}export let `;
+            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+        this.constants.forEach((property) => {
+            code += `${tab1}export let `;
+            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+
+
+        // code += `${tab1}}\n`;
+
+        // this.elements.forEach((ele) => {
+        //     if (ele.type === 'UserTask') {
+        //         code += `${tab1}${ele.name}: nasl.process.UserTask;\n`;
+        //     }
+        // });
+
+        // code += `${tab1}constructor(`;
+        // this.params.forEach((param, index) => {
+        //     code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        //     if (index !== this.params.length - 1)
+        //         code += ', ';
+        // });
+        // code += `) {\n`;
+
+        code += `${tab1}export namespace logics {\n`;
+        const logic = genLaunchProcess(this);
+        code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 3 }));
+        code += `${tab1}}\n`;
+
+        code += `${tab1}export namespace elements {\n`
+        this.elements.forEach((ele) => {
+            if (ele.type === 'UserTask') {
+                code += `${tab2}export namespace ${ele.name}{\n`;
+                code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+                ele.bindAttrs.forEach((attr) => {
+                    if(attr.name === 'destination') {
+                        code += attr.destination.toEmbeddedTSNormalFunction(shiftState(state, code, { tabSize: state.tabSize + 2 }))
+                    } else {
+                        code += attr.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize }));
+                    }
+                });
+
+                const logic = genUserTaskLogic(ele);
+                code += `${tab3}export namespace logics {\n`;
+
+                code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 4 }));
+
+                code += `${tab3}}\n`;
+
+                code += `${tab2}}\n`;
+
+                
+            }
+            if (ele.type === 'ExclusiveGateway') {
+                code += `${tab2}export namespace ${ele.name}{\n`;
+                code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+                code += ele.logic.toEmbeddedTSNoExport(shiftState(state, code, { tabSize: state.tabSize + 3 }));
+                code += `${tab2}}\n`;
+            }
+        });
+        code += `${tab1}}\n`;
+
+        // code += `${tab1}}\n`;
+        code += `${tab0}}\n`;
+        return code;
+    }
+
+    toEmbeddedTSFile() {
+        let code = `namespace ${this.getNamespace('processes')} {\n`;
+
+        const state = createCompilerState(code, { tabSize: 1 });
+        const tab1 = indent(state.tabSize);
+        code += this.toEmbeddedTS(state);
+        code += '}\n';
+
+        /* const ns = process2LogicNamespace(this);
+        ns.path = `${this.getNamespace('logics')}.${ns.name}`;
+        code += `\nnamespace ${ns.path} {\n`;
+        ns.logics.forEach((logic) => {
+            code += logic.toEmbeddedTS(shiftState(state, code)) + '\n';
+        });
+        this.elements.forEach((ele) => {
+            if (ele.type === 'UserTask') {
+                const uns = userTask2LogicNamespace(ele);
+                code += `${tab1}export namespace ${uns.name} {\n`;
+
+                uns.logics.forEach((logic) => {
+                    code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+                });
+
+                code += `${tab1}}\n`;
+            }
+        });
+
+        code += '}\n';*/
+
+        return {
+            code,
+            filePath: this.getEmbeddedFilePath(),
+            sourceMap: state.sourceMap,
+        };
+    }
+
+    public static getDefaultOptions() {
+        return {
+            constants: [
+                {
+                    concept: 'Constant',
+                    name: 'processId',
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeNamespace: 'nasl.core',
+                        typeName: 'String',
+                    },
+                },
+            ],
+            elements: [
+                {
+                    concept: 'ProcessElement',
+                    name: 'start',
+                    type: 'StartNoneEvent',
+                    bounds: {
+                        concept: 'Rect',
+                        x: 0, y: 0
+                    }
+                },
+                {
+                    concept: 'ProcessElement',
+                    name: 'end',
+                    type: 'EndNoneEvent',
+                    bounds: {
+                        concept: 'Rect',
+                        x: 0, y: 180
+                    }
+                },
+                {
+                    concept: 'ProcessElement',
+                    type: 'SequenceFlow',
+                    sourceRef: 'start',
+                    targetRef: 'end',
+                },
+            ]
+        };
+    }
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap['Process'] = Process;
+export default Process;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================