@lcap/nasl 0.3.15-beta → 1.0.0-alpha.2

package/src/concepts/Module__.ts

@@ -0,0 +1,1706 @@
+type PropertyType = 'structures' | 'enums' | 'entities' | 'interfaces' | 'processes' | 'views';
+const moduleNameSpace = {
+    dependencies: 'extensions',
+    interfaceDependencies: 'interfaces',
+    componentDependencies: 'components',
+};
+type ModuleKeyType = 'dependencies' | 'interfaceDependencies' | 'componentDependencies';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 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 Entity from './Entity__';
+import Structure from './Structure__';
+import Enum from './Enum__';
+import Logic from './Logic__';
+import Interface from './Interface__';
+import View from './View__';
+import Process from './Process__';
+import ViewComponent from './ViewComponent__';
+import App from './App__';
+
+/**
+ * 模块
+ */
+@concept
+export class Module extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'Module' = 'Module';
+
+    /**
+     * type
+     */
+    @property()
+    type: 'extension' | 'interface' | 'component' = undefined;
+
+    /**
+     * version
+     */
+    @property()
+    version: string = undefined;
+
+    /**
+     * 模块名称
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 模块标题
+     */
+    @property()
+    title: string = undefined;
+
+    /**
+     * 模块描述
+     */
+    @property()
+    description: string = undefined;
+
+    /**
+     * 外部语言依赖
+     */
+    @property()
+    externalDependencyMap: { maven?: Array<{ groupId: string; artifactId: string; version: string }> } = undefined;
+
+    /**
+     * 实体列表
+     */
+    @property('Entity')
+    entities: Array<Entity> = [];
+
+    /**
+     * 数据结构列表
+     */
+    @property('Structure')
+    structures: Array<Structure> = [];
+
+    /**
+     * 枚举列表
+     */
+    @property('Enum')
+    enums: Array<Enum> = [];
+
+    /**
+     * 逻辑列表
+     */
+    @property('Logic')
+    logics: Array<Logic> = [];
+
+    /**
+     * 接口列表
+     */
+    @property('Interface')
+    interfaces: Array<Interface> = [];
+
+    /**
+     * 页面列表
+     */
+    @property('View')
+    views: Array<View> = [];
+
+    /**
+     * 流程列表
+     */
+    @property('Process')
+    processes: Array<Process> = [];
+
+    /**
+     * 页面组件列表
+     */
+    @property('ViewComponent')
+    viewComponents: Array<ViewComponent> = [];
+
+    /**
+     * 祖先 App
+     */
+    get app() {
+        return this.getAncestor('App') as App;
+    }
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Module>) {
+        source = Object.assign({}, Module.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): Module {
+        return super.from(source, parentNode, parentKey) as Module;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeModule?.(this);
+        }
+        return params;
+    }
+
+    getEntityExistingNames(excludedList: Array<Entity> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.entities.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getEntityUniqueName(name = 'Entity1') {
+        return utils.unique(name, this.getEntityExistingNames());
+    }
+
+    /**
+     * 插入实体
+     * @internal
+     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     */
+    _insertEntityAt(name: string, index: number): Entity;
+
+    /**
+     * 插入实体
+     * @internal
+     * @param entityOptions 实体参数
+     */
+    _insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
+
+    /**
+     * 插入实体
+     * @internal
+     * @param entity 已有的实体实例
+     */
+    _insertEntityAt(entity: Entity, index: number): Entity;
+
+    _insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
+        const entityOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'entities' };
+        let entity: Entity;
+        if (!options) {
+            entity = Entity.from({
+                ...entityOptions,
+                name: this.getEntityUniqueName(),
+            }, this, 'entities');
+        } else if (typeof options === 'string') {
+            entity = Entity.from({
+                ...entityOptions,
+                name: options,
+            }, this, 'entities');
+        } else if (options instanceof Entity) {
+            options.delete(); // 同一实例不支持多处存在
+            entity = options;
+            Object.assign(entity, relationOptions);
+        } else {
+            entity = Entity.from({
+                ...entityOptions,
+                ...options,
+            }, this, 'entities');
+        }
+        this.entities.splice(index, 0, entity);
+        return entity;
+    }
+
+    /**
+     * 插入实体
+     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     */
+    insertEntityAt(name: string, index: number): Entity;
+
+    /**
+     * 插入实体
+     * @param entityOptions 实体参数
+     */
+    insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
+
+    /**
+     * 插入实体
+     * @param entity 已有的实体实例
+     */
+    insertEntityAt(entity: Entity, index: number): Entity;
+
+    insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
+        const node = this._insertEntityAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'entities',
+        });
+        return node;
+    }
+
+    /**
+     * 添加实体
+     * @internal
+     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     */
+    _addEntity(name?: string): Entity;
+
+    /**
+     * 添加实体
+     * @internal
+     * @param entityOptions 实体参数
+     */
+    _addEntity(entityOptions: Partial<Entity>): Entity;
+
+    /**
+     * 添加实体
+     * @internal
+     * @param entity 已有的实体实例
+     */
+    _addEntity(entity: Entity): Entity;
+
+    _addEntity(options?: string | Partial<Entity> | Entity) {
+        const index = 0;
+        return this._insertEntityAt(options as any, index);
+    }
+
+    /**
+     * 添加实体
+     * @internal
+     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     */
+    addEntity(name?: string): Entity;
+
+    /**
+     * 添加实体
+     * @param entityOptions 实体参数
+     */
+    addEntity(entityOptions: Partial<Entity>): Entity;
+
+    /**
+     * 添加实体
+     * @param entity 已有的实体实例
+     */
+    addEntity(entity: Entity): Entity;
+
+    addEntity(options?: string | Partial<Entity> | Entity) {
+        const node = this._addEntity(options as any);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'entities',
+        });
+        return node;
+    }
+
+    getStructureExistingNames(excludedList: Array<Structure> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.structures.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getStructureUniqueName(name = 'Structure1') {
+        return utils.unique(name, this.getStructureExistingNames());
+    }
+
+    /**
+     * 插入数据结构
+     * @internal
+     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+     */
+    _insertStructureAt(name: string, index: number): Structure;
+
+    /**
+     * 插入数据结构
+     * @internal
+     * @param structureOptions 数据结构参数
+     */
+    _insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
+
+    /**
+     * 插入数据结构
+     * @internal
+     * @param structure 已有的数据结构实例
+     */
+    _insertStructureAt(structure: Structure, index: number): Structure;
+
+    _insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
+        const structureOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'structures' };
+        let structure: Structure;
+        if (!options) {
+            structure = Structure.from({
+                ...structureOptions,
+                name: this.getStructureUniqueName(),
+            }, this, 'structures');
+        } else if (typeof options === 'string') {
+            structure = Structure.from({
+                ...structureOptions,
+                name: options,
+            }, this, 'structures');
+        } else if (options instanceof Structure) {
+            options.delete(); // 同一实例不支持多处存在
+            structure = options;
+            Object.assign(structure, relationOptions);
+        } else {
+            structure = Structure.from({
+                ...structureOptions,
+                ...options,
+            }, this, 'structures');
+        }
+        this.structures.splice(index, 0, structure);
+        return structure;
+    }
+
+    /**
+     * 插入数据结构
+     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+     */
+    insertStructureAt(name: string, index: number): Structure;
+
+    /**
+     * 插入数据结构
+     * @param structureOptions 数据结构参数
+     */
+    insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
+
+    /**
+     * 插入数据结构
+     * @param structure 已有的数据结构实例
+     */
+    insertStructureAt(structure: Structure, index: number): Structure;
+
+    insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
+        const node = this._insertStructureAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'structures',
+        });
+        return node;
+    }
+
+    /**
+     * 添加数据结构
+     * @internal
+     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+     */
+    _addStructure(name?: string): Structure;
+
+    /**
+     * 添加数据结构
+     * @internal
+     * @param structureOptions 数据结构参数
+     */
+    _addStructure(structureOptions: Partial<Structure>): Structure;
+
+    /**
+     * 添加数据结构
+     * @internal
+     * @param structure 已有的数据结构实例
+     */
+    _addStructure(structure: Structure): Structure;
+
+    _addStructure(options?: string | Partial<Structure> | Structure) {
+        const index = 0;
+        return this._insertStructureAt(options as any, index);
+    }
+
+    /**
+     * 添加数据结构
+     * @internal
+     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+     */
+    addStructure(name?: string): Structure;
+
+    /**
+     * 添加数据结构
+     * @param structureOptions 数据结构参数
+     */
+    addStructure(structureOptions: Partial<Structure>): Structure;
+
+    /**
+     * 添加数据结构
+     * @param structure 已有的数据结构实例
+     */
+    addStructure(structure: Structure): Structure;
+
+    addStructure(options?: string | Partial<Structure> | Structure) {
+        const node = this._addStructure(options as any);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'structures',
+        });
+        return node;
+    }
+
+    getEnumExistingNames(excludedList: Array<Enum> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.enums.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getEnumUniqueName(name = 'Enum1') {
+        return utils.unique(name, this.getEnumExistingNames());
+    }
+
+    /**
+     * 插入枚举
+     * @internal
+     * @param name 枚举名称，如果不填会自动生成一个唯一名称
+     */
+    _insertEnumAt(name: string, index: number): Enum;
+
+    /**
+     * 插入枚举
+     * @internal
+     * @param enumerationOptions 枚举参数
+     */
+    _insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
+
+    /**
+     * 插入枚举
+     * @internal
+     * @param enumeration 已有的枚举实例
+     */
+    _insertEnumAt(enumeration: Enum, index: number): Enum;
+
+    _insertEnumAt(options: string | Partial<Enum> | Enum, index: number) {
+        const enumerationOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'enums' };
+        let enumeration: Enum;
+        if (!options) {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                name: this.getEnumUniqueName(),
+            }, this, 'enums');
+        } else if (typeof options === 'string') {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                name: options,
+            }, this, 'enums');
+        } else if (options instanceof Enum) {
+            options.delete(); // 同一实例不支持多处存在
+            enumeration = options;
+            Object.assign(enumeration, relationOptions);
+        } else {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                ...options,
+            }, this, 'enums');
+        }
+        this.enums.splice(index, 0, enumeration);
+        return enumeration;
+    }
+
+    /**
+     * 插入枚举
+     * @param name 枚举名称，如果不填会自动生成一个唯一名称
+     */
+    insertEnumAt(name: string, index: number): Enum;
+
+    /**
+     * 插入枚举
+     * @param enumerationOptions 枚举参数
+     */
+    insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
+
+    /**
+     * 插入枚举
+     * @param enumeration 已有的枚举实例
+     */
+    insertEnumAt(enumeration: Enum, index: number): Enum;
+
+    insertEnumAt(options: string | Partial<Enum> | Enum, index: number) {
+        const node = this._insertEnumAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'enums',
+        });
+        return node;
+    }
+
+    /**
+     * 添加枚举
+     * @internal
+     * @param name 枚举名称，如果不填会自动生成一个唯一名称
+     */
+    _addEnum(name?: string): Enum;
+
+    /**
+     * 添加枚举
+     * @internal
+     * @param enumerationOptions 枚举参数
+     */
+    _addEnum(enumerationOptions: Partial<Enum>): Enum;
+
+    /**
+     * 添加枚举
+     * @internal
+     * @param enumeration 已有的枚举实例
+     */
+    _addEnum(enumeration: Enum): Enum;
+
+    _addEnum(options?: string | Partial<Enum> | Enum) {
+        const index = 0;
+        return this._insertEnumAt(options as any, index);
+    }
+
+    /**
+     * 添加枚举
+     * @internal
+     * @param name 枚举名称，如果不填会自动生成一个唯一名称
+     */
+    addEnum(name?: string): Enum;
+
+    /**
+     * 添加枚举
+     * @param enumerationOptions 枚举参数
+     */
+    addEnum(enumerationOptions: Partial<Enum>): Enum;
+
+    /**
+     * 添加枚举
+     * @param enumeration 已有的枚举实例
+     */
+    addEnum(enumeration: Enum): Enum;
+
+    addEnum(options?: string | Partial<Enum> | Enum) {
+        const node = this._addEnum(options as any);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'enums',
+        });
+        return node;
+    }
+
+    getLogicExistingNames(excludedList: Array<Logic> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.logics.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getLogicUniqueName(name = 'logic1') {
+        return utils.unique(name, this.getLogicExistingNames());
+    }
+
+    /**
+     * 插入逻辑
+     * @internal
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    _insertLogicAt(name: string, index: number): Logic;
+
+    /**
+     * 插入逻辑
+     * @internal
+     * @param logicOptions 逻辑参数
+     */
+    _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+
+    /**
+     * 插入逻辑
+     * @internal
+     * @param logic 已有的逻辑实例
+     */
+    _insertLogicAt(logic: Logic, index: number): Logic;
+
+    _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+        const logicOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'logics' };
+        let logic: Logic;
+        if (!options) {
+            logic = Logic.from({
+                ...logicOptions,
+                name: this.getLogicUniqueName(),
+            }, this, 'logics');
+        } else if (typeof options === 'string') {
+            logic = Logic.from({
+                ...logicOptions,
+                name: options,
+            }, this, 'logics');
+        } else if (options instanceof Logic) {
+            options.delete(); // 同一实例不支持多处存在
+            logic = options;
+            Object.assign(logic, relationOptions);
+        } else {
+            logic = Logic.from({
+                ...logicOptions,
+                ...options,
+            }, this, 'logics');
+        }
+        this.logics.splice(index, 0, logic);
+        return logic;
+    }
+
+    /**
+     * 插入逻辑
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    insertLogicAt(name: string, index: number): Logic;
+
+    /**
+     * 插入逻辑
+     * @param logicOptions 逻辑参数
+     */
+    insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+
+    /**
+     * 插入逻辑
+     * @param logic 已有的逻辑实例
+     */
+    insertLogicAt(logic: Logic, index: number): Logic;
+
+    insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+        const node = this._insertLogicAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    _addLogic(name?: string): Logic;
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param logicOptions 逻辑参数
+     */
+    _addLogic(logicOptions: Partial<Logic>): Logic;
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param logic 已有的逻辑实例
+     */
+    _addLogic(logic: Logic): Logic;
+
+    _addLogic(options?: string | Partial<Logic> | Logic) {
+        const index = 0;
+        return this._insertLogicAt(options as any, index);
+    }
+
+    /**
+     * 添加逻辑
+     * @internal
+     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+     */
+    addLogic(name?: string): Logic;
+
+    /**
+     * 添加逻辑
+     * @param logicOptions 逻辑参数
+     */
+    addLogic(logicOptions: Partial<Logic>): Logic;
+
+    /**
+     * 添加逻辑
+     * @param logic 已有的逻辑实例
+     */
+    addLogic(logic: Logic): Logic;
+
+    addLogic(options?: string | Partial<Logic> | Logic) {
+        const node = this._addLogic(options as any);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+
+    getInterfaceExistingNames(excludedList: Array<Interface> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.interfaces.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getInterfaceUniqueName(name = 'Interface1') {
+        return utils.unique(name, this.getInterfaceExistingNames());
+    }
+
+    /**
+     * 插入接口
+     * @internal
+     * @param name 接口名称，如果不填会自动生成一个唯一名称
+     */
+    _insertInterfaceAt(name: string, index: number): Interface;
+
+    /**
+     * 插入接口
+     * @internal
+     * @param itfaceOptions 接口参数
+     */
+    _insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+
+    /**
+     * 插入接口
+     * @internal
+     * @param itface 已有的接口实例
+     */
+    _insertInterfaceAt(itface: Interface, index: number): Interface;
+
+    _insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
+        const itfaceOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+        let itface: Interface;
+        if (!options) {
+            itface = Interface.from({
+                ...itfaceOptions,
+                name: this.getInterfaceUniqueName(),
+            }, this, 'interfaces');
+        } else if (typeof options === 'string') {
+            itface = Interface.from({
+                ...itfaceOptions,
+                name: options,
+            }, this, 'interfaces');
+        } else if (options instanceof Interface) {
+            options.delete(); // 同一实例不支持多处存在
+            itface = options;
+            Object.assign(itface, relationOptions);
+        } else {
+            itface = Interface.from({
+                ...itfaceOptions,
+                ...options,
+            }, this, 'interfaces');
+        }
+        this.interfaces.splice(index, 0, itface);
+        return itface;
+    }
+
+    /**
+     * 插入接口
+     * @param name 接口名称，如果不填会自动生成一个唯一名称
+     */
+    insertInterfaceAt(name: string, index: number): Interface;
+
+    /**
+     * 插入接口
+     * @param itfaceOptions 接口参数
+     */
+    insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+
+    /**
+     * 插入接口
+     * @param itface 已有的接口实例
+     */
+    insertInterfaceAt(itface: Interface, index: number): Interface;
+
+    insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
+        const node = this._insertInterfaceAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+
+    /**
+     * 添加接口
+     * @internal
+     * @param name 接口名称，如果不填会自动生成一个唯一名称
+     */
+    _addInterface(name?: string): Interface;
+
+    /**
+     * 添加接口
+     * @internal
+     * @param itfaceOptions 接口参数
+     */
+    _addInterface(itfaceOptions: Partial<Interface>): Interface;
+
+    /**
+     * 添加接口
+     * @internal
+     * @param itface 已有的接口实例
+     */
+    _addInterface(itface: Interface): Interface;
+
+    _addInterface(options?: string | Partial<Interface> | Interface) {
+        const index = 0;
+        return this._insertInterfaceAt(options as any, index);
+    }
+
+    /**
+     * 添加接口
+     * @internal
+     * @param name 接口名称，如果不填会自动生成一个唯一名称
+     */
+    addInterface(name?: string): Interface;
+
+    /**
+     * 添加接口
+     * @param itfaceOptions 接口参数
+     */
+    addInterface(itfaceOptions: Partial<Interface>): Interface;
+
+    /**
+     * 添加接口
+     * @param itface 已有的接口实例
+     */
+    addInterface(itface: Interface): Interface;
+
+    addInterface(options?: string | Partial<Interface> | Interface) {
+        const node = this._addInterface(options as any);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+
+    getViewExistingNames(excludedList: Array<View> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.views.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getViewUniqueName(name = 'view1') {
+        return utils.unique(name, this.getViewExistingNames());
+    }
+
+    /**
+     * 插入页面
+     * @internal
+     * @param name 页面名称，如果不填会自动生成一个唯一名称
+     */
+    _insertViewAt(name: string, index: number): View;
+
+    /**
+     * 插入页面
+     * @internal
+     * @param viewOptions 页面参数
+     */
+    _insertViewAt(viewOptions: Partial<View>, index: number): View;
+
+    /**
+     * 插入页面
+     * @internal
+     * @param view 已有的页面实例
+     */
+    _insertViewAt(view: View, index: number): View;
+
+    _insertViewAt(options: string | Partial<View> | View, index: number) {
+        const viewOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'views' };
+        let view: View;
+        if (!options) {
+            view = View.from({
+                ...viewOptions,
+                name: this.getViewUniqueName(),
+            }, this, 'views');
+        } else if (typeof options === 'string') {
+            view = View.from({
+                ...viewOptions,
+                name: options,
+            }, this, 'views');
+        } else if (options instanceof View) {
+            options.delete(); // 同一实例不支持多处存在
+            view = options;
+            Object.assign(view, relationOptions);
+        } else {
+            view = View.from({
+                ...viewOptions,
+                ...options,
+            }, this, 'views');
+        }
+        this.views.splice(index, 0, view);
+        return view;
+    }
+
+    /**
+     * 插入页面
+     * @param name 页面名称，如果不填会自动生成一个唯一名称
+     */
+    insertViewAt(name: string, index: number): View;
+
+    /**
+     * 插入页面
+     * @param viewOptions 页面参数
+     */
+    insertViewAt(viewOptions: Partial<View>, index: number): View;
+
+    /**
+     * 插入页面
+     * @param view 已有的页面实例
+     */
+    insertViewAt(view: View, index: number): View;
+
+    insertViewAt(options: string | Partial<View> | View, index: number) {
+        const node = this._insertViewAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'views',
+        });
+        return node;
+    }
+
+    /**
+     * 添加页面
+     * @internal
+     * @param name 页面名称，如果不填会自动生成一个唯一名称
+     */
+    _addView(name?: string): View;
+
+    /**
+     * 添加页面
+     * @internal
+     * @param viewOptions 页面参数
+     */
+    _addView(viewOptions: Partial<View>): View;
+
+    /**
+     * 添加页面
+     * @internal
+     * @param view 已有的页面实例
+     */
+    _addView(view: View): View;
+
+    _addView(options?: string | Partial<View> | View) {
+        const index = this.views.length;
+        return this._insertViewAt(options as any, index);
+    }
+
+    /**
+     * 添加页面
+     * @internal
+     * @param name 页面名称，如果不填会自动生成一个唯一名称
+     */
+    addView(name?: string): View;
+
+    /**
+     * 添加页面
+     * @param viewOptions 页面参数
+     */
+    addView(viewOptions: Partial<View>): View;
+
+    /**
+     * 添加页面
+     * @param view 已有的页面实例
+     */
+    addView(view: View): View;
+
+    addView(options?: string | Partial<View> | View) {
+        const node = this._addView(options as any);
+        const index = this.views.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'views',
+        });
+        return node;
+    }
+
+    getProcessExistingNames(excludedList: Array<Process> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.processes.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getProcessUniqueName(name = 'Process1') {
+        return utils.unique(name, this.getProcessExistingNames());
+    }
+
+    /**
+     * 插入流程
+     * @internal
+     * @param name 流程名称，如果不填会自动生成一个唯一名称
+     */
+    _insertProcessAt(name: string, index: number): Process;
+
+    /**
+     * 插入流程
+     * @internal
+     * @param processOptions 流程参数
+     */
+    _insertProcessAt(processOptions: Partial<Process>, index: number): Process;
+
+    /**
+     * 插入流程
+     * @internal
+     * @param process 已有的流程实例
+     */
+    _insertProcessAt(process: Process, index: number): Process;
+
+    _insertProcessAt(options: string | Partial<Process> | Process, index: number) {
+        const processOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'processes' };
+        let process: Process;
+        if (!options) {
+            process = Process.from({
+                ...processOptions,
+                name: this.getProcessUniqueName(),
+            }, this, 'processes');
+        } else if (typeof options === 'string') {
+            process = Process.from({
+                ...processOptions,
+                name: options,
+            }, this, 'processes');
+        } else if (options instanceof Process) {
+            options.delete(); // 同一实例不支持多处存在
+            process = options;
+            Object.assign(process, relationOptions);
+        } else {
+            process = Process.from({
+                ...processOptions,
+                ...options,
+            }, this, 'processes');
+        }
+        this.processes.splice(index, 0, process);
+        return process;
+    }
+
+    /**
+     * 插入流程
+     * @param name 流程名称，如果不填会自动生成一个唯一名称
+     */
+    insertProcessAt(name: string, index: number): Process;
+
+    /**
+     * 插入流程
+     * @param processOptions 流程参数
+     */
+    insertProcessAt(processOptions: Partial<Process>, index: number): Process;
+
+    /**
+     * 插入流程
+     * @param process 已有的流程实例
+     */
+    insertProcessAt(process: Process, index: number): Process;
+
+    insertProcessAt(options: string | Partial<Process> | Process, index: number) {
+        const node = this._insertProcessAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processes',
+        });
+        return node;
+    }
+
+    /**
+     * 添加流程
+     * @internal
+     * @param name 流程名称，如果不填会自动生成一个唯一名称
+     */
+    _addProcess(name?: string): Process;
+
+    /**
+     * 添加流程
+     * @internal
+     * @param processOptions 流程参数
+     */
+    _addProcess(processOptions: Partial<Process>): Process;
+
+    /**
+     * 添加流程
+     * @internal
+     * @param process 已有的流程实例
+     */
+    _addProcess(process: Process): Process;
+
+    _addProcess(options?: string | Partial<Process> | Process) {
+        const index = 0;
+        return this._insertProcessAt(options as any, index);
+    }
+
+    /**
+     * 添加流程
+     * @internal
+     * @param name 流程名称，如果不填会自动生成一个唯一名称
+     */
+    addProcess(name?: string): Process;
+
+    /**
+     * 添加流程
+     * @param processOptions 流程参数
+     */
+    addProcess(processOptions: Partial<Process>): Process;
+
+    /**
+     * 添加流程
+     * @param process 已有的流程实例
+     */
+    addProcess(process: Process): Process;
+
+    addProcess(options?: string | Partial<Process> | Process) {
+        const node = this._addProcess(options as any);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processes',
+        });
+        return node;
+    }
+
+    getViewComponentExistingNames(excludedList: Array<ViewComponent> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.viewComponents.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getViewComponentUniqueName(name = 'viewComponent1') {
+        return utils.unique(name, this.getViewComponentExistingNames());
+    }
+
+    /**
+     * 插入页面组件
+     * @internal
+     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+     */
+    _insertViewComponentAt(name: string, index: number): ViewComponent;
+
+    /**
+     * 插入页面组件
+     * @internal
+     * @param viewComponentOptions 页面组件参数
+     */
+    _insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
+
+    /**
+     * 插入页面组件
+     * @internal
+     * @param viewComponent 已有的页面组件实例
+     */
+    _insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
+
+    _insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
+        const viewComponentOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'viewComponents' };
+        let viewComponent: ViewComponent;
+        if (!options) {
+            viewComponent = ViewComponent.from({
+                ...viewComponentOptions,
+                name: this.getViewComponentUniqueName(),
+            }, this, 'viewComponents');
+        } else if (typeof options === 'string') {
+            viewComponent = ViewComponent.from({
+                ...viewComponentOptions,
+                name: options,
+            }, this, 'viewComponents');
+        } else if (options instanceof ViewComponent) {
+            options.delete(); // 同一实例不支持多处存在
+            viewComponent = options;
+            Object.assign(viewComponent, relationOptions);
+        } else {
+            viewComponent = ViewComponent.from({
+                ...viewComponentOptions,
+                ...options,
+            }, this, 'viewComponents');
+        }
+        this.viewComponents.splice(index, 0, viewComponent);
+        return viewComponent;
+    }
+
+    /**
+     * 插入页面组件
+     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+     */
+    insertViewComponentAt(name: string, index: number): ViewComponent;
+
+    /**
+     * 插入页面组件
+     * @param viewComponentOptions 页面组件参数
+     */
+    insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
+
+    /**
+     * 插入页面组件
+     * @param viewComponent 已有的页面组件实例
+     */
+    insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
+
+    insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
+        const node = this._insertViewComponentAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'viewComponents',
+        });
+        return node;
+    }
+
+    /**
+     * 添加页面组件
+     * @internal
+     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+     */
+    _addViewComponent(name?: string): ViewComponent;
+
+    /**
+     * 添加页面组件
+     * @internal
+     * @param viewComponentOptions 页面组件参数
+     */
+    _addViewComponent(viewComponentOptions: Partial<ViewComponent>): ViewComponent;
+
+    /**
+     * 添加页面组件
+     * @internal
+     * @param viewComponent 已有的页面组件实例
+     */
+    _addViewComponent(viewComponent: ViewComponent): ViewComponent;
+
+    _addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
+        const index = this.viewComponents.length;
+        return this._insertViewComponentAt(options as any, index);
+    }
+
+    /**
+     * 添加页面组件
+     * @internal
+     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+     */
+    addViewComponent(name?: string): ViewComponent;
+
+    /**
+     * 添加页面组件
+     * @param viewComponentOptions 页面组件参数
+     */
+    addViewComponent(viewComponentOptions: Partial<ViewComponent>): ViewComponent;
+
+    /**
+     * 添加页面组件
+     * @param viewComponent 已有的页面组件实例
+     */
+    addViewComponent(viewComponent: ViewComponent): ViewComponent;
+
+    addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
+        const node = this._addViewComponent(options as any);
+        const index = this.viewComponents.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'viewComponents',
+        });
+        return node;
+    }
+
+    /**
+     * 删除实体
+     * @param name 实体名称
+     */
+    removeEntity(name: string): void;
+
+    /**
+     * 删除实体
+     * @param entity 已有的实体实例
+     */
+    removeEntity(entity: Entity): void;
+
+    removeEntity(options: string | Entity) {
+        let entity: Entity;
+        if (typeof options === 'string') {
+            entity = this.entities.find((item) => item.name === options);
+            if (!entity) {
+                throw new Error('找不到实体 ' + options);
+            }
+        } else {
+            entity = options;
+        }
+        return entity.delete();
+    }
+
+    __removeEntity(entity: Entity) {
+        const parentKey = entity.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: entity,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(entity);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === entity) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    /**
+     * 删除数据结构
+     * @param name 数据结构名称
+     */
+    removeStructure(name: string): void;
+
+    /**
+     * 删除数据结构
+     * @param structure 已有的数据结构实例
+     */
+    removeStructure(structure: Structure): void;
+
+    removeStructure(options: string | Structure) {
+        let structure: Structure;
+        if (typeof options === 'string') {
+            structure = this.structures.find((item) => item.name === options);
+            if (!structure) {
+                throw new Error('找不到数据结构 ' + options);
+            }
+        } else {
+            structure = options;
+        }
+        return structure.delete();
+    }
+
+    __removeStructure(structure: Structure) {
+        const parentKey = structure.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: structure,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(structure);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === structure) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    /**
+     * 删除枚举
+     * @param name 枚举名称
+     */
+    removeEnum(name: string): void;
+
+    /**
+     * 删除枚举
+     * @param enumeration 已有的枚举实例
+     */
+    removeEnum(enumeration: Enum): void;
+
+    removeEnum(options: string | Enum) {
+        let enumeration: Enum;
+        if (typeof options === 'string') {
+            enumeration = this.enums.find((item) => item.name === options);
+            if (!enumeration) {
+                throw new Error('找不到枚举 ' + options);
+            }
+        } else {
+            enumeration = options;
+        }
+        return enumeration.delete();
+    }
+
+    __removeEnum(enumeration: Enum) {
+        const parentKey = enumeration.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: enumeration,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(enumeration);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === enumeration) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    /**
+     * 删除逻辑
+     * @param name 逻辑名称
+     */
+    removeLogic(name: string): void;
+
+    /**
+     * 删除逻辑
+     * @param logic 已有的逻辑实例
+     */
+    removeLogic(logic: Logic): void;
+
+    removeLogic(options: string | Logic) {
+        let logic: Logic;
+        if (typeof options === 'string') {
+            logic = this.logics.find((item) => item.name === options);
+            if (!logic) {
+                throw new Error('找不到逻辑 ' + options);
+            }
+        } else {
+            logic = options;
+        }
+        return logic.delete();
+    }
+
+    __removeLogic(logic: Logic) {
+        const parentKey = logic.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: logic,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(logic);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === logic) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    /**
+     * 删除接口
+     * @param name 接口名称
+     */
+    removeInterface(name: string): void;
+
+    /**
+     * 删除接口
+     * @param itface 已有的接口实例
+     */
+    removeInterface(itface: Interface): void;
+
+    removeInterface(options: string | Interface) {
+        let itface: Interface;
+        if (typeof options === 'string') {
+            itface = this.interfaces.find((item) => item.name === options);
+            if (!itface) {
+                throw new Error('找不到接口 ' + options);
+            }
+        } else {
+            itface = options;
+        }
+        return itface.delete();
+    }
+
+    __removeInterface(itface: Interface) {
+        const parentKey = itface.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: itface,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(itface);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === itface) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    /**
+     * 删除页面
+     * @param name 页面名称
+     */
+    removeView(name: string): void;
+
+    /**
+     * 删除页面
+     * @param view 已有的页面实例
+     */
+    removeView(view: View): void;
+
+    removeView(options: string | View) {
+        let view: View;
+        if (typeof options === 'string') {
+            view = this.views.find((item) => item.name === options);
+            if (!view) {
+                throw new Error('找不到页面 ' + options);
+            }
+        } else {
+            view = options;
+        }
+        return view.delete();
+    }
+
+    __removeView(view: View) {
+        const parentKey = view.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: view,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(view);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === view) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    /**
+     * 删除流程
+     * @param name 流程名称
+     */
+    removeProcess(name: string): void;
+
+    /**
+     * 删除流程
+     * @param process 已有的流程实例
+     */
+    removeProcess(process: Process): void;
+
+    removeProcess(options: string | Process) {
+        let process: Process;
+        if (typeof options === 'string') {
+            process = this.processes.find((item) => item.name === options);
+            if (!process) {
+                throw new Error('找不到流程 ' + options);
+            }
+        } else {
+            process = options;
+        }
+        return process.delete();
+    }
+
+    __removeProcess(process: Process) {
+        const parentKey = process.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: process,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(process);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === process) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    /**
+     * 删除页面组件
+     * @param name 页面组件名称
+     */
+    removeViewComponent(name: string): void;
+
+    /**
+     * 删除页面组件
+     * @param viewComponent 已有的页面组件实例
+     */
+    removeViewComponent(viewComponent: ViewComponent): void;
+
+    removeViewComponent(options: string | ViewComponent) {
+        let viewComponent: ViewComponent;
+        if (typeof options === 'string') {
+            viewComponent = this.viewComponents.find((item) => item.name === options);
+            if (!viewComponent) {
+                throw new Error('找不到页面组件 ' + options);
+            }
+        } else {
+            viewComponent = options;
+        }
+        return viewComponent.delete();
+    }
+
+    __removeViewComponent(viewComponent: ViewComponent) {
+        const parentKey = viewComponent.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: viewComponent,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(viewComponent);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === viewComponent) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+
+    /**
+     * 获取命名空间
+     * 暂时不考虑 Module 嵌套的情况
+     */
+    getNamespace() {
+        return `${this.app.getNamespace()}.${this.name}`;
+    }
+    /**
+     * 获取命名空间和
+     * 暂时不考虑 Module 嵌套的情况
+     */
+    getNamespaceAndKey() {
+        return `${moduleNameSpace[this.parentKey as ModuleKeyType]}.${this.name}`;
+    }
+
+    /**
+     *  获取属性节点是否存在
+     */
+
+    findProperty(name: string, propertyType: PropertyType): any {
+        return (this[propertyType] as Array<any>).find((item) => item.name === name);
+    }
+
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap.Module = Module;
+export default Module;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================