@lcap/nasl 0.3.14 → 1.0.0-alpha.1

package/out/concepts/App__.js

@@ -0,0 +1,1453 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var App_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const decorators_1 = require("../decorators");
+const utils = __importStar(require("../utils"));
+const BaseNode_1 = __importDefault(require("../common/BaseNode"));
+const classMap_1 = __importDefault(require("../common/classMap"));
+const Entity__1 = __importDefault(require("./Entity__"));
+const Structure__1 = __importDefault(require("./Structure__"));
+const Enum__1 = __importDefault(require("./Enum__"));
+const Logic__1 = __importDefault(require("./Logic__"));
+const Interface__1 = __importDefault(require("./Interface__"));
+const View__1 = __importDefault(require("./View__"));
+const Process__1 = __importDefault(require("./Process__"));
+const Role__1 = __importDefault(require("./Role__"));
+const Theme__1 = __importDefault(require("./Theme__"));
+const Module__1 = __importDefault(require("./Module__"));
+/**
+ * 应用
+ */
+let App = App_1 = class App extends BaseNode_1.default {
+    /**
+     * 应用 Id
+     */
+    id = undefined;
+    /**
+     * 产品概念
+     */
+    concept = 'App';
+    /**
+     * IDE 版本
+     */
+    ideVersion = undefined;
+    /**
+     * 应用标识
+     */
+    name = undefined;
+    /**
+     * 应用标题
+     */
+    title = undefined;
+    /**
+     * 应用图标
+     */
+    icon = undefined;
+    /**
+     * 应用描述
+     */
+    desc = undefined;
+    /**
+     * 域名
+     */
+    dnsAddr = undefined;
+    /**
+     * PC/H5 端
+     */
+    scope = undefined;
+    /**
+     * 是否有用户中心
+     */
+    hasUserCenter = undefined;
+    /**
+     * 是否有权限
+     */
+    hasAuth = undefined;
+    /**
+     * 实体列表
+     */
+    entities = [];
+    /**
+     * 数据结构列表
+     */
+    structures = [];
+    /**
+     * 枚举列表
+     */
+    enums = [];
+    /**
+     * 逻辑列表
+     */
+    logics = [];
+    /**
+     * 接口列表
+     */
+    interfaces = [];
+    /**
+     * 页面列表
+     */
+    views = [];
+    /**
+     * 流程列表
+     */
+    processes = [];
+    /**
+     * 角色列表
+     */
+    roles = [];
+    /**
+     * 主题配置
+     */
+    theme = new Theme__1.default();
+    /**
+     * 扩展模块列表
+     */
+    dependencies = [];
+    /**
+     * 接口应用列表（兼容老版）
+     */
+    interfaceDependencies = [];
+    /**
+     * 扩展组件列表（兼容老版）
+     */
+    componentDependencies = [];
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source) {
+        source = Object.assign({}, App_1.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+    static from(source, parentNode, parentKey) {
+        return super.from(source, parentNode, parentKey);
+    }
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params = null;
+        if (this.parentNode) {
+            params = this.parentNode?.__removeApp?.(this);
+        }
+        return params;
+    }
+    getEntityExistingNames(excludedList = []) {
+        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());
+    }
+    _insertEntityAt(options, index) {
+        const entityOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'entities' };
+        let entity;
+        if (!options) {
+            entity = Entity__1.default.from({
+                ...entityOptions,
+                name: this.getEntityUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            entity = Entity__1.default.from({
+                ...entityOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Entity__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            entity = options;
+        }
+        else {
+            entity = Entity__1.default.from({
+                ...entityOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(entity, relationOptions);
+        this.entities.splice(index, 0, entity);
+        return entity;
+    }
+    insertEntityAt(options, index) {
+        const node = this._insertEntityAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'entities',
+        });
+        return node;
+    }
+    _addEntity(options) {
+        const index = 0;
+        return this._insertEntityAt(options, index);
+    }
+    addEntity(options) {
+        const node = this._addEntity(options);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'entities',
+        });
+        return node;
+    }
+    getStructureExistingNames(excludedList = []) {
+        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());
+    }
+    _insertStructureAt(options, index) {
+        const structureOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'structures' };
+        let structure;
+        if (!options) {
+            structure = Structure__1.default.from({
+                ...structureOptions,
+                name: this.getStructureUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            structure = Structure__1.default.from({
+                ...structureOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Structure__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            structure = options;
+        }
+        else {
+            structure = Structure__1.default.from({
+                ...structureOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(structure, relationOptions);
+        this.structures.splice(index, 0, structure);
+        return structure;
+    }
+    insertStructureAt(options, index) {
+        const node = this._insertStructureAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'structures',
+        });
+        return node;
+    }
+    _addStructure(options) {
+        const index = 0;
+        return this._insertStructureAt(options, index);
+    }
+    addStructure(options) {
+        const node = this._addStructure(options);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'structures',
+        });
+        return node;
+    }
+    getEnumExistingNames(excludedList = []) {
+        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());
+    }
+    _insertEnumAt(options, index) {
+        const enumerationOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'enums' };
+        let enumeration;
+        if (!options) {
+            enumeration = Enum__1.default.from({
+                ...enumerationOptions,
+                name: this.getEnumUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            enumeration = Enum__1.default.from({
+                ...enumerationOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Enum__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            enumeration = options;
+        }
+        else {
+            enumeration = Enum__1.default.from({
+                ...enumerationOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(enumeration, relationOptions);
+        this.enums.splice(index, 0, enumeration);
+        return enumeration;
+    }
+    insertEnumAt(options, index) {
+        const node = this._insertEnumAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'enums',
+        });
+        return node;
+    }
+    _addEnum(options) {
+        const index = 0;
+        return this._insertEnumAt(options, index);
+    }
+    addEnum(options) {
+        const node = this._addEnum(options);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'enums',
+        });
+        return node;
+    }
+    getLogicExistingNames(excludedList = []) {
+        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());
+    }
+    _insertLogicAt(options, index) {
+        const logicOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'logics' };
+        let logic;
+        if (!options) {
+            logic = Logic__1.default.from({
+                ...logicOptions,
+                name: this.getLogicUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            logic = Logic__1.default.from({
+                ...logicOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Logic__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            logic = options;
+        }
+        else {
+            logic = Logic__1.default.from({
+                ...logicOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(logic, relationOptions);
+        this.logics.splice(index, 0, logic);
+        return logic;
+    }
+    insertLogicAt(options, index) {
+        const node = this._insertLogicAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+    _addLogic(options) {
+        const index = 0;
+        return this._insertLogicAt(options, index);
+    }
+    addLogic(options) {
+        const node = this._addLogic(options);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+    getInterfaceExistingNames(excludedList = []) {
+        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());
+    }
+    _insertInterfaceAt(options, index) {
+        const itfaceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+        let itface;
+        if (!options) {
+            itface = Interface__1.default.from({
+                ...itfaceOptions,
+                name: this.getInterfaceUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            itface = Interface__1.default.from({
+                ...itfaceOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Interface__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            itface = options;
+        }
+        else {
+            itface = Interface__1.default.from({
+                ...itfaceOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(itface, relationOptions);
+        this.interfaces.splice(index, 0, itface);
+        return itface;
+    }
+    insertInterfaceAt(options, index) {
+        const node = this._insertInterfaceAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+    _addInterface(options) {
+        const index = 0;
+        return this._insertInterfaceAt(options, index);
+    }
+    addInterface(options) {
+        const node = this._addInterface(options);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+    getViewExistingNames(excludedList = []) {
+        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());
+    }
+    _insertViewAt(options, index) {
+        const viewOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'views' };
+        let view;
+        if (!options) {
+            view = View__1.default.from({
+                ...viewOptions,
+                name: this.getViewUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            view = View__1.default.from({
+                ...viewOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof View__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            view = options;
+        }
+        else {
+            view = View__1.default.from({
+                ...viewOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(view, relationOptions);
+        this.views.splice(index, 0, view);
+        return view;
+    }
+    insertViewAt(options, index) {
+        const node = this._insertViewAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'views',
+        });
+        return node;
+    }
+    _addView(options) {
+        const index = this.views.length;
+        return this._insertViewAt(options, index);
+    }
+    addView(options) {
+        const node = this._addView(options);
+        const index = this.views.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'views',
+        });
+        return node;
+    }
+    getProcessExistingNames(excludedList = []) {
+        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());
+    }
+    _insertProcessAt(options, index) {
+        const processOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'processes' };
+        let process;
+        if (!options) {
+            process = Process__1.default.from({
+                ...processOptions,
+                name: this.getProcessUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            process = Process__1.default.from({
+                ...processOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Process__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            process = options;
+        }
+        else {
+            process = Process__1.default.from({
+                ...processOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(process, relationOptions);
+        this.processes.splice(index, 0, process);
+        return process;
+    }
+    insertProcessAt(options, index) {
+        const node = this._insertProcessAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processes',
+        });
+        return node;
+    }
+    _addProcess(options) {
+        const index = 0;
+        return this._insertProcessAt(options, index);
+    }
+    addProcess(options) {
+        const node = this._addProcess(options);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processes',
+        });
+        return node;
+    }
+    getRoleExistingNames(excludedList = []) {
+        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());
+    }
+    _insertRoleAt(options, index) {
+        const roleOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'roles' };
+        let role;
+        if (!options) {
+            role = Role__1.default.from({
+                ...roleOptions,
+                name: this.getRoleUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            role = Role__1.default.from({
+                ...roleOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Role__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            role = options;
+        }
+        else {
+            role = Role__1.default.from({
+                ...roleOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(role, relationOptions);
+        this.roles.splice(index, 0, role);
+        return role;
+    }
+    insertRoleAt(options, index) {
+        const node = this._insertRoleAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'roles',
+        });
+        return node;
+    }
+    _addRole(options) {
+        const index = this.roles.length;
+        return this._insertRoleAt(options, index);
+    }
+    addRole(options) {
+        const node = this._addRole(options);
+        const index = this.roles.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'roles',
+        });
+        return node;
+    }
+    getModuleExistingNames(excludedList = []) {
+        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());
+    }
+    _insertModuleInDependenciesAt(options, index) {
+        const moduleOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'dependencies' };
+        let module;
+        if (!options) {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                name: this.getModuleUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Module__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            module = options;
+        }
+        else {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(module, relationOptions);
+        this.dependencies.splice(index, 0, module);
+        return module;
+    }
+    insertModuleInDependenciesAt(options, index) {
+        const node = this._insertModuleInDependenciesAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dependencies',
+        });
+        return node;
+    }
+    _addModuleInDependencies(options) {
+        const index = this.dependencies.length;
+        return this._insertModuleInDependenciesAt(options, index);
+    }
+    addModuleInDependencies(options) {
+        const node = this._addModuleInDependencies(options);
+        const index = this.dependencies.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dependencies',
+        });
+        return node;
+    }
+    _insertModuleInInterfaceDependenciesAt(options, index) {
+        const moduleOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaceDependencies' };
+        let module;
+        if (!options) {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                name: this.getModuleUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Module__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            module = options;
+        }
+        else {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(module, relationOptions);
+        this.interfaceDependencies.splice(index, 0, module);
+        return module;
+    }
+    insertModuleInInterfaceDependenciesAt(options, index) {
+        const node = this._insertModuleInInterfaceDependenciesAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaceDependencies',
+        });
+        return node;
+    }
+    _addModuleInInterfaceDependencies(options) {
+        const index = this.interfaceDependencies.length;
+        return this._insertModuleInInterfaceDependenciesAt(options, index);
+    }
+    addModuleInInterfaceDependencies(options) {
+        const node = this._addModuleInInterfaceDependencies(options);
+        const index = this.interfaceDependencies.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaceDependencies',
+        });
+        return node;
+    }
+    _insertModuleInComponentDependenciesAt(options, index) {
+        const moduleOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'componentDependencies' };
+        let module;
+        if (!options) {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                name: this.getModuleUniqueName(),
+            }, this);
+        }
+        else if (typeof options === 'string') {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                name: options,
+            }, this);
+        }
+        else if (options instanceof Module__1.default) {
+            options.delete(); // 同一实例不支持多处存在
+            module = options;
+        }
+        else {
+            module = Module__1.default.from({
+                ...moduleOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(module, relationOptions);
+        this.componentDependencies.splice(index, 0, module);
+        return module;
+    }
+    insertModuleInComponentDependenciesAt(options, index) {
+        const node = this._insertModuleInComponentDependenciesAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'componentDependencies',
+        });
+        return node;
+    }
+    _addModuleInComponentDependencies(options) {
+        const index = this.componentDependencies.length;
+        return this._insertModuleInComponentDependenciesAt(options, index);
+    }
+    addModuleInComponentDependencies(options) {
+        const node = this._addModuleInComponentDependencies(options);
+        const index = this.componentDependencies.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'componentDependencies',
+        });
+        return node;
+    }
+    removeEntity(options) {
+        let 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) {
+        const parentKey = entity.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: entity,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(entity);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === entity) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeStructure(options) {
+        let 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) {
+        const parentKey = structure.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: structure,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(structure);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === structure) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeEnum(options) {
+        let enumeration;
+        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) {
+        const parentKey = enumeration.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: enumeration,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(enumeration);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === enumeration) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeLogic(options) {
+        let 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) {
+        const parentKey = logic.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: logic,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(logic);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === logic) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeInterface(options) {
+        let itface;
+        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) {
+        const parentKey = itface.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: itface,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(itface);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === itface) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeView(options) {
+        let 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) {
+        const parentKey = view.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: view,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(view);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === view) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeProcess(options) {
+        let 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) {
+        const parentKey = process.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: process,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(process);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === process) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeRole(options) {
+        let 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) {
+        const parentKey = role.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: role,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(role);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === role) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeTheme(options) {
+        let theme;
+        if (typeof options === 'string') {
+            theme = this.theme;
+            if (!theme) {
+                throw new Error('找不到主题 ' + options);
+            }
+        }
+        else {
+            theme = options;
+        }
+        return theme.delete();
+    }
+    __removeTheme(theme) {
+        const parentKey = theme.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: theme,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(theme);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === theme) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    removeModuleInDependencies(options) {
+        let 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();
+    }
+    removeModuleInInterfaceDependencies(options) {
+        let 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();
+    }
+    removeModuleInComponentDependencies(options) {
+        let 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) {
+        const parentKey = module.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: module,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(module);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === module) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    findEntityByName(name) {
+        return this.entities.find((entity) => entity.name === name);
+    }
+    findEnumByName(name) {
+        return this.enums.find((enumItem) => enumItem.name === name);
+    }
+    findStructureByName(name) {
+        return this.structures.find((item) => item.name === name);
+    }
+    findLogicByName(name) {
+        return this.logics.find((logic) => logic.name === name);
+    }
+    /**
+     * 是否为官方应用
+     */
+    officialType = undefined;
+    /**
+     * 轻舟项目 Id
+     */
+    projectId = undefined;
+    /**
+     * 租户 Id
+     */
+    tenantId = undefined;
+    /**
+     * 租户 Id
+     */
+    userGroupId = undefined;
+    /**
+     * 多环境
+     */
+    envs = undefined;
+    /**
+     * 多环境
+     */
+    envList = ['dev', 'online'];
+    /**
+     * 发布状态
+     */
+    deploying = undefined;
+    /**
+     * 发布 Id
+     */
+    deploymentId = undefined;
+    /**
+     * 从模板创建的模板 Id
+     */
+    templateId = undefined;
+    /**
+     * 获取命名空间
+     */
+    getNamespace() {
+        return `app`;
+    }
+    findNodeByPath(nodePath) {
+        const pathArr = nodePath?.split('.') || [];
+        let pathItem = pathArr.shift();
+        let node = this;
+        while (pathItem) {
+            const matchArr = pathItem.match(/\[(.+?)\]/);
+            const arrayPropertyKey = pathItem.split('[')[0];
+            const arrOption = matchArr && matchArr[1] && matchArr[1].split('=');
+            if (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;
+    }
+    loadEnvList() {
+        this.envList = ['dev', 'online'];
+    }
+    packageInfo = {
+        template: {
+            name: 'lcap-pc-template',
+            version: '0.4.12',
+        },
+        ui: {
+            name: 'cloud-ui.vusion',
+            version: '0.14.8',
+        },
+    };
+    loadPackageInfo() {
+        const dependencyMap = window.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) {
+        const packageInfo = this.packageInfo;
+        const scope = this.scope;
+        const result = {
+            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@${packageInfo.template.version}/cloudAdminDesigner.umd.min.js` : `${prefix}/packages/lcap-pc-template@${packageInfo.template.version}/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) => {
+            result.custom.js.push(`${prefix}/packages/${dep.name}@${dep.version}/dist-theme/index.js`);
+            result.custom.css.push(`${prefix}/packages/${dep.name}@${dep.version}/dist-theme/index.css`);
+            result.custom.names.push(dep.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')}
+}
+`;
+    }
+};
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "id", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "concept", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "ideVersion", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "name", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "title", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "icon", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "desc", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "dnsAddr", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "scope", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "hasUserCenter", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "hasAuth", void 0);
+__decorate([
+    (0, decorators_1.property)('Entity')
+], App.prototype, "entities", void 0);
+__decorate([
+    (0, decorators_1.property)('Structure')
+], App.prototype, "structures", void 0);
+__decorate([
+    (0, decorators_1.property)('Enum')
+], App.prototype, "enums", void 0);
+__decorate([
+    (0, decorators_1.property)('Logic')
+], App.prototype, "logics", void 0);
+__decorate([
+    (0, decorators_1.property)('Interface')
+], App.prototype, "interfaces", void 0);
+__decorate([
+    (0, decorators_1.property)('View')
+], App.prototype, "views", void 0);
+__decorate([
+    (0, decorators_1.property)('Process')
+], App.prototype, "processes", void 0);
+__decorate([
+    (0, decorators_1.property)('Role')
+], App.prototype, "roles", void 0);
+__decorate([
+    (0, decorators_1.property)('Theme')
+], App.prototype, "theme", void 0);
+__decorate([
+    (0, decorators_1.property)('Module')
+], App.prototype, "dependencies", void 0);
+__decorate([
+    (0, decorators_1.property)('Module')
+], App.prototype, "interfaceDependencies", void 0);
+__decorate([
+    (0, decorators_1.property)('Module')
+], App.prototype, "componentDependencies", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "officialType", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "projectId", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "tenantId", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "userGroupId", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "envs", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "envList", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "deploying", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "deploymentId", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "templateId", void 0);
+App = App_1 = __decorate([
+    decorators_1.concept
+], App);
+exports.App = App;
+classMap_1.default['App'] = App;
+exports.default = App;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================
+//# sourceMappingURL=App__.js.map