@lcap/nasl 0.3.14 → 1.0.0-alpha.1

package/src/concepts/Logic__.ts

@@ -0,0 +1,1487 @@
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
+import Namespace from './Namespace__';
+import CallQueryComponent from './CallQueryComponent__';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property } from '../decorators';
+
+import * as utils from '../utils';
+import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
+import Transactional from './Transactional__';
+import TypeParam from './TypeParam__';
+import Param from './Param__';
+import Return from './Return__';
+import Variable from './Variable__';
+import LogicItem from './LogicItem__';
+import Module from './Module__';
+import View from './View__';
+import ProcessElement from './ProcessElement__';
+import App from './App__';
+import Process from './Process__';
+
+/**
+ * 逻辑
+ */
+@concept
+export class Logic extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'Logic' = 'Logic';
+
+    /**
+     * 逻辑名称
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 逻辑描述
+     */
+    @property()
+    description: string = undefined;
+
+    /**
+     * triggerType
+     */
+    @property()
+    triggerType: string = undefined;
+
+    /**
+     * cron
+     */
+    @property()
+    cron: string = undefined;
+
+    /**
+     * 事务
+     */
+    @property('Transactional')
+    transactional: Transactional = undefined;
+
+    /**
+     * 编译器信息
+     */
+    @property()
+    compilerInfoMap: { java?: { packageName: string, className: string } } = undefined;
+
+    /**
+     * 类型参数列表
+     */
+    @property('TypeParam')
+    typeParams: Array<TypeParam> = null;
+
+    /**
+     * 输入参数列表
+     */
+    @property('Param')
+    params: Array<Param> = [];
+
+    /**
+     * 输出参数列表
+     */
+    @property('Return')
+    returns: Array<Return> = [];
+
+    /**
+     * 局部变量列表
+     */
+    @property('Variable')
+    variables: Array<Variable> = [];
+
+    /**
+     * 逻辑项列表
+     */
+    @property('LogicItem')
+    body: Array<LogicItem> = [];
+
+    /**
+     * 逻辑项列表
+     */
+    @property('LogicItem')
+    playground: Array<LogicItem> = [];
+
+    /**
+     * 祖先 Module
+     */
+    get module() {
+        return this.getAncestor('Module') as Module;
+    }
+    /**
+     * 祖先 App
+     */
+    get app() {
+        return this.getAncestor('App') as App;
+    }
+    /**
+     * 祖先 View
+     */
+    get view() {
+        return this.getAncestor('View') as View;
+    }
+    /**
+     * 祖先 ProcessElement
+     */
+    get processElement() {
+        return this.getAncestor('ProcessElement') as ProcessElement;
+    }
+    /**
+     * 祖先 Process
+     */
+    get process() {
+        return this.getAncestor('Process') as Process;
+    }
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Logic>) {
+        source = Object.assign({}, Logic.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): Logic {
+        return super.from(source, parentNode, parentKey) as Logic;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeLogic?.(this);
+        }
+        return params;
+    }
+    /**
+     * 设置逻辑名称
+     */
+    setName(name: string) {
+        const object = {
+            name,
+        };
+        this.update({
+            ...object,
+            field: 'name',
+        });
+    }
+
+    /**
+     * 设置逻辑描述
+     */
+    setDescription(description: string) {
+        const object = {
+            description,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+        getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.typeParams.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getTypeParamUniqueName(name = 'typeParam1') {
+        return utils.unique(name, this.getTypeParamExistingNames());
+    }
+
+    /**
+    * 插入类型参数
+    * @internal
+    * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertTypeParamAt(name: string, index: number): TypeParam;
+
+    /**
+    * 插入类型参数
+    * @internal
+    * @param typeParamOptions 类型参数参数
+    */
+    _insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
+
+    /**
+    * 插入类型参数
+    * @internal
+    * @param typeParam 已有的类型参数实例
+    */
+    _insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
+
+    _insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
+        const typeParamOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'typeParams' };
+        let typeParam: TypeParam;
+        if (!options) {
+            typeParam = TypeParam.from({
+                ...typeParamOptions,
+                name: this.getTypeParamUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            typeParam = TypeParam.from({
+                ...typeParamOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof TypeParam) {
+            options.delete(); // 同一实例不支持多处存在
+            typeParam = options;
+        } else {
+            typeParam = TypeParam.from({
+                ...typeParamOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(typeParam, relationOptions);
+        this.typeParams.splice(index, 0, typeParam);
+        return typeParam;
+    }
+
+    /**
+     * 插入类型参数
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertTypeParamAt(name: string, index: number): TypeParam;
+
+    /**
+     * 插入类型参数
+     * @param typeParamOptions 类型参数参数
+     */
+    insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
+
+    /**
+     * 插入类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
+
+    insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
+        const node = this._insertTypeParamAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'typeParams',
+        });
+        return node;
+    }
+
+    /**
+     * 添加类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addTypeParam(name?: string): TypeParam;
+
+    /**
+     * 添加类型参数
+     * @internal
+     * @param typeParamOptions 类型参数参数
+     */
+    _addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
+
+    /**
+     * 添加类型参数
+     * @internal
+     * @param typeParam 已有的类型参数实例
+     */
+    _addTypeParam(typeParam: TypeParam): TypeParam;
+
+    _addTypeParam(options?: string | Partial<TypeParam> | TypeParam) {
+        const index = this.typeParams.length;
+        return this._insertTypeParamAt(options as any, index);
+    }
+
+    /**
+     * 添加类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    addTypeParam(name?: string): TypeParam;
+
+    /**
+     * 添加类型参数
+     * @param typeParamOptions 类型参数参数
+     */
+    addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
+
+    /**
+     * 添加类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    addTypeParam(typeParam: TypeParam): TypeParam;
+
+    addTypeParam(options?: string | Partial<TypeParam> | TypeParam) {
+        const node = this._addTypeParam(options as any);
+        const index = this.typeParams.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'typeParams',
+        });
+        return node;
+    }
+
+
+    getParamUniqueName(name = 'param1') {
+        return utils.unique(name, this.getVarExistingNames());
+    }
+
+    /**
+    * 插入输入参数
+    * @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);
+        } else if (typeof options === 'string') {
+            param = Param.from({
+                ...paramOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Param) {
+            options.delete(); // 同一实例不支持多处存在
+            param = options;
+        } else {
+            param = Param.from({
+                ...paramOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(param, relationOptions);
+        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;
+    }
+
+
+    getReturnUniqueName(name = 'result1') {
+        return utils.unique(name, this.getVarExistingNames());
+    }
+
+    /**
+    * 插入输出参数
+    * @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);
+        } else if (typeof options === 'string') {
+            ret = Return.from({
+                ...retOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Return) {
+            options.delete(); // 同一实例不支持多处存在
+            ret = options;
+        } else {
+            ret = Return.from({
+                ...retOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(ret, relationOptions);
+        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;
+    }
+
+
+    getVariableUniqueName(name = 'variable1') {
+        return utils.unique(name, this.getVarExistingNames());
+    }
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+    */
+    _insertVariableAt(name: string, index: number): Variable;
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param variableOptions 局部变量参数
+    */
+    _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param variable 已有的局部变量实例
+    */
+    _insertVariableAt(variable: Variable, index: number): Variable;
+
+    _insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
+        const variableOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'variables' };
+        let variable: Variable;
+        if (!options) {
+            variable = Variable.from({
+                ...variableOptions,
+                name: this.getVariableUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            variable = Variable.from({
+                ...variableOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Variable) {
+            options.delete(); // 同一实例不支持多处存在
+            variable = options;
+        } else {
+            variable = Variable.from({
+                ...variableOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(variable, relationOptions);
+        this.variables.splice(index, 0, variable);
+        return variable;
+    }
+
+    /**
+     * 插入局部变量
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    insertVariableAt(name: string, index: number): Variable;
+
+    /**
+     * 插入局部变量
+     * @param variableOptions 局部变量参数
+     */
+    insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+    /**
+     * 插入局部变量
+     * @param variable 已有的局部变量实例
+     */
+    insertVariableAt(variable: Variable, index: number): Variable;
+
+    insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
+        const node = this._insertVariableAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'variables',
+        });
+        return node;
+    }
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    _addVariable(name?: string): Variable;
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param variableOptions 局部变量参数
+     */
+    _addVariable(variableOptions: Partial<Variable>): Variable;
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param variable 已有的局部变量实例
+     */
+    _addVariable(variable: Variable): Variable;
+
+    _addVariable(options?: string | Partial<Variable> | Variable) {
+        const index = this.variables.length;
+        return this._insertVariableAt(options as any, index);
+    }
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    addVariable(name?: string): Variable;
+
+    /**
+     * 添加局部变量
+     * @param variableOptions 局部变量参数
+     */
+    addVariable(variableOptions: Partial<Variable>): Variable;
+
+    /**
+     * 添加局部变量
+     * @param variable 已有的局部变量实例
+     */
+    addVariable(variable: Variable): Variable;
+
+    addVariable(options?: string | Partial<Variable> | Variable) {
+        const node = this._addVariable(options as any);
+        const index = this.variables.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'variables',
+        });
+        return node;
+    }
+
+
+
+
+    
+
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItemOptions 逻辑项参数
+    */
+    _insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItem 已有的逻辑项实例
+    */
+    _insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
+
+    _insertItemInBodyAt(options: Partial<LogicItem> | LogicItem, index: number) {
+        const logicItemOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'body' };
+        let logicItem: LogicItem;
+        if (options instanceof LogicItem) {
+            options.delete(); // 同一实例不支持多处存在
+            logicItem = options;
+        } else {
+            logicItem = LogicItem.from({
+                ...logicItemOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(logicItem, relationOptions);
+        this.body.splice(index, 0, logicItem);
+        return logicItem;
+    }
+
+    
+
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
+
+    insertItemInBodyAt(options: Partial<LogicItem> | LogicItem, index: number) {
+        const node = this._insertItemInBodyAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'body',
+        });
+        return node;
+    }
+
+    
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInBody(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInBody(logicItem: LogicItem): LogicItem;
+
+    _addItemInBody(options?: Partial<LogicItem> | LogicItem) {
+        const index = this.body.length;
+        return this._insertItemInBodyAt(options as any, index);
+    }
+
+    
+
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInBody(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInBody(logicItem: LogicItem): LogicItem;
+
+    addItemInBody(options?: Partial<LogicItem> | LogicItem) {
+        const node = this._addItemInBody(options as any);
+        const index = this.body.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'body',
+        });
+        return node;
+    }
+
+    
+
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItemOptions 逻辑项参数
+    */
+    _insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItem 已有的逻辑项实例
+    */
+    _insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+
+    _insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+        const logicItemOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'playground' };
+        let logicItem: LogicItem;
+        if (options instanceof LogicItem) {
+            options.delete(); // 同一实例不支持多处存在
+            logicItem = options;
+        } else {
+            logicItem = LogicItem.from({
+                ...logicItemOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(logicItem, relationOptions);
+        this.playground.splice(index, 0, logicItem);
+        return logicItem;
+    }
+
+    
+
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+
+    insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+        const node = this._insertItemInPlaygroundAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'playground',
+        });
+        return node;
+    }
+
+    
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInPlayground(logicItem: LogicItem): LogicItem;
+
+    _addItemInPlayground(options?: Partial<LogicItem> | LogicItem) {
+        const index = this.playground.length;
+        return this._insertItemInPlaygroundAt(options as any, index);
+    }
+
+    
+
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInPlayground(logicItem: LogicItem): LogicItem;
+
+    addItemInPlayground(options?: Partial<LogicItem> | LogicItem) {
+        const node = this._addItemInPlayground(options as any);
+        const index = this.playground.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'playground',
+        });
+        return node;
+    }
+
+
+    
+
+    /**
+    * 删除事务
+    * @param name 事务名称
+    */
+    removeTransactional(name: string): void;
+
+    /**
+     * 删除事务
+     * @param transactional 已有的事务实例
+     */
+    removeTransactional(transactional: Transactional): void;
+
+    removeTransactional(options: string | Transactional) {
+        let transactional: Transactional;
+        if (typeof options === 'string') {
+            transactional = this.transactional;
+            if (!transactional) {
+                throw new Error('找不到事务 ' + options);
+            }
+        } else {
+            transactional = options;
+        }
+        return transactional.delete();
+    }
+
+    __removeTransactional(transactional: Transactional) {
+        const parentKey = transactional.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: transactional,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(transactional);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === transactional) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除类型参数
+    * @param name 类型参数名称
+    */
+    removeTypeParam(name: string): void;
+
+    /**
+     * 删除类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    removeTypeParam(typeParam: TypeParam): void;
+
+    removeTypeParam(options: string | TypeParam) {
+        let typeParam: TypeParam;
+        if (typeof options === 'string') {
+            typeParam = this.typeParams.find((item) => item.name === options);
+            if (!typeParam) {
+                throw new Error('找不到类型参数 ' + options);
+            }
+        } else {
+            typeParam = options;
+        }
+        return typeParam.delete();
+    }
+
+    __removeTypeParam(typeParam: TypeParam) {
+        const parentKey = typeParam.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: typeParam,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(typeParam);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === typeParam) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除输入参数
+    * @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 局部变量名称
+    */
+    removeVariable(name: string): void;
+
+    /**
+     * 删除局部变量
+     * @param variable 已有的局部变量实例
+     */
+    removeVariable(variable: Variable): void;
+
+    removeVariable(options: string | Variable) {
+        let variable: Variable;
+        if (typeof options === 'string') {
+            variable = this.variables.find((item) => item.name === options);
+            if (!variable) {
+                throw new Error('找不到局部变量 ' + options);
+            }
+        } else {
+            variable = options;
+        }
+        return variable.delete();
+    }
+
+    __removeVariable(variable: Variable) {
+        const parentKey = variable.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: variable,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(variable);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === variable) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInBody(logicItem: LogicItem): void;
+
+    removeItemInBody(options: LogicItem) {
+        let logicItem: LogicItem = options;
+        return logicItem.delete();
+    }
+
+    
+
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInPlayground(logicItem: LogicItem): void;
+
+    removeItemInPlayground(options: LogicItem) {
+        let logicItem: LogicItem = options;
+        return logicItem.delete();
+    }
+
+    __removeLogicItem(logicItem: LogicItem) {
+        const parentKey = logicItem.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: logicItem,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(logicItem);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === logicItem) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+
+    findLogicItemByConcept(concept: string) {
+        let result: any;
+
+        utils.traverse((current) => {
+            if ((current.node as any).concept === concept)
+                return (result = current.node);
+        }, { node: this }, {
+            mode: 'anyObject',
+            excludedKeySet: this.JSON_EXCLUDED_KEYS,
+        });
+
+        return result as LogicItem;
+    }
+
+    onChange($event?: EventPayload): void {
+        this.emit('change', $event);
+    }
+
+    getVarExistingNames(excludedList: Array<Param | Return | Variable> = []) {
+        const excludedSet = new Set(excludedList);
+        return [...this.params, ...this.returns, ...this.variables].filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+
+    toUI(state?: TranslatorState): string {
+        let code = `function ${this.name}(`;
+
+        this.params.forEach((param, index) => {
+            code += param.toUI(shiftState(state, code, { inline: true }));
+            if (index !== this.params.length - 1)
+                code += ', ';
+        });
+        code += `) {\n`;
+
+        this.variables.forEach((variable) => {
+            code += indent(state.tabSize + 1) + 'let ';
+            code += variable.toUI(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+
+        this.returns.forEach((ret) => {
+            code += indent(state.tabSize + 1) + 'let ';
+            code += ret.toUI(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+
+        if (!this.body.length && this.returns.length) {
+            code += indent(state.tabSize + 1) + `return ${this.returns[0].name};\n`;
+        } else {
+            this.body.forEach((item) => {
+                code += item.toUI && item.toUI(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+                code += '\n';
+            });
+        }
+
+        code += indent(state.tabSize) + '}\n';
+        return code;
+    }
+
+    toJS(state?: TranslatorState): string {
+        let code = `methods['${this.name}'] = async function (`;
+        if (Array.isArray(this.params)) {
+            this.params.forEach((param, index) => {
+                code += param.toJS(shiftState(state, code, { inline: true }));
+                if (index !== this.params.length - 1)
+                    code += ', ';
+            });
+        }
+        code += `) {\n`;
+        if (Array.isArray(this.variables)) {
+            this.variables.forEach((variable) => {
+                code += indent(state.tabSize + 1) + 'let ';
+                code += variable.toJS(shiftState(state, code, { inline: true }));
+                code += ';\n';
+            });
+        }
+        if (Array.isArray(this.returns)) {
+            this.returns.forEach((ret) => {
+                code += indent(state.tabSize + 1) + 'let ';
+                code += ret.toJS(shiftState(state, code, { inline: true }));
+                code += ';\n';
+            });
+        }
+        if (!this.body.length && this.returns.length) {
+            code += indent(state.tabSize + 1) + `return ${this.returns[0].name};\n`;
+        } else {
+            this.body.forEach((item) => {
+                code += item.toJS && item.toJS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+                code += '\n';
+            });
+        }
+        code += indent(state.tabSize) + '}\n';
+        return code;
+    }
+
+    toEmbeddedTSNoExport(state?: TranslatorState): string {
+        return this.toEmbeddedTS(state, 'noExport');
+    }
+
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState, prefix?: string): string {
+        // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
+        const funcPrefix = prefix === 'noExport' ? '' : 'export';
+        let code = `${funcPrefix} function ${this.name}(`;
+        this.params.forEach((param, index) => {
+            code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            if (index !== this.params.length - 1)
+                code += ', ';
+        });
+        code += `) {\n`;
+
+        this.variables.forEach((variable) => {
+            code += indent(state.tabSize + 1) + 'let ';
+            code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+
+        this.returns.forEach((ret) => {
+            code += indent(state.tabSize + 1) + 'let ';
+            code += ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+
+        if (!this.body.length && this.returns.length) {
+            code += indent(state.tabSize + 1) + `return ${this.returns[0].name};\n`;
+        } else {
+            this.body.forEach((item) => {
+                code += item.toEmbeddedTS && item.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+                code += '\n';
+            });
+        }
+
+        // 在body渲染完成之后把其余的节点放到下面
+        this.playground.forEach((item) => {
+            code += item.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+            code += '\n';
+        });
+
+        code += indent(state.tabSize) + '}\n';
+        return code;
+    }
+
+    getNamespace(): string {
+        if (this.parentNode) {
+            let parentNodeNamespace = '';
+            if ((this.parentNode as Namespace).getNamespace) {
+                parentNodeNamespace = (this.parentNode as Namespace).getNamespace();
+            } else if ((this.parentNode as View).getNamespace) {
+                parentNodeNamespace = `${(this.parentNode as View).getNamespace()}.${this.parentNode.name}`;
+            }
+            return parentNodeNamespace.includes('.logics.') ? parentNodeNamespace : `${parentNodeNamespace}.logics`;
+        } else
+            throw new Error('无法获取命名空间，请设置 parentNode！');
+    }
+
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name = this.name) {
+        return `/embedded/${this.app.name}/logics/${name}.ts`;
+    }
+
+    get calleeKey(): string {
+        return `${this.getNamespace()}.${this.name}`;
+    }
+
+    toEmbeddedTSFile() {
+        let code = `namespace ${this.getNamespace()} {\n`;
+
+        const state = createCompilerState(code, { tabSize: 1 });
+        code += this.toEmbeddedTS(state);
+        code += '}\n';
+        return {
+            code,
+            filePath: this.getEmbeddedFilePath(),
+            sourceMap: state.sourceMap,
+        };
+    }
+
+    public static getDefaultOptions() {
+        return {
+            body: [
+                {
+                    concept: 'Start',
+                    label: '开始',
+                    kind: 'Statement',
+                    type: 'Start',
+                },
+                {
+                    concept: 'End',
+                    label: '结束',
+                    kind: 'Statement',
+                    type: 'End',
+                },
+            ],
+        };
+    }
+
+    async saveStructureOfCallQueryComponents(root?: BaseNode | Logic) {
+        if (!root)
+            root = this;
+        const set = new Set();
+        utils.traverse(({ node }) => {
+            if (node instanceof CallQueryComponent) {
+                set.add(node);
+            }
+        }, { node: root }, {
+            mode: 'anyObject',
+            excludedKeySet: new Set(['parentNode']),
+        });
+        for (const node of set) {
+            (<CallQueryComponent>node).saveStructure();
+        }
+    }
+
+    fake: boolean;
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap['Logic'] = Logic;
+export default Logic;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================