@lcap/nasl 0.3.15 → 1.0.0-alpha.10

package/src/concepts/App__.ts

@@ -0,0 +1,2568 @@
+export interface AssetsInfo {
+    js: Array<string>;
+    css: Array<string>;
+    names?: Array<string>;
+}
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 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 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 Role from './Role__';
+import Theme from './Theme__';
+import Configuration from './Configuration__';
+import Module from './Module__';
+
+/**
+ * 应用
+ */
+@concept('应用')
+export class App extends BaseNode {
+    /**
+     * 应用 Id
+     */
+    @property()
+    id: string = undefined;
+
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'App' = 'App';
+
+    /**
+     * IDE 版本
+     */
+    @property()
+    ideVersion: string = undefined;
+
+    /**
+     * 应用标识
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 应用标题
+     */
+    @property()
+    title: string = undefined;
+
+    /**
+     * 应用图标
+     */
+    @property()
+    icon: string = undefined;
+
+    /**
+     * 应用描述
+     */
+    @property()
+    desc: string = undefined;
+
+    /**
+     * 域名
+     */
+    @property()
+    dnsAddr: string = undefined;
+
+    /**
+     * PC/H5 端
+     */
+    @property()
+    scope: 'pc' | 'h5' = undefined;
+
+    /**
+     * 是否有用户中心
+     */
+    @property()
+    hasUserCenter: boolean = undefined;
+
+    /**
+     * 是否有权限
+     */
+    @property()
+    hasAuth: boolean = 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('Role')
+    roles: Array<Role> = [];
+
+    /**
+     * 主题配置
+     */
+    @property('Theme')
+    theme: Theme = new Theme();
+
+    /**
+     * 配置管理
+     */
+    @property('Configuration')
+    configuration: Configuration = new Configuration();
+
+    /**
+     * 扩展模块列表
+     */
+    @property('Module')
+    dependencies: Array<Module> = [];
+
+    /**
+     * 接口应用列表（兼容老版）
+     */
+    @property('Module')
+    interfaceDependencies: Array<Module> = [];
+
+    /**
+     * 扩展组件列表（兼容老版）
+     */
+    @property('Module')
+    componentDependencies: Array<Module> = [];
+
+    
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<App>) {
+        source = Object.assign({}, App.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): App {
+        return super.from(source, parentNode, parentKey) as App;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeApp?.(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;
+    }
+
+
+    getRoleExistingNames(excludedList: Array<Role> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.roles || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getRoleUniqueName(name = 'role1') {
+        return utils.unique(name, this.getRoleExistingNames());
+    }
+
+    /**
+    * 插入角色
+    * @internal
+    * @param name 角色名称，如果不填会自动生成一个唯一名称
+    */
+    _insertRoleAt(name: string, index: number): Role;
+
+    /**
+    * 插入角色
+    * @internal
+    * @param roleOptions 角色参数
+    */
+    _insertRoleAt(roleOptions: Partial<Role>, index: number): Role;
+
+    /**
+    * 插入角色
+    * @internal
+    * @param role 已有的角色实例
+    */
+    _insertRoleAt(role: Role, index: number): Role;
+
+    _insertRoleAt(options: string | Partial<Role> | Role, index: number) {
+        const roleOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'roles' };
+        let role: Role;
+        if (!options) {
+            role = Role.from({
+                ...roleOptions,
+                name: this.getRoleUniqueName(),
+            }, this, 'roles');
+        } else if (typeof options === 'string') {
+            role = Role.from({
+                ...roleOptions,
+                name: options,
+            }, this, 'roles');
+        } else if (options instanceof Role) {
+            options.delete(); // 同一实例不支持多处存在
+            role = options;
+            Object.assign(role, relationOptions);
+        } else {
+            role = Role.from({
+                ...roleOptions,
+                ...options,
+            }, this, 'roles');
+        }
+        this.roles.splice(index, 0, role);
+        return role;
+    }
+
+    /**
+     * 插入角色
+     * @param name 角色名称，如果不填会自动生成一个唯一名称
+     */
+    insertRoleAt(name: string, index: number): Role;
+
+    /**
+     * 插入角色
+     * @param roleOptions 角色参数
+     */
+    insertRoleAt(roleOptions: Partial<Role>, index: number): Role;
+
+    /**
+     * 插入角色
+     * @param role 已有的角色实例
+     */
+    insertRoleAt(role: Role, index: number): Role;
+
+    insertRoleAt(options: string | Partial<Role> | Role, index: number) {
+        const node = this._insertRoleAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'roles',
+        });
+        return node;
+    }
+
+    /**
+     * 添加角色
+     * @internal
+     * @param name 角色名称，如果不填会自动生成一个唯一名称
+     */
+    _addRole(name?: string): Role;
+
+    /**
+     * 添加角色
+     * @internal
+     * @param roleOptions 角色参数
+     */
+    _addRole(roleOptions: Partial<Role>): Role;
+
+    /**
+     * 添加角色
+     * @internal
+     * @param role 已有的角色实例
+     */
+    _addRole(role: Role): Role;
+
+    _addRole(options?: string | Partial<Role> | Role) {
+        const index = this.roles.length;
+        return this._insertRoleAt(options as any, index);
+    }
+
+    /**
+     * 添加角色
+     * @internal
+     * @param name 角色名称，如果不填会自动生成一个唯一名称
+     */
+    addRole(name?: string): Role;
+
+    /**
+     * 添加角色
+     * @param roleOptions 角色参数
+     */
+    addRole(roleOptions: Partial<Role>): Role;
+
+    /**
+     * 添加角色
+     * @param role 已有的角色实例
+     */
+    addRole(role: Role): Role;
+
+    addRole(options?: string | Partial<Role> | Role) {
+        const node = this._addRole(options as any);
+        const index = this.roles.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'roles',
+        });
+        return node;
+    }
+
+
+    getModuleExistingNames(excludedList: Array<Module> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.dependencies || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getModuleUniqueName(name = 'module1') {
+        return utils.unique(name, this.getModuleExistingNames());
+    }
+
+    /**
+    * 插入模块
+    * @internal
+    * @param name 模块名称，如果不填会自动生成一个唯一名称
+    */
+    _insertModuleInDependenciesAt(name: string, index: number): Module;
+
+    /**
+    * 插入模块
+    * @internal
+    * @param moduleOptions 模块参数
+    */
+    _insertModuleInDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+
+    /**
+    * 插入模块
+    * @internal
+    * @param module 已有的模块实例
+    */
+    _insertModuleInDependenciesAt(module: Module, index: number): Module;
+
+    _insertModuleInDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+        const moduleOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'dependencies' };
+        let module: Module;
+        if (!options) {
+            module = Module.from({
+                ...moduleOptions,
+                name: this.getModuleUniqueName(),
+            }, this, 'dependencies');
+        } else if (typeof options === 'string') {
+            module = Module.from({
+                ...moduleOptions,
+                name: options,
+            }, this, 'dependencies');
+        } else if (options instanceof Module) {
+            options.delete(); // 同一实例不支持多处存在
+            module = options;
+            Object.assign(module, relationOptions);
+        } else {
+            module = Module.from({
+                ...moduleOptions,
+                ...options,
+            }, this, 'dependencies');
+        }
+        this.dependencies.splice(index, 0, module);
+        return module;
+    }
+
+    /**
+     * 插入模块
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    insertModuleInDependenciesAt(name: string, index: number): Module;
+
+    /**
+     * 插入模块
+     * @param moduleOptions 模块参数
+     */
+    insertModuleInDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+
+    /**
+     * 插入模块
+     * @param module 已有的模块实例
+     */
+    insertModuleInDependenciesAt(module: Module, index: number): Module;
+
+    insertModuleInDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+        const node = this._insertModuleInDependenciesAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dependencies',
+        });
+        return node;
+    }
+
+    /**
+     * 添加模块
+     * @internal
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    _addModuleInDependencies(name?: string): Module;
+
+    /**
+     * 添加模块
+     * @internal
+     * @param moduleOptions 模块参数
+     */
+    _addModuleInDependencies(moduleOptions: Partial<Module>): Module;
+
+    /**
+     * 添加模块
+     * @internal
+     * @param module 已有的模块实例
+     */
+    _addModuleInDependencies(module: Module): Module;
+
+    _addModuleInDependencies(options?: string | Partial<Module> | Module) {
+        const index = this.dependencies.length;
+        return this._insertModuleInDependenciesAt(options as any, index);
+    }
+
+    /**
+     * 添加模块
+     * @internal
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    addModuleInDependencies(name?: string): Module;
+
+    /**
+     * 添加模块
+     * @param moduleOptions 模块参数
+     */
+    addModuleInDependencies(moduleOptions: Partial<Module>): Module;
+
+    /**
+     * 添加模块
+     * @param module 已有的模块实例
+     */
+    addModuleInDependencies(module: Module): Module;
+
+    addModuleInDependencies(options?: string | Partial<Module> | Module) {
+        const node = this._addModuleInDependencies(options as any);
+        const index = this.dependencies.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dependencies',
+        });
+        return node;
+    }
+
+    /**
+    * 插入模块
+    * @internal
+    * @param name 模块名称，如果不填会自动生成一个唯一名称
+    */
+    _insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
+
+    /**
+    * 插入模块
+    * @internal
+    * @param moduleOptions 模块参数
+    */
+    _insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+
+    /**
+    * 插入模块
+    * @internal
+    * @param module 已有的模块实例
+    */
+    _insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
+
+    _insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+        const moduleOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaceDependencies' };
+        let module: Module;
+        if (!options) {
+            module = Module.from({
+                ...moduleOptions,
+                name: this.getModuleUniqueName(),
+            }, this, 'interfaceDependencies');
+        } else if (typeof options === 'string') {
+            module = Module.from({
+                ...moduleOptions,
+                name: options,
+            }, this, 'interfaceDependencies');
+        } else if (options instanceof Module) {
+            options.delete(); // 同一实例不支持多处存在
+            module = options;
+            Object.assign(module, relationOptions);
+        } else {
+            module = Module.from({
+                ...moduleOptions,
+                ...options,
+            }, this, 'interfaceDependencies');
+        }
+        this.interfaceDependencies.splice(index, 0, module);
+        return module;
+    }
+
+    /**
+     * 插入模块
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
+
+    /**
+     * 插入模块
+     * @param moduleOptions 模块参数
+     */
+    insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+
+    /**
+     * 插入模块
+     * @param module 已有的模块实例
+     */
+    insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
+
+    insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+        const node = this._insertModuleInInterfaceDependenciesAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaceDependencies',
+        });
+        return node;
+    }
+
+    /**
+     * 添加模块
+     * @internal
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    _addModuleInInterfaceDependencies(name?: string): Module;
+
+    /**
+     * 添加模块
+     * @internal
+     * @param moduleOptions 模块参数
+     */
+    _addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
+
+    /**
+     * 添加模块
+     * @internal
+     * @param module 已有的模块实例
+     */
+    _addModuleInInterfaceDependencies(module: Module): Module;
+
+    _addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
+        const index = this.interfaceDependencies.length;
+        return this._insertModuleInInterfaceDependenciesAt(options as any, index);
+    }
+
+    /**
+     * 添加模块
+     * @internal
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    addModuleInInterfaceDependencies(name?: string): Module;
+
+    /**
+     * 添加模块
+     * @param moduleOptions 模块参数
+     */
+    addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
+
+    /**
+     * 添加模块
+     * @param module 已有的模块实例
+     */
+    addModuleInInterfaceDependencies(module: Module): Module;
+
+    addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
+        const node = this._addModuleInInterfaceDependencies(options as any);
+        const index = this.interfaceDependencies.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaceDependencies',
+        });
+        return node;
+    }
+
+    /**
+    * 插入模块
+    * @internal
+    * @param name 模块名称，如果不填会自动生成一个唯一名称
+    */
+    _insertModuleInComponentDependenciesAt(name: string, index: number): Module;
+
+    /**
+    * 插入模块
+    * @internal
+    * @param moduleOptions 模块参数
+    */
+    _insertModuleInComponentDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+
+    /**
+    * 插入模块
+    * @internal
+    * @param module 已有的模块实例
+    */
+    _insertModuleInComponentDependenciesAt(module: Module, index: number): Module;
+
+    _insertModuleInComponentDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+        const moduleOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'componentDependencies' };
+        let module: Module;
+        if (!options) {
+            module = Module.from({
+                ...moduleOptions,
+                name: this.getModuleUniqueName(),
+            }, this, 'componentDependencies');
+        } else if (typeof options === 'string') {
+            module = Module.from({
+                ...moduleOptions,
+                name: options,
+            }, this, 'componentDependencies');
+        } else if (options instanceof Module) {
+            options.delete(); // 同一实例不支持多处存在
+            module = options;
+            Object.assign(module, relationOptions);
+        } else {
+            module = Module.from({
+                ...moduleOptions,
+                ...options,
+            }, this, 'componentDependencies');
+        }
+        this.componentDependencies.splice(index, 0, module);
+        return module;
+    }
+
+    /**
+     * 插入模块
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    insertModuleInComponentDependenciesAt(name: string, index: number): Module;
+
+    /**
+     * 插入模块
+     * @param moduleOptions 模块参数
+     */
+    insertModuleInComponentDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+
+    /**
+     * 插入模块
+     * @param module 已有的模块实例
+     */
+    insertModuleInComponentDependenciesAt(module: Module, index: number): Module;
+
+    insertModuleInComponentDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+        const node = this._insertModuleInComponentDependenciesAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'componentDependencies',
+        });
+        return node;
+    }
+
+    /**
+     * 添加模块
+     * @internal
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    _addModuleInComponentDependencies(name?: string): Module;
+
+    /**
+     * 添加模块
+     * @internal
+     * @param moduleOptions 模块参数
+     */
+    _addModuleInComponentDependencies(moduleOptions: Partial<Module>): Module;
+
+    /**
+     * 添加模块
+     * @internal
+     * @param module 已有的模块实例
+     */
+    _addModuleInComponentDependencies(module: Module): Module;
+
+    _addModuleInComponentDependencies(options?: string | Partial<Module> | Module) {
+        const index = this.componentDependencies.length;
+        return this._insertModuleInComponentDependenciesAt(options as any, index);
+    }
+
+    /**
+     * 添加模块
+     * @internal
+     * @param name 模块名称，如果不填会自动生成一个唯一名称
+     */
+    addModuleInComponentDependencies(name?: string): Module;
+
+    /**
+     * 添加模块
+     * @param moduleOptions 模块参数
+     */
+    addModuleInComponentDependencies(moduleOptions: Partial<Module>): Module;
+
+    /**
+     * 添加模块
+     * @param module 已有的模块实例
+     */
+    addModuleInComponentDependencies(module: Module): Module;
+
+    addModuleInComponentDependencies(options?: string | Partial<Module> | Module) {
+        const node = this._addModuleInComponentDependencies(options as any);
+        const index = this.componentDependencies.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'componentDependencies',
+        });
+        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 角色名称
+    */
+    removeRole(name: string): void;
+
+    /**
+     * 删除角色
+     * @param role 已有的角色实例
+     */
+    removeRole(role: Role): void;
+
+    removeRole(options: string | Role) {
+        let role: Role;
+        if (typeof options === 'string') {
+            role = this.roles.find((item) => item.name === options);
+            if (!role) {
+                throw new Error('找不到角色 ' + options);
+            }
+        } else {
+            role = options;
+        }
+        return role.delete();
+    }
+
+    __removeRole(role: Role) {
+        const parentKey = role.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: role,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(role);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === role) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除主题
+    * @param name 主题名称
+    */
+    removeTheme(name: string): void;
+
+    /**
+     * 删除主题
+     * @param theme 已有的主题实例
+     */
+    removeTheme(theme: Theme): void;
+
+    removeTheme(options: string | Theme) {
+        let theme: Theme;
+        if (typeof options === 'string') {
+            theme = this.theme;
+            if (!theme) {
+                throw new Error('找不到主题 ' + options);
+            }
+        } else {
+            theme = options;
+        }
+        return theme.delete();
+    }
+
+    __removeTheme(theme: Theme) {
+        const parentKey = theme.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: theme,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(theme);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === theme) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除配置管理
+    * @param name 配置管理名称
+    */
+    removeConfiguration(name: string): void;
+
+    /**
+     * 删除配置管理
+     * @param configuration 已有的配置管理实例
+     */
+    removeConfiguration(configuration: Configuration): void;
+
+    removeConfiguration(options: string | Configuration) {
+        let configuration: Configuration;
+        if (typeof options === 'string') {
+            configuration = this.configuration;
+            if (!configuration) {
+                throw new Error('找不到配置管理 ' + options);
+            }
+        } else {
+            configuration = options;
+        }
+        return configuration.delete();
+    }
+
+    __removeConfiguration(configuration: Configuration) {
+        const parentKey = configuration.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: configuration,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(configuration);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === configuration) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除模块
+    * @param name 模块名称
+    */
+    removeModuleInDependencies(name: string): void;
+
+    /**
+     * 删除模块
+     * @param module 已有的模块实例
+     */
+    removeModuleInDependencies(module: Module): void;
+
+    removeModuleInDependencies(options: string | Module) {
+        let module: Module;
+        if (typeof options === 'string') {
+            module = this.dependencies.find((item) => item.name === options);
+            if (!module) {
+                throw new Error('找不到模块 ' + options);
+            }
+        } else {
+            module = options;
+        }
+        return module.delete();
+    }
+
+    
+
+    /**
+    * 删除模块
+    * @param name 模块名称
+    */
+    removeModuleInInterfaceDependencies(name: string): void;
+
+    /**
+     * 删除模块
+     * @param module 已有的模块实例
+     */
+    removeModuleInInterfaceDependencies(module: Module): void;
+
+    removeModuleInInterfaceDependencies(options: string | Module) {
+        let module: Module;
+        if (typeof options === 'string') {
+            module = this.interfaceDependencies.find((item) => item.name === options);
+            if (!module) {
+                throw new Error('找不到模块 ' + options);
+            }
+        } else {
+            module = options;
+        }
+        return module.delete();
+    }
+
+    
+
+    /**
+    * 删除模块
+    * @param name 模块名称
+    */
+    removeModuleInComponentDependencies(name: string): void;
+
+    /**
+     * 删除模块
+     * @param module 已有的模块实例
+     */
+    removeModuleInComponentDependencies(module: Module): void;
+
+    removeModuleInComponentDependencies(options: string | Module) {
+        let module: Module;
+        if (typeof options === 'string') {
+            module = this.componentDependencies.find((item) => item.name === options);
+            if (!module) {
+                throw new Error('找不到模块 ' + options);
+            }
+        } else {
+            module = options;
+        }
+        return module.delete();
+    }
+
+    __removeModule(module: Module) {
+        const parentKey = module.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: module,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(module);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === module) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    findComponentDependencyByName(name: string) {
+        return this.componentDependencies.find((componentDependency) => componentDependency.name === name);
+    }
+
+    findEntityByName(name: string) {
+        return this.entities.find((entity) => entity.name === name);
+    }
+
+    findEnumByName(name: string) {
+        return this.enums.find((enumItem) => enumItem.name === name);
+    }
+
+    findStructureByName(name: string) {
+        return this.structures.find((item) => item.name === name);
+    }
+
+    findLogicByName(name: string) {
+        return this.logics.find((logic) => logic.name === name);
+    }
+
+    /**
+     * 是否为官方应用
+     */
+    @excludedInJSON()
+    officialType: 'official' | 'nonofficial' = undefined;
+
+    /**
+     * 轻舟项目 Id
+     */
+    @excludedInJSON()
+    projectId: string = undefined;
+
+    /**
+     * 租户 Id
+     */
+    @excludedInJSON()
+    tenantId: string = undefined;
+
+    /**
+     * 租户 Id
+     */
+    @excludedInJSON()
+    userGroupId: string = undefined;
+
+    /**
+     * 多环境
+     */
+    @excludedInJSON()
+    envs: string = undefined;
+
+    /**
+     * 多环境
+     */
+    @excludedInJSON()
+    envList: Array<string> = ['dev', 'online'];
+
+    /**
+     * 发布状态
+     */
+    @excludedInJSON()
+    deploying: boolean = undefined;
+
+    /**
+     * 发布 Id
+     */
+    @excludedInJSON()
+    deploymentId: number = undefined;
+
+    /**
+     * 从模板创建的模板 Id
+     */
+    @excludedInJSON()
+    templateId: number = undefined;
+
+    /**
+     * 获取命名空间
+     */
+    getNamespace() {
+        return `app`;
+    }
+
+    findNodeByPath(nodePath: string) {
+        const pathArr = nodePath?.split('.') || [];
+        let pathItem = pathArr.shift();
+        let node: any = this;
+        while (pathItem) {
+            const matchArr = pathItem.match(/\[(.+?)\]/);
+            const arrayPropertyKey = pathItem.split('[')[0];
+            const arrOption = matchArr && matchArr[1] && matchArr[1].split('=');
+            if (node && arrayPropertyKey && arrayPropertyKey !== 'app') {
+                node = node[arrayPropertyKey];
+                if (Array.isArray(arrOption) && arrOption.length && Array.isArray(node) && node.length) {
+                    if (arrOption.length === 2) {
+                        node = node.filter((nodeItem) => nodeItem[arrOption[0]] === arrOption[1])[0];
+                    } else {
+                        const index = +arrOption[0];
+                        node = node[index];
+                    }
+                }
+            }
+            pathItem = pathArr.shift();
+        }
+        return node;
+    }
+
+    /**
+     * @param path 路径
+     * path 为要查找路径：如 /dashboard/student/list、/dashboard/student/list
+     */
+    findViewByPath(path: string) {
+        const arr = path.split('/');
+        if (arr[0] === '')
+            arr.shift();
+
+        if (!arr.length)
+            throw Error('Cannot find View ' + path);
+        const childName = arr.shift();
+        const subView = this.views.find((child) => child.name === childName);
+        return arr.length ? subView.findViewByPath(arr.join('/')) : subView;
+    }
+
+    loadEnvList() {
+        this.envList = ['dev', 'online'];
+    }
+
+    public readonly packageInfo: {
+        template: { name: string; version: string };
+        ui: { name: string; version: string };
+    } = {
+        template: {
+            name: 'lcap-pc-template',
+            version: '0.4.13-beta',
+        },
+        ui: {
+            name: 'cloud-ui.vusion',
+            version: '0.14.8',
+        },
+    };
+
+    loadPackageInfo() {
+        const dependencyMap = (window as any).globalData.ideVersionDetail.dependencies;
+        this.packageInfo.template.name = this.scope === 'h5' ? '@lcap/mobile-template' : 'lcap-pc-template';
+        this.packageInfo.template.version = this.scope === 'h5' ? dependencyMap.FrontendArchH5.version : dependencyMap.FrontendArchPC.version;
+        this.packageInfo.ui.name = this.scope === 'h5' ? '@lcap/mobile-ui' : 'cloud-ui.vusion';
+        this.packageInfo.ui.version = this.scope === 'h5' ? dependencyMap.FrontendComponentLibraryH5.version : dependencyMap.FrontendComponentLibraryPC.version;
+    }
+
+    /**
+     * 根据 packageInfo 的信息生成用于 load 的 assetsInfo
+     * 在环境中需要 basic 和 custom 分开 load，否则容易报错
+     * @param prefix
+     */
+    genAllAssetsInfo(prefix: string) {
+        const packageInfo = this.packageInfo;
+        const scope = this.scope;
+        const result: {
+            basic: AssetsInfo;
+            custom?: AssetsInfo;
+        } = {
+            basic: {
+                js: [
+                    `${prefix}/packages/vue@2/dist/vue.min.js`,
+                    // `${prefix}/packages/vue-router@3/dist/vue-router.min.js`,
+
+                    scope === 'h5' ? `${prefix}/packages/@lcap/mobile-ui@${packageInfo.ui.version}/dist-theme/index.js` : `${prefix}/packages/cloud-ui.vusion@${packageInfo.ui.version}/dist-theme/index.js`,
+
+                    scope === 'h5' ? `${prefix}/packages/@lcap/mobile-template@0.7.10-beta/cloudAdminDesigner.umd.min.js` : `${prefix}/packages/lcap-pc-template@0.4.13-beta/cloudAdminDesigner.umd.min.js`,
+                ],
+                css: [
+                    scope === 'h5' ? `${prefix}/packages/@lcap/mobile-ui@${packageInfo.ui.version}/dist-theme/index.css` : `${prefix}/packages/cloud-ui.vusion@${packageInfo.ui.version}/dist-theme/index.css`,
+                    scope === 'h5' ? `${prefix}/packages/@lcap/mobile-template@${packageInfo.template.version}/cloudAdminDesigner.css` : `${prefix}/packages/lcap-pc-template@${packageInfo.template.version}/cloudAdminDesigner.css`,
+                ],
+            },
+            custom: {
+                js: [],
+                css: [],
+                names: [],
+            },
+        };
+        this.componentDependencies.forEach((dep) => {
+            const { name, version } = dep;
+            result.custom.js.push(`${prefix}/packages/${name}@${version}/dist-theme/index.js`);
+            result.custom.css.push(`${prefix}/packages/${name}@${version}/dist-theme/index.css`);
+            result.custom.names.push(name);
+        });
+        return result;
+    }
+
+    genThemeCSS() {
+        const keys = Object.keys(this.theme?.variableMap || {});
+        if (!keys.length)
+            return;
+
+        return `:root {
+${keys.map((key) => `    ${key}: ${this.theme?.variableMap[key]};`).join('\n')}
+}
+`;
+    }
+
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap['App'] = App;
+export default App;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================