@lcap/nasl-concepts 3.9.0-beta.1

package/out/concepts/App__.js

@@ -0,0 +1,3475 @@
+"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 nasl_utils_1 = require("@lcap/nasl-utils");
+const nasl_translator_1 = require("@lcap/nasl-translator");
+const service_1 = require("../service");
+const utils_1 = require("../utils");
+const decorators_1 = require("../decorators");
+const utils = __importStar(require("../utils"));
+const asserts = __importStar(require("./utils/asserts"));
+const BaseNode_1 = __importDefault(require("../common/BaseNode"));
+/**
+ * 应用
+ */
+let App = class App extends BaseNode_1.default {
+    static { App_1 = this; }
+    /** 类名 */
+    static { this.ConceptName = 'App'; }
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static { this.isAbstract = false; }
+    /** 继承链 */
+    static { this.inheritanceChain = ['BaseNode']; }
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source) {
+        source = Object.assign({}, App_1.getDefaultOptions(), source);
+        super(source);
+        /**
+         * 应用 Id
+         */
+        this.id = '';
+        /**
+         * 应用标识
+         */
+        this.name = '';
+        /**
+         * 数据源列表
+         */
+        this.dataSources = [];
+        /**
+         * 数据结构列表
+         */
+        this.structures = [];
+        /**
+         * 枚举列表
+         */
+        this.enums = [];
+        /**
+         * 逻辑列表
+         */
+        this.logics = [];
+        /**
+         * 覆写逻辑列表
+         */
+        this.overriddenLogics = [];
+        /**
+         * 接口列表
+         */
+        this.interfaces = [];
+        /**
+         * 端类型列表
+         */
+        this.frontendTypes = [];
+        /**
+         * 流程列表
+         */
+        this.processes = [];
+        /**
+         * 流程列表
+         */
+        this.processV2s = [];
+        /**
+         * 角色列表
+         */
+        this.roles = [];
+        /**
+         * 连接器列表
+         */
+        this.connectorDependencies = [];
+        /**
+         * 接口应用列表（兼容老版）
+         */
+        this.interfaceDependencies = [];
+        /**
+         * 扩展模块列表
+         */
+        this.dependencies = [];
+        /**
+         * 暴露接口的接口鉴权
+         */
+        this.authLogics = [];
+        /**
+         * 调用接口的鉴权模板
+         */
+        this.authLogicsForCallInterface = [];
+        /**
+         * 连接
+         */
+        this.connections = [];
+        /**
+         * 触发器启动器
+         */
+        this.triggerLaunchers = [];
+        /**
+         * 元数据类型列表
+         */
+        this.metadataTypes = [];
+        /**
+         * 是否为官方应用
+         */
+        this.officialType = undefined;
+        /**
+         * 轻舟项目 Id
+         */
+        this.projectId = undefined;
+        /**
+         * 租户 Id
+         */
+        this.tenantId = undefined;
+        /**
+         * 租户 Id
+         */
+        this.userGroupId = undefined;
+        /**
+         * 多环境
+         */
+        this.envs = undefined;
+        /**
+         * 多环境
+         */
+        this.envList = ['dev', 'online'];
+        /**
+         * 发布状态
+         */
+        this.deploying = undefined;
+        /**
+         * 发布 Id
+         */
+        this.deploymentId = undefined;
+        /**
+         * 从模板创建的模板 Id
+         */
+        this.templateId = undefined;
+        /**
+         * 组合节点缓存
+         */
+        this.composeCache = {};
+        /**
+         * 语言服务
+         */
+        this.naslServer = undefined;
+        /**
+         * 是否启动新版流程
+         */
+        this.newProcessVersion = false;
+        // loadPackageInfo(scope: string) {
+        //   const materialConfig = (window as any).globalData.materialConfig || {};
+        //   const { framework, ui } = materialConfig;
+        //   const packageInfo = {
+        //     template: [],{ name: '', version: '', scope },
+        //     ui: [],{ name: '', version: '', scope },
+        //     scope,
+        //   };
+        //   packageInfo.template.name = scope === 'h5' ? framework.h5 : framework.pc;
+        //   packageInfo.template.version = framework.version;
+        //   packageInfo.ui.name = scope === 'h5' ? ui.h5.name : ui.pc.name;
+        //   packageInfo.ui.version = scope === 'h5' ? ui.h5.version : ui.pc.version;
+        //   return packageInfo;
+        // }
+        this.packageInfos = [];
+        /**
+         * 当前正在发布的环境，临时状态
+         */
+        this.curDeployEnv = 'dev';
+        this.__databaseTypeMap = {};
+        super.subConstructor(source);
+    }
+    static from(source, parentNode, parentKey) {
+        return super.from(source, parentNode, parentKey);
+    }
+    /**
+     * 设置集成
+     */
+    setIntegration(integration) {
+        integration._delete();
+        const relationOptions = { parentNode: this, parentKey: 'integration' };
+        Object.assign(integration, relationOptions);
+        const object = {
+            integration,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    getDataSourceUniqueName(name = 'dataSource1') {
+        return utils.unique(name, this.getDataSourceExistingNames(), undefined, true);
+    }
+    _insertDataSourceAt(options, index) {
+        const dataSourceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'dataSources' };
+        const DataSource = (0, decorators_1.getConceptConstructor)('DataSource');
+        let dataSource;
+        if (!options) {
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
+                name: this.getDataSourceUniqueName(),
+            }, this, 'dataSources');
+        }
+        else if (typeof options === 'string') {
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
+                name: options,
+            }, this, 'dataSources');
+        }
+        else if (asserts.isDataSource(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            dataSource = options;
+            Object.assign(dataSource, relationOptions);
+        }
+        else {
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
+                ...options,
+            }, this, 'dataSources');
+        }
+        this.dataSources.splice(index, 0, dataSource);
+        return dataSource;
+    }
+    insertDataSourceAt(options, index) {
+        const node = this._insertDataSourceAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dataSources',
+        });
+        return node;
+    }
+    _addDataSource(options) {
+        const index = this.dataSources.length;
+        return this._insertDataSourceAt(options, index);
+    }
+    addDataSource(options) {
+        const node = this._addDataSource(options);
+        const index = this.dataSources.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dataSources',
+        });
+        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(), undefined, true);
+    }
+    _insertStructureAt(options, index) {
+        const structureOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'structures' };
+        const Structure = (0, decorators_1.getConceptConstructor)('Structure');
+        let 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 (asserts.isStructure(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            structure = options;
+            Object.assign(structure, relationOptions);
+        }
+        else {
+            structure = Structure.from({
+                ...structureOptions,
+                ...options,
+            }, this, 'structures');
+        }
+        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 = this.structures.indexOf(node);
+        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(), undefined, true);
+    }
+    _insertEnumAt(options, index) {
+        const enumerationOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'enums' };
+        const Enum = (0, decorators_1.getConceptConstructor)('Enum');
+        let enumeration;
+        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 (asserts.isEnum(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            enumeration = options;
+            Object.assign(enumeration, relationOptions);
+        }
+        else {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                ...options,
+            }, this, 'enums');
+        }
+        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 = this.enums.indexOf(node);
+        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(), undefined, true);
+    }
+    _insertLogicAt(options, index) {
+        const logicOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'logics' };
+        const Logic = (0, decorators_1.getConceptConstructor)('Logic');
+        let 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 (asserts.isLogic(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            logic = options;
+            Object.assign(logic, relationOptions);
+        }
+        else {
+            logic = Logic.from({
+                ...logicOptions,
+                ...options,
+            }, this, 'logics');
+        }
+        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 = this.logics.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+    getOverriddenLogicExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.overriddenLogics || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getOverriddenLogicUniqueName(name = 'overriddenLogic1') {
+        return utils.unique(name, this.getOverriddenLogicExistingNames(), undefined, true);
+    }
+    _insertOverriddenLogicAt(options, index) {
+        const overriddenLogicOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'overriddenLogics' };
+        const OverriddenLogic = (0, decorators_1.getConceptConstructor)('OverriddenLogic');
+        let overriddenLogic;
+        if (!options) {
+            overriddenLogic = OverriddenLogic.from({
+                ...overriddenLogicOptions,
+                name: this.getOverriddenLogicUniqueName(),
+            }, this, 'overriddenLogics');
+        }
+        else if (typeof options === 'string') {
+            overriddenLogic = OverriddenLogic.from({
+                ...overriddenLogicOptions,
+                name: options,
+            }, this, 'overriddenLogics');
+        }
+        else if (asserts.isOverriddenLogic(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            overriddenLogic = options;
+            Object.assign(overriddenLogic, relationOptions);
+        }
+        else {
+            overriddenLogic = OverriddenLogic.from({
+                ...overriddenLogicOptions,
+                ...options,
+            }, this, 'overriddenLogics');
+        }
+        this.overriddenLogics.splice(index, 0, overriddenLogic);
+        return overriddenLogic;
+    }
+    insertOverriddenLogicAt(options, index) {
+        const node = this._insertOverriddenLogicAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'overriddenLogics',
+        });
+        return node;
+    }
+    _addOverriddenLogic(options) {
+        const index = 0;
+        return this._insertOverriddenLogicAt(options, index);
+    }
+    addOverriddenLogic(options) {
+        const node = this._addOverriddenLogic(options);
+        const index = this.overriddenLogics.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'overriddenLogics',
+        });
+        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(), undefined, true);
+    }
+    _insertInterfaceAt(options, index) {
+        const itfaceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+        const AbstractInterface = (0, decorators_1.getConceptConstructor)('AbstractInterface');
+        let itface;
+        if (!options) {
+            itface = AbstractInterface.from({
+                ...itfaceOptions,
+                name: this.getInterfaceUniqueName(),
+            }, this, 'interfaces');
+        }
+        else if (typeof options === 'string') {
+            itface = AbstractInterface.from({
+                ...itfaceOptions,
+                name: options,
+            }, this, 'interfaces');
+        }
+        else if (asserts.isAbstractInterface(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            itface = options;
+            Object.assign(itface, relationOptions);
+        }
+        else {
+            itface = AbstractInterface.from({
+                ...itfaceOptions,
+                ...options,
+            }, this, 'interfaces');
+        }
+        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 = this.interfaces.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+    getFrontendTypeExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.frontendTypes || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getFrontendTypeUniqueName(name = 'frontendType1') {
+        return utils.unique(name, this.getFrontendTypeExistingNames(), undefined, true);
+    }
+    _insertFrontendTypeAt(options, index) {
+        const frontendTypeOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'frontendTypes' };
+        const FrontendType = (0, decorators_1.getConceptConstructor)('FrontendType');
+        let frontendType;
+        if (!options) {
+            frontendType = FrontendType.from({
+                ...frontendTypeOptions,
+                name: this.getFrontendTypeUniqueName(),
+            }, this, 'frontendTypes');
+        }
+        else if (typeof options === 'string') {
+            frontendType = FrontendType.from({
+                ...frontendTypeOptions,
+                name: options,
+            }, this, 'frontendTypes');
+        }
+        else if (asserts.isFrontendType(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            frontendType = options;
+            Object.assign(frontendType, relationOptions);
+        }
+        else {
+            frontendType = FrontendType.from({
+                ...frontendTypeOptions,
+                ...options,
+            }, this, 'frontendTypes');
+        }
+        this.frontendTypes.splice(index, 0, frontendType);
+        return frontendType;
+    }
+    insertFrontendTypeAt(options, index) {
+        const node = this._insertFrontendTypeAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'frontendTypes',
+        });
+        return node;
+    }
+    _addFrontendType(options) {
+        const index = this.frontendTypes.length;
+        return this._insertFrontendTypeAt(options, index);
+    }
+    addFrontendType(options) {
+        const node = this._addFrontendType(options);
+        const index = this.frontendTypes.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'frontendTypes',
+        });
+        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(), undefined, true);
+    }
+    _insertProcessAt(options, index) {
+        const processOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'processes' };
+        const Process = (0, decorators_1.getConceptConstructor)('Process');
+        let 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 (asserts.isProcess(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            process = options;
+            Object.assign(process, relationOptions);
+        }
+        else {
+            process = Process.from({
+                ...processOptions,
+                ...options,
+            }, this, 'processes');
+        }
+        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 = this.processes.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processes',
+        });
+        return node;
+    }
+    getProcessV2ExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.processV2s || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getProcessV2UniqueName(name = 'Process1') {
+        return utils.unique(name, this.getProcessV2ExistingNames(), undefined, true);
+    }
+    _insertProcessV2At(options, index) {
+        const processV2Options = {};
+        const relationOptions = { parentNode: this, parentKey: 'processV2s' };
+        const ProcessV2 = (0, decorators_1.getConceptConstructor)('ProcessV2');
+        let processV2;
+        if (!options) {
+            processV2 = ProcessV2.from({
+                ...processV2Options,
+                name: this.getProcessV2UniqueName(),
+            }, this, 'processV2s');
+        }
+        else if (typeof options === 'string') {
+            processV2 = ProcessV2.from({
+                ...processV2Options,
+                name: options,
+            }, this, 'processV2s');
+        }
+        else if (asserts.isProcessV2(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            processV2 = options;
+            Object.assign(processV2, relationOptions);
+        }
+        else {
+            processV2 = ProcessV2.from({
+                ...processV2Options,
+                ...options,
+            }, this, 'processV2s');
+        }
+        this.processV2s.splice(index, 0, processV2);
+        return processV2;
+    }
+    insertProcessV2At(options, index) {
+        const node = this._insertProcessV2At(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processV2s',
+        });
+        return node;
+    }
+    _addProcessV2(options) {
+        const index = 0;
+        return this._insertProcessV2At(options, index);
+    }
+    addProcessV2(options) {
+        const node = this._addProcessV2(options);
+        const index = this.processV2s.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processV2s',
+        });
+        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(), undefined, true);
+    }
+    _insertRoleAt(options, index) {
+        const roleOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'roles' };
+        const Role = (0, decorators_1.getConceptConstructor)('Role');
+        let 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 (asserts.isRole(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            role = options;
+            Object.assign(role, relationOptions);
+        }
+        else {
+            role = Role.from({
+                ...roleOptions,
+                ...options,
+            }, this, 'roles');
+        }
+        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.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'roles',
+        });
+        return node;
+    }
+    getConnectorExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.connectorDependencies || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getConnectorUniqueName(name = 'connector1') {
+        return utils.unique(name, this.getConnectorExistingNames(), undefined, false);
+    }
+    _insertConnectorAt(options, index) {
+        const connectorOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'connectorDependencies' };
+        const Connector = (0, decorators_1.getConceptConstructor)('Connector');
+        let connector;
+        if (!options) {
+            connector = Connector.from({
+                ...connectorOptions,
+                name: this.getConnectorUniqueName(),
+            }, this, 'connectorDependencies');
+        }
+        else if (typeof options === 'string') {
+            connector = Connector.from({
+                ...connectorOptions,
+                name: options,
+            }, this, 'connectorDependencies');
+        }
+        else if (asserts.isConnector(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            connector = options;
+            Object.assign(connector, relationOptions);
+        }
+        else {
+            connector = Connector.from({
+                ...connectorOptions,
+                ...options,
+            }, this, 'connectorDependencies');
+        }
+        this.connectorDependencies.splice(index, 0, connector);
+        return connector;
+    }
+    insertConnectorAt(options, index) {
+        const node = this._insertConnectorAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'connectorDependencies',
+        });
+        return node;
+    }
+    _addConnector(options) {
+        const index = this.connectorDependencies.length;
+        return this._insertConnectorAt(options, index);
+    }
+    addConnector(options) {
+        const node = this._addConnector(options);
+        const index = this.connectorDependencies.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'connectorDependencies',
+        });
+        return node;
+    }
+    getModuleExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.interfaceDependencies || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getModuleUniqueName(name = 'module1') {
+        return utils.unique(name, this.getModuleExistingNames(), undefined, false);
+    }
+    _insertModuleInInterfaceDependenciesAt(options, index) {
+        const moduleOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaceDependencies' };
+        const Module = (0, decorators_1.getConceptConstructor)('Module');
+        let 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 (asserts.isModule(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            module = options;
+            Object.assign(module, relationOptions);
+        }
+        else {
+            module = Module.from({
+                ...moduleOptions,
+                ...options,
+            }, this, 'interfaceDependencies');
+        }
+        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.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaceDependencies',
+        });
+        return node;
+    }
+    _insertModuleInDependenciesAt(options, index) {
+        const moduleOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'dependencies' };
+        const Module = (0, decorators_1.getConceptConstructor)('Module');
+        let 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 (asserts.isModule(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            module = options;
+            Object.assign(module, relationOptions);
+        }
+        else {
+            module = Module.from({
+                ...moduleOptions,
+                ...options,
+            }, this, 'dependencies');
+        }
+        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.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dependencies',
+        });
+        return node;
+    }
+    getAuthLogicExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.authLogics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getAuthLogicUniqueName(name = 'authentication1') {
+        return utils.unique(name, this.getAuthLogicExistingNames(), undefined, false);
+    }
+    _insertAuthLogicAt(options, index) {
+        const authLogicOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'authLogics' };
+        const AuthLogic = (0, decorators_1.getConceptConstructor)('AuthLogic');
+        let authLogic;
+        if (!options) {
+            authLogic = AuthLogic.from({
+                ...authLogicOptions,
+                name: this.getAuthLogicUniqueName(),
+            }, this, 'authLogics');
+        }
+        else if (typeof options === 'string') {
+            authLogic = AuthLogic.from({
+                ...authLogicOptions,
+                name: options,
+            }, this, 'authLogics');
+        }
+        else if (asserts.isAuthLogic(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogic = options;
+            Object.assign(authLogic, relationOptions);
+        }
+        else {
+            authLogic = AuthLogic.from({
+                ...authLogicOptions,
+                ...options,
+            }, this, 'authLogics');
+        }
+        this.authLogics.splice(index, 0, authLogic);
+        return authLogic;
+    }
+    insertAuthLogicAt(options, index) {
+        const node = this._insertAuthLogicAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogics',
+        });
+        return node;
+    }
+    _addAuthLogic(options) {
+        const index = this.authLogics.length;
+        return this._insertAuthLogicAt(options, index);
+    }
+    addAuthLogic(options) {
+        const node = this._addAuthLogic(options);
+        const index = this.authLogics.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogics',
+        });
+        return node;
+    }
+    getAuthLogicForCallInterfaceExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.authLogicsForCallInterface || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getAuthLogicForCallInterfaceUniqueName(name = 'authLogicForCallInterface1') {
+        return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
+    }
+    _insertAuthLogicForCallInterfaceAt(options, index) {
+        const authLogicForCallInterfaceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+        const AuthLogicForCallInterface = (0, decorators_1.getConceptConstructor)('AuthLogicForCallInterface');
+        let authLogicForCallInterface;
+        if (!options) {
+            authLogicForCallInterface = AuthLogicForCallInterface.from({
+                ...authLogicForCallInterfaceOptions,
+                name: this.getAuthLogicForCallInterfaceUniqueName(),
+            }, this, 'authLogicsForCallInterface');
+        }
+        else if (typeof options === 'string') {
+            authLogicForCallInterface = AuthLogicForCallInterface.from({
+                ...authLogicForCallInterfaceOptions,
+                name: options,
+            }, this, 'authLogicsForCallInterface');
+        }
+        else if (asserts.isAuthLogicForCallInterface(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogicForCallInterface = options;
+            Object.assign(authLogicForCallInterface, relationOptions);
+        }
+        else {
+            authLogicForCallInterface = AuthLogicForCallInterface.from({
+                ...authLogicForCallInterfaceOptions,
+                ...options,
+            }, this, 'authLogicsForCallInterface');
+        }
+        this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+        return authLogicForCallInterface;
+    }
+    insertAuthLogicForCallInterfaceAt(options, index) {
+        const node = this._insertAuthLogicForCallInterfaceAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogicsForCallInterface',
+        });
+        return node;
+    }
+    _addAuthLogicForCallInterface(options) {
+        const index = this.authLogicsForCallInterface.length;
+        return this._insertAuthLogicForCallInterfaceAt(options, index);
+    }
+    addAuthLogicForCallInterface(options) {
+        const node = this._addAuthLogicForCallInterface(options);
+        const index = this.authLogicsForCallInterface.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'authLogicsForCallInterface',
+        });
+        return node;
+    }
+    getConnectionExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.connections || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getConnectionUniqueName(name = 'connection1') {
+        return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
+    }
+    _insertConnectionAt(options, index) {
+        const connectionOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'connections' };
+        const Connection = (0, decorators_1.getConceptConstructor)('Connection');
+        let connection;
+        if (!options) {
+            connection = Connection.from({
+                ...connectionOptions,
+                name: this.getConnectionUniqueName(),
+            }, this, 'connections');
+        }
+        else if (typeof options === 'string') {
+            connection = Connection.from({
+                ...connectionOptions,
+                name: options,
+            }, this, 'connections');
+        }
+        else if (asserts.isConnection(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            connection = options;
+            Object.assign(connection, relationOptions);
+        }
+        else {
+            connection = Connection.from({
+                ...connectionOptions,
+                ...options,
+            }, this, 'connections');
+        }
+        this.connections.splice(index, 0, connection);
+        return connection;
+    }
+    insertConnectionAt(options, index) {
+        const node = this._insertConnectionAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'connections',
+        });
+        return node;
+    }
+    _addConnection(options) {
+        const index = this.connections.length;
+        return this._insertConnectionAt(options, index);
+    }
+    addConnection(options) {
+        const node = this._addConnection(options);
+        const index = this.connections.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'connections',
+        });
+        return node;
+    }
+    getTriggerLauncherExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.triggerLaunchers || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
+        return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
+    }
+    _insertTriggerLauncherAt(options, index) {
+        const triggerLauncherOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
+        const TriggerLauncher = (0, decorators_1.getConceptConstructor)('TriggerLauncher');
+        let triggerLauncher;
+        if (!options) {
+            triggerLauncher = TriggerLauncher.from({
+                ...triggerLauncherOptions,
+                name: this.getTriggerLauncherUniqueName(),
+            }, this, 'triggerLaunchers');
+        }
+        else if (typeof options === 'string') {
+            triggerLauncher = TriggerLauncher.from({
+                ...triggerLauncherOptions,
+                name: options,
+            }, this, 'triggerLaunchers');
+        }
+        else if (asserts.isTriggerLauncher(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            triggerLauncher = options;
+            Object.assign(triggerLauncher, relationOptions);
+        }
+        else {
+            triggerLauncher = TriggerLauncher.from({
+                ...triggerLauncherOptions,
+                ...options,
+            }, this, 'triggerLaunchers');
+        }
+        this.triggerLaunchers.splice(index, 0, triggerLauncher);
+        return triggerLauncher;
+    }
+    insertTriggerLauncherAt(options, index) {
+        const node = this._insertTriggerLauncherAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'triggerLaunchers',
+        });
+        return node;
+    }
+    _addTriggerLauncher(options) {
+        const index = this.triggerLaunchers.length;
+        return this._insertTriggerLauncherAt(options, index);
+    }
+    addTriggerLauncher(options) {
+        const node = this._addTriggerLauncher(options);
+        const index = this.triggerLaunchers.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'triggerLaunchers',
+        });
+        return node;
+    }
+    getMetadataTypeExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.metadataTypes || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getMetadataTypeUniqueName(name = 'MetadataType1') {
+        return utils.unique(name, this.getMetadataTypeExistingNames(), undefined, true);
+    }
+    _insertMetadataTypeAt(options, index) {
+        const metadataTypeOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'metadataTypes' };
+        const MetadataType = (0, decorators_1.getConceptConstructor)('MetadataType');
+        let metadataType;
+        if (!options) {
+            metadataType = MetadataType.from({
+                ...metadataTypeOptions,
+                name: this.getMetadataTypeUniqueName(),
+            }, this, 'metadataTypes');
+        }
+        else if (typeof options === 'string') {
+            metadataType = MetadataType.from({
+                ...metadataTypeOptions,
+                name: options,
+            }, this, 'metadataTypes');
+        }
+        else if (asserts.isMetadataType(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            metadataType = options;
+            Object.assign(metadataType, relationOptions);
+        }
+        else {
+            metadataType = MetadataType.from({
+                ...metadataTypeOptions,
+                ...options,
+            }, this, 'metadataTypes');
+        }
+        this.metadataTypes.splice(index, 0, metadataType);
+        return metadataType;
+    }
+    insertMetadataTypeAt(options, index) {
+        const node = this._insertMetadataTypeAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'metadataTypes',
+        });
+        return node;
+    }
+    _addMetadataType(options) {
+        const index = 0;
+        return this._insertMetadataTypeAt(options, index);
+    }
+    addMetadataType(options) {
+        const node = this._addMetadataType(options);
+        const index = this.metadataTypes.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'metadataTypes',
+        });
+        return node;
+    }
+    removeDataSource(options) {
+        let dataSource;
+        if (typeof options === 'string') {
+            dataSource = this.dataSources.find((item) => item.name === options);
+            if (!dataSource) {
+                throw new Error('找不到数据源 ' + options);
+            }
+        }
+        else {
+            dataSource = options;
+        }
+        return dataSource.delete();
+    }
+    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();
+    }
+    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();
+    }
+    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();
+    }
+    removeOverriddenLogic(options) {
+        let overriddenLogic;
+        if (typeof options === 'string') {
+            overriddenLogic = this.overriddenLogics.find((item) => item.name === options);
+            if (!overriddenLogic) {
+                throw new Error('找不到覆写逻辑 ' + options);
+            }
+        }
+        else {
+            overriddenLogic = options;
+        }
+        return overriddenLogic.delete();
+    }
+    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();
+    }
+    removeFrontendType(options) {
+        let frontendType;
+        if (typeof options === 'string') {
+            frontendType = this.frontendTypes.find((item) => item.name === options);
+            if (!frontendType) {
+                throw new Error('找不到端类型 ' + options);
+            }
+        }
+        else {
+            frontendType = options;
+        }
+        return frontendType.delete();
+    }
+    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();
+    }
+    removeProcessV2(options) {
+        let processV2;
+        if (typeof options === 'string') {
+            processV2 = this.processV2s.find((item) => item.name === options);
+            if (!processV2) {
+                throw new Error('找不到流程 ' + options);
+            }
+        }
+        else {
+            processV2 = options;
+        }
+        return processV2.delete();
+    }
+    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();
+    }
+    removeConnector(options) {
+        let connector;
+        if (typeof options === 'string') {
+            connector = this.connectorDependencies.find((item) => item.name === options);
+            if (!connector) {
+                throw new Error('找不到连接器 ' + options);
+            }
+        }
+        else {
+            connector = options;
+        }
+        return connector.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();
+    }
+    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();
+    }
+    removeAuthLogic(options) {
+        let authLogic;
+        if (typeof options === 'string') {
+            authLogic = this.authLogics.find((item) => item.name === options);
+            if (!authLogic) {
+                throw new Error('找不到鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogic = options;
+        }
+        return authLogic.delete();
+    }
+    removeAuthLogicForCallInterface(options) {
+        let authLogicForCallInterface;
+        if (typeof options === 'string') {
+            authLogicForCallInterface = this.authLogicsForCallInterface.find((item) => item.name === options);
+            if (!authLogicForCallInterface) {
+                throw new Error('找不到调用接口的鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogicForCallInterface = options;
+        }
+        return authLogicForCallInterface.delete();
+    }
+    removeConnection(options) {
+        let connection;
+        if (typeof options === 'string') {
+            connection = this.connections.find((item) => item.name === options);
+            if (!connection) {
+                throw new Error('找不到连接 ' + options);
+            }
+        }
+        else {
+            connection = options;
+        }
+        return connection.delete();
+    }
+    removeTriggerLauncher(options) {
+        let triggerLauncher;
+        if (typeof options === 'string') {
+            triggerLauncher = this.triggerLaunchers.find((item) => item.name === options);
+            if (!triggerLauncher) {
+                throw new Error('找不到触发器启动器 ' + options);
+            }
+        }
+        else {
+            triggerLauncher = options;
+        }
+        return triggerLauncher.delete();
+    }
+    removeMetadataType(options) {
+        let metadataType;
+        if (typeof options === 'string') {
+            metadataType = this.metadataTypes.find((item) => item.name === options);
+            if (!metadataType) {
+                throw new Error('找不到元数据类型 ' + options);
+            }
+        }
+        else {
+            metadataType = options;
+        }
+        return metadataType.delete();
+    }
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    getDefaultOnAnno() {
+        let result = {
+            Entity: [],
+            Logic: [],
+            ViewElement: [],
+        };
+        this?.dependencies?.forEach((dep) => {
+            if (dep?.annotations?.length > 0) {
+                dep.annotations.forEach((anno) => {
+                    let useAnno = anno?.properties?.find((p) => p?.name === 'useAnno');
+                    if (useAnno && ['true', true].includes(useAnno.defaultValue?.expression?.value)) {
+                        anno.applyTo.map((concept) => {
+                            result[concept].push(anno);
+                        });
+                    }
+                });
+            }
+        });
+        return result;
+    }
+    findDataSourceByName(name) {
+        return this.dataSources.find((dataSourceItem) => dataSourceItem.name === name);
+    }
+    get defaultDS() {
+        return this.dataSources?.find((dataSource) => dataSource.name === 'defaultDS');
+    }
+    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);
+    }
+    /**
+  
+    /**
+     * 判断缓存是否为空
+     */
+    isComposeCacheEmpty() {
+        const isEmpty = (composeCache) => {
+            let result = true;
+            for (const key in composeCache) {
+                if (key !== 'nodes') {
+                    result = result && isEmpty(composeCache[key]);
+                }
+            }
+            return result && !composeCache?.nodes?.length;
+        };
+        return isEmpty(this.composeCache);
+    }
+    /**
+     * 获取组合节点
+     */
+    getCompose(path) {
+        let compose = this.composeCache;
+        path.forEach((key) => {
+            compose = compose?.[key];
+        });
+        return compose || null;
+    }
+    /**
+     * 获取组合节点
+     */
+    getComposeNodes(path) {
+        let compose = this.composeCache;
+        path.forEach((key) => {
+            compose = compose?.[key];
+        });
+        return compose?.nodes || [];
+    }
+    /**
+     * 往组合内添加节点
+     */
+    addComposeNodes(path, node) {
+        let compose = this.composeCache;
+        path.forEach((key, index) => {
+            if (index === path.length - 1) {
+                if (compose?.[key]?.nodes) {
+                    // 需要判断下nodes里面是否已经存在
+                    if (Array.isArray(node)) {
+                        node.forEach((item) => {
+                            if (!compose[key].nodes.find((it) => it === item)) {
+                                compose[key].nodes.push(item);
+                            }
+                        });
+                    }
+                    else {
+                        if (!compose[key].nodes.find((it) => it === node)) {
+                            compose[key].nodes.push(node);
+                        }
+                    }
+                    // 去重
+                    compose[key].nodes = Array.from(new Set(compose[key].nodes));
+                }
+                else {
+                    if (!compose?.[key]) {
+                        compose[key] = {};
+                    }
+                    compose[key].nodes = Array.isArray(node) ? node : [node];
+                }
+            }
+            else {
+                if (!compose?.[key]) {
+                    compose[key] = {};
+                }
+                compose = compose[key];
+            }
+        });
+    }
+    /**
+     * 删除分组, 包括子集
+     */
+    deleteCompose(path) {
+        if (!Array.isArray(path))
+            return;
+        let compose = this.composeCache;
+        const delNodes = (_compose) => {
+            if (_compose?.nodes) {
+                for (const key in _compose) {
+                    if (key !== 'nodes') {
+                        delNodes(_compose[key]);
+                    }
+                }
+                const arr = [..._compose.nodes] || [];
+                const triggerNode = []; // 触点放在最后删
+                arr.forEach((node) => {
+                    if (node.name === path?.[0]) {
+                        triggerNode.push(node);
+                    }
+                    else {
+                        node && node.delete();
+                    }
+                });
+                triggerNode.forEach((node) => {
+                    node && node.delete();
+                });
+                _compose.nodes = [];
+            }
+        };
+        this.emit('collect:start', {
+            actionMsg: '删除同一分组节点',
+        });
+        path.forEach((key, index) => {
+            if (index === path.length - 1) {
+                delNodes(compose?.[key]);
+            }
+            else {
+                compose = compose[key];
+            }
+        });
+        this.emit('collect:end');
+    }
+    /**
+     * 释放分组内所有节点， 包括子分组
+     */
+    releaseComposeNode(path) {
+        if (!Array.isArray(path))
+            return;
+        let compose = this.composeCache;
+        const releaseNodes = (_compose) => {
+            if (_compose?.nodes) {
+                for (const key in _compose) {
+                    if (key !== 'nodes') {
+                        releaseNodes(_compose[key]);
+                    }
+                }
+                _compose.nodes.forEach((node) => {
+                    node.update({
+                        composedBy: undefined,
+                    });
+                    // 临时兼容性代码，后续抽离成插件化
+                    if (node.tag === 'u-linear-layout') {
+                        const attr = node.bindAttrs.find((it) => it.name === 'TableDesignerLocked');
+                        if (attr) {
+                            attr.delete();
+                            // 数据管理页释放节点时，需要主动调整弹窗的位置
+                            const filterList = [];
+                            node.children.forEach((item) => {
+                                if (item?.tag === 'u-modal') {
+                                    filterList.push(item);
+                                }
+                            });
+                            if (filterList.length > 0) {
+                                const sourceNode = node.parentNode;
+                                filterList.forEach((item) => {
+                                    item.moveNode({
+                                        sourceNode,
+                                        position: 'append',
+                                    });
+                                });
+                            }
+                        }
+                    }
+                });
+                _compose.nodes = [];
+            }
+        };
+        this.emit('collect:start', {
+            actionMsg: '释放节点',
+        });
+        path.forEach((key, index) => {
+            if (index === path.length - 1) {
+                releaseNodes(compose?.[key]);
+            }
+            else {
+                compose = compose[key];
+            }
+        });
+        this.emit('collect:end');
+    }
+    /**
+     * 删除分组内的某一个
+     */
+    deleteComposeNode(path, node) {
+        if (!node)
+            return;
+        let compose = this.composeCache;
+        path.forEach((key, index) => {
+            if (index === path.length - 1) {
+                if (compose?.[key]?.nodes) {
+                    const index = compose[key].nodes.findIndex((it) => it === node);
+                    if (index > -1) {
+                        compose[key].nodes.splice(index, 1);
+                    }
+                }
+            }
+            else {
+                compose = compose[key];
+            }
+        });
+    }
+    /**
+     * 清空某一分组
+     */
+    clearComposeNodes(path) {
+        let compose = this.composeCache;
+        path.forEach((key, index) => {
+            if (index === path.length - 1) {
+                if (compose?.[key]) {
+                    delete compose[key];
+                }
+            }
+            else {
+                compose = compose[key];
+            }
+        });
+    }
+    /**
+     * 获取命名空间
+     */
+    getNamespace() {
+        return 'app';
+    }
+    getTsNamespace() {
+        return `app`;
+    }
+    findNodeByPath(nodePath) {
+        return (0, nasl_utils_1.queryNodeByPath)(this, nodePath);
+    }
+    findNodeByCompleteName(originCompleteName) {
+        let completeName = originCompleteName;
+        // 是否是来自编辑态的自定义连接器
+        const isFromEditableConnector = completeName?.endsWith(utils_1.CUSTOM_CONNECTOR_EDITABLE_SUFFIX);
+        // 如果是自定义连接器，需要去掉后缀才能查找到符合预期的节点
+        if (isFromEditableConnector) {
+            completeName = originCompleteName.replace(utils_1.CUSTOM_CONNECTOR_EDITABLE_SUFFIX, '');
+        }
+        const nameArr = completeName?.split('.') || [];
+        let node = this;
+        // 先处理平台的
+        if (completeName?.startsWith('nasl')) {
+            node = (0, service_1.getNaslNodeByNodeCallee)(nameArr.splice(0, nameArr.length - 1).join('.'), nameArr[nameArr.length - 1]);
+            return node;
+        }
+        const start = nameArr.shift();
+        const mod = 0;
+        const modulesMap = {
+            // v3.3 版本引入自定义连接器，在配置自定义连接器时需要同步支持内部数据结构使用，所以这里做扩展
+            extensions: [...(node?.dependencies || []), ...(node?.integration?.connectors || [])],
+            apis: node.interfaceDependencies,
+            components: node.componentDependencies,
+            // v3.6 版本引入自定义连接器，前缀统一更新为 conenctor
+            // 在配置自定义连接器时需要同步支持内部数据结构使用，所以这里做扩展
+            connector: [...node.connectorDependencies, ...(node?.integration?.connectors || [])],
+        };
+        const modules = modulesMap[start];
+        if (Array.isArray(modules)) {
+            const moduleName = nameArr.shift();
+            if (isFromEditableConnector) {
+                node = modules.find((moduleItem) => moduleItem.name === moduleName && moduleItem?.parentNode?.concept === 'Integration');
+            }
+            else {
+                node = modules.find((moduleItem) => moduleItem.name === moduleName);
+            }
+        }
+        for (let index = 0; index < nameArr.length; index++) {
+            if (!node) {
+                return null;
+            }
+            const nameItem = nameArr[index];
+            // const isKeyword = index % 2 === mod;
+            // if (!isKeyword && Array.isArray(node)) {
+            //     node = node.find(({ name }) => name === nameItem);
+            // } else {
+            //     node = node[nameItem];
+            // }
+            if (Array.isArray(node)) {
+                node = node.find(({ name }) => name === nameItem);
+            }
+            else {
+                node = node[nameItem];
+            }
+        }
+        return node;
+    }
+    loadEnvList() {
+        this.envList = ['dev', 'online'];
+    }
+    loadPackageInfos(inputMaterialConfig) {
+        this.packageInfos = [];
+        const materialConfig = inputMaterialConfig ?? (window.globalData.materialConfig || {});
+        const { framework, ui } = materialConfig;
+        const scopes = ['pc', 'h5'];
+        scopes.forEach((scope) => {
+            if (ui[scope]) {
+                this.packageInfos.push({
+                    ui: ui[scope],
+                    template: framework[scope],
+                    scope,
+                });
+            }
+        });
+        return this.packageInfos;
+    }
+    /**
+     * 根据 packageInfo 的信息生成用于 load 的 assetsInfo
+     * 在环境中需要 basic 和 custom 分开 load，否则容易报错
+     * @param prefix
+     */
+    genAllAssetsInfo(prefix, scope, frameworkKind) {
+        // const packageInfo = this.packageInfo;
+        const packageInfo = this.packageInfos.find((info) => info.scope === scope);
+        const ui = packageInfo?.ui.find((info) => info.frameworkKind === frameworkKind);
+        const template = packageInfo?.template.find((info) => info.frameworkKind === frameworkKind);
+        const result = {
+            basic: {
+                js: [
+                    `${prefix}/packages/vue@2/dist/vue.min.js`,
+                    // `${prefix}/packages/vue-router@3/dist/vue-router.min.js`,
+                    `${prefix}/packages/${ui?.name}@${ui?.version}/dist-theme/index.js`,
+                    `${prefix}/packages/${template?.name}@${template?.version}/cloudAdminDesigner.umd.min.js`,
+                ],
+                css: [
+                    `${prefix}/packages/${ui?.name}@${ui?.version}/dist-theme/index.css`,
+                    `${prefix}/packages/${template?.name}@${template?.version}/cloudAdminDesigner.css`,
+                ],
+            },
+            custom: {
+                js: [],
+                css: [],
+                names: [],
+            },
+        };
+        const frontendTypes = this.frontendTypes.filter((frontendType) => frontendType.kind === scope);
+        const existingSet = new Set();
+        frontendTypes.forEach((frontendType) => {
+            frontendType.componentDependencies.forEach((dep) => {
+                const { name, version } = dep;
+                const jsName = `${prefix}/packages/${name}@${version}/dist-theme/index.js`;
+                if (!existingSet.has(jsName)) {
+                    existingSet.add(jsName);
+                    result.custom.js.push(jsName);
+                    if (utils.shouldLoadCss(name, version)) {
+                        result.custom.css.push(`${prefix}/packages/${name}@${version}/dist-theme/index.css`);
+                    }
+                    result.custom.names.push(name);
+                }
+            });
+        });
+        this.dependencies.forEach((dep) => {
+            const { name, version, compilerInfoMap, frontends } = dep;
+            const prefixPath = compilerInfoMap?.js?.prefix;
+            if (name) {
+                (frontends || []).forEach((frontend) => {
+                    if (frontend.type === scope) {
+                        const cssFileName = 'dist-theme/index.css';
+                        const jsName = `${prefix}/packages/${prefixPath ? `${prefixPath}/` : ''}${name}@${version}/dist-theme/index.js`;
+                        const cssName = `${prefix}/packages/${prefixPath ? `${prefixPath}/` : ''}${name}@${version}/${cssFileName}`;
+                        if (!existingSet.has(jsName)) {
+                            existingSet.add(jsName);
+                            result.custom.js.push(jsName);
+                            if (dep.checkFileInManifest(cssFileName)) {
+                                result.custom.css.push(cssName);
+                            }
+                            result.custom.names.push(dep.name);
+                        }
+                    }
+                });
+            }
+        });
+        return result;
+    }
+    onChange($event) {
+        this.emit('change', $event);
+    }
+    addModuleInDependenciesWithDataSource(options) {
+        this.emit('collect:start', {
+            actionMsg: '导入依赖库',
+        });
+        const existSameNameNode = this.dependencies.find((l) => l.name === options.name);
+        // 同名同版本的依赖库会替换 同名不同版本的依赖库会保留并设置为禁用
+        // (options as Module).enable = true;
+        if (existSameNameNode) {
+            // const hasSameVersion = existSameNameNode.version === (options as Module).version;
+            // if (hasSameVersion) {
+            existSameNameNode.delete();
+            // }
+            // 同名的依赖库 只启用第一个
+            // (options as Module).enable = hasSameVersion;
+        }
+        //  导入依赖库的时候如果有logic 且logic 可以被覆写 需要在app overideLogic 新增一个
+        // 但是导入局部模板的时候已经手动新增了 这里就不需要了
+        // 当依赖库被删除 的时候同样要删除 overideLogic
+        // 支持局部模板导出导入overideLogic
+        // 只复制 depLogic  输入输出参数
+        const node = this.addModuleInDependencies(options);
+        if (node?.logics && node?.logics.length > 0) {
+            node.logics.forEach((logic) => {
+                if (logic?.overridable) {
+                    const existing = this.overriddenLogics.find((ol) => ol.name === logic.name);
+                    !existing &&
+                        this.addOverriddenLogic({
+                            name: logic.name,
+                            description: logic.description,
+                            overriddenModule: node.name,
+                            returns: logic.returns.map((r) => r.toJSON()),
+                            params: logic.params.map((r) => r.toJSON()),
+                        });
+                }
+            });
+        }
+        // 启用的依赖库才创建数据源
+        // if (node.enable && node.dataSources) {
+        if (node.dataSources) {
+            const dataSourceGroup = this.configuration?.getGroup('dataSource');
+            const ConfigProperty = (0, decorators_1.getConceptConstructor)('ConfigProperty');
+            if (dataSourceGroup) {
+                node.dataSources.forEach((datasource) => {
+                    const body = ConfigProperty.from({
+                        name: datasource.name,
+                        description: '',
+                        isPrivate: false,
+                        values: [
+                            { env: 'dev', value: '', concept: 'ConfigPropertyValue' },
+                            { env: 'online', value: '', concept: 'ConfigPropertyValue' },
+                        ],
+                    });
+                    dataSourceGroup.addConfigProperty(body);
+                });
+            }
+        }
+        this.emit('collect:end');
+    }
+    statistics() {
+        const sum = (list) => list.reduce((curr, prev) => prev + curr, 0);
+        const countView = (list) => list.length + sum(list.map((view) => countView(view.children)));
+        return {
+            entityCount: sum(this.dataSources.map((dataSource) => dataSource.entities.length)),
+            structureCount: this.structures.length,
+            enumCount: this.enums.length,
+            logicCount: this.logics.length,
+            viewCount: sum(this.frontendTypes.map((frontendType) => sum(frontendType.frontends.map((frontend) => countView(frontend.views))))),
+            processCount: this.processes.length,
+        };
+    }
+    /**
+     * 需要包含依赖库里的dataSources，不自动生成
+     */
+    getDataSourceExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        const dependDatasources = [];
+        const modules = [...this.dependencies];
+        modules.forEach((module) => {
+            if (Array.isArray(module.dataSources)) {
+                dependDatasources.push(...module.dataSources);
+            }
+        });
+        const dataSources = this.dataSources.concat(dependDatasources);
+        return (dataSources || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    /**
+     * 更新全局设置 preferenceMap
+     */
+    updatePreferenceMap(preferences = {}) {
+        this.emit('collect:start', { actionMsg: '修改实体表名列名' });
+        const oldPreferenceMap = { ...this.preferenceMap };
+        Object.assign(this.preferenceMap, preferences);
+        // 更新实体表名和列名
+        this.dataSources.forEach((ds) => {
+            ds.entities.forEach((e) => {
+                if (oldPreferenceMap['namingConvention.tableName'] !== preferences['namingConvention.tableName']) {
+                    e.formatTableName();
+                }
+                if (oldPreferenceMap['namingConvention.columnName'] !== preferences['namingConvention.columnName']) {
+                    e.formatPropertyColumnName();
+                }
+            });
+        });
+        // 使撤销生效
+        Object.assign(this.preferenceMap, oldPreferenceMap);
+        this.update({
+            preferenceMap: preferences,
+        });
+        this.emit('collect:end');
+    }
+    /* 判断接口是否有误，需要重新导出 */
+    getQualifiedInterface(interfaces = this.interfaces) {
+        // getConceptConstructor
+        const TypeAnnotationClass = (0, decorators_1.getConceptConstructor)('TypeAnnotation');
+        const errorList = [];
+        interfaces.forEach((item) => {
+            const logic = this.logics.find((logic) => logic.name === item.originLogicName);
+            const logicParamMap = {};
+            if (!logic) {
+                return;
+            }
+            logic.params.forEach((param) => {
+                logicParamMap[param.name] = param.typeAnnotation;
+            });
+            item.params.forEach((param) => {
+                const logicTypeAnnotation = TypeAnnotationClass.from(logicParamMap[param.name]?.toJSON());
+                delete logicParamMap[param.name];
+                if (!logicTypeAnnotation) {
+                    return errorList.push({
+                        logicName: logic.name,
+                        interfaceName: item.name,
+                        param: param.name,
+                        type: 1,
+                        message: `参数“${param.name}”已被删除，请确定请求类型无误后点击“重新导出”`,
+                    });
+                }
+                const interfaceTypeAnnotation = TypeAnnotationClass.from(param.typeAnnotation.toJSON());
+                let isSame = false;
+                if (logicTypeAnnotation?.typeNamespace === 'app.enums') {
+                    if (interfaceTypeAnnotation.typeNamespace === 'nasl.core' && interfaceTypeAnnotation.typeName === 'String') {
+                        isSame = true;
+                    }
+                }
+                if (logicTypeAnnotation.isSame(interfaceTypeAnnotation)) {
+                    isSame = true;
+                }
+                if (!isSame) {
+                    errorList.push({
+                        logicName: logic.name,
+                        interfaceName: item.name,
+                        param: param.name,
+                        type: 2,
+                        message: `参数“${param.name}”数据类型变更，请确定请求类型无误后点击“重新导出”`,
+                    });
+                }
+            });
+            const logicReturns = logic.returns;
+            const interfaceReturns = item.returns;
+            if (logicReturns?.length > interfaceReturns?.length) {
+                if (!logicReturns[0].typeAnnotation) {
+                    errorList.push({
+                        logicName: logic.name,
+                        interfaceName: item.name,
+                        resultName: logicReturns[0].name,
+                        type: 4,
+                        message: `输出参数发生变更，请点击“重新导出”`,
+                    });
+                }
+                else {
+                    errorList.push({
+                        logicName: logic.name,
+                        interfaceName: item.name,
+                        resultName: logicReturns[0].name,
+                        type: 4,
+                        message: `输出参数发生变更，请点击“重新导出”`,
+                    });
+                }
+            }
+            else if (logicReturns?.length < interfaceReturns?.length) {
+                errorList.push({
+                    logicName: logic.name,
+                    interfaceName: item.name,
+                    resultName: interfaceReturns[0].name,
+                    type: 4,
+                    message: `输出参数发生变更，请点击“重新导出”`,
+                });
+            }
+            else if (logicReturns?.length === interfaceReturns?.length) {
+                if (logicReturns.length !== 0) {
+                    if (logicReturns[0].name !== interfaceReturns[0].name) {
+                        errorList.push({
+                            logicName: logic.name,
+                            interfaceName: item.name,
+                            resultName: logicReturns[0].name,
+                            type: 4,
+                            message: `输出参数发生变更，请点击“重新导出”`,
+                        });
+                    }
+                    else if (!logicReturns[0].typeAnnotation) {
+                        if (!logicReturns[0]?.__TypeAnnotation) {
+                            errorList.push({
+                                logicName: logic.name,
+                                interfaceName: item.name,
+                                resultName: logicReturns[0].name,
+                                type: 7,
+                                message: `输出参数“${logicReturns[0].name}”没有数据类型，无法导出`,
+                            });
+                        }
+                        else if (!logicReturns[0]?.__TypeAnnotation.isSame(interfaceReturns[0]?.typeAnnotation)) {
+                            errorList.push({
+                                logicName: logic.name,
+                                interfaceName: item.name,
+                                resultName: logicReturns[0].name,
+                                type: 4,
+                                message: `输出参数发生变更，请点击“重新导出”`,
+                            });
+                        }
+                    }
+                    else if (!logicReturns[0]?.typeAnnotation.isSame(interfaceReturns[0]?.typeAnnotation)) {
+                        errorList.push({
+                            logicName: logic.name,
+                            interfaceName: item.name,
+                            resultName: logicReturns[0].name,
+                            type: 4,
+                            message: `输出参数发生变更，请点击“重新导出”`,
+                        });
+                    }
+                }
+            }
+            for (const i in logicParamMap) {
+                errorList.push({
+                    logicName: logic.name,
+                    param: i,
+                    message: `新增参数“${i}”，请确定请求类型无误后点击“重新导出”`,
+                    type: 3,
+                });
+            }
+        });
+        return errorList;
+    }
+    getFrontendExistingTitles(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.frontendTypes || [])
+            .map((frontendType) => frontendType.frontends?.filter((item) => !excludedSet.has(item)).map((item) => item.title))
+            .flat(2);
+    }
+    getExtensionsCallbackLogics() {
+        const resultLogics = new Set();
+        this.frontendTypes.forEach((frontendType) => {
+            frontendType?.frontends?.forEach((frontend) => {
+                frontend.getExtensionsCallbackLogics().forEach((logic) => {
+                    resultLogics.add(logic);
+                });
+            });
+            frontendType?.businessComponents?.forEach((businessComponent) => {
+                (businessComponent?.getViewCallLogics?.() || []).forEach((logic) => {
+                    resultLogics.add(logic);
+                });
+            });
+        });
+        return Array.from(resultLogics);
+    }
+    getJavaLogicUniqueName(name = 'javalogic1') {
+        return utils.unique(name, this.getLogicExistingNames(), undefined, true);
+    }
+    getJavaLogicClassUniqueName(name = 'Javalogic1') {
+        return `${utils.unique(name, this.getLogicExistingNames(), undefined, true)}Service`;
+    }
+    genAllCustomComponents() {
+        const compMap = {
+            pc: [],
+            h5: [],
+        };
+        const existingSet = new Set();
+        this.frontendTypes.forEach((frontendType) => {
+            if (frontendType.componentDependencies) {
+                frontendType.componentDependencies.forEach((dep) => {
+                    const { name } = dep;
+                    if (!existingSet.has(name)) {
+                        compMap[frontendType.kind].push(dep);
+                    }
+                });
+            }
+        });
+        return compMap;
+    }
+    /**
+     * 获取 “系统统一路径前缀”
+     * @returns
+     */
+    get sysPrefixPath() {
+        const uniformPathPrefix = this.configuration?.groups
+            ?.find((item) => item.name === 'system')
+            ?.properties?.find((item) => item.name === 'uniformPathPrefix')
+            ?.values.find((item) => item.env === this.curDeployEnv)?.value;
+        const sysPrefixPath = uniformPathPrefix && uniformPathPrefix !== '/' ? uniformPathPrefix : '';
+        return sysPrefixPath;
+    }
+    getAuthInterfaceUniqueName(name = 'authInterface1') {
+        // never used
+    }
+    get appTimeZone() {
+        return this.configuration?.groups
+            ?.find((item) => item.name === 'system')
+            ?.properties?.find((item) => item.name === 'appTimeZone')
+            ?.values.find((item) => item.env === this.curDeployEnv)?.value;
+    }
+    /** 根据名称获取 triggerLauncher */
+    getTriggerLauncherByName(name) {
+        return this.triggerLaunchers.find((item) => item.name === name);
+    }
+    /** 根据名称获取 Logic */
+    getLogicByName(name) {
+        return this.logics.find((item) => item.name === name);
+    }
+    /** 获取已经存在的Module title */
+    getConnectorExistingTitles(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.connectorDependencies || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.title);
+    }
+    /** hank */
+    // setConnector() {
+    //   const [a, b, c, d] = this.dependencies;
+    //   const Module = getConceptConstructor('Module');
+    //   const module = Module.from({
+    //     "concept": "Module",
+    //     "type": "extension",
+    //     "version": "1.0.1",
+    //     "name": "cw_cryptojs_library",
+    //     "title": "前端加密依赖库",
+    //     "description": "",
+    //     "provider": "资产中心-租户",
+    //     "compilerInfoMap": {
+    //         "js": {
+    //             "prefix": "extension"
+    //         }
+    //     },
+    //     "dataSources": [],
+    //     "structures": [],
+    //     "enums": [],
+    //     "logics": [],
+    //     "interfaces": [],
+    //     "views": [],
+    //     "frontendVariables": [],
+    //     "processes": [],
+    //     "processV2s": [],
+    //     "frontends": [
+    //         {
+    //             "concept": "FrontendLibrary",
+    //             "name": "pc",
+    //             "type": "pc",
+    //             "logics": [
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "decryptDataWithSalt",
+    //                     "description": "加盐解密算法",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "encryptedData",
+    //                             "description": "加密数据",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "secretKey",
+    //                             "description": "密钥",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         }
+    //                     ],
+    //                     "playground": []
+    //                 },
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "encryptByDes",
+    //                     "description": "Des加密",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "data",
+    //                             "description": "需要加密的内容",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "key",
+    //                             "description": "加密的key",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "iv",
+    //                             "description": "加密的iv",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         }
+    //                     ],
+    //                     "playground": []
+    //                 },
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "encryptDataWithSalt",
+    //                     "description": "加盐加密算法",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "data",
+    //                             "description": "待加密数据",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "secretKey",
+    //                             "description": "密钥",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         }
+    //                     ],
+    //                     "playground": []
+    //                 },
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "encryptSha256",
+    //                     "description": "RSA-SHA256加密",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "rsa",
+    //                             "description": "加密私钥",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         }
+    //                     ],
+    //                     "playground": []
+    //                 },
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "addWaterImgMarkAsync",
+    //                     "description": "",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "taskId",
+    //                             "description": "",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "srcFile",
+    //                             "description": "",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "imgPath",
+    //                             "description": "",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "textFont",
+    //                             "description": "",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "func",
+    //                             "description": "",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "function",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "",
+    //                                 "typeArguments": [
+    //                                     {
+    //                                         "concept": "TypeAnnotation",
+    //                                         "typeKind": "generic",
+    //                                         "typeNamespace": "nasl.collection",
+    //                                         "typeName": "Map",
+    //                                         "typeArguments": [
+    //                                             {
+    //                                                 "concept": "TypeAnnotation",
+    //                                                 "typeKind": "primitive",
+    //                                                 "typeNamespace": "nasl.core",
+    //                                                 "typeName": "String",
+    //                                                 "typeArguments": null,
+    //                                                 "returnType": null,
+    //                                                 "properties": null
+    //                                             },
+    //                                             {
+    //                                                 "concept": "TypeAnnotation",
+    //                                                 "typeKind": "primitive",
+    //                                                 "typeNamespace": "nasl.core",
+    //                                                 "typeName": "String",
+    //                                                 "typeArguments": null,
+    //                                                 "returnType": null,
+    //                                                 "properties": null
+    //                                             }
+    //                                         ],
+    //                                         "returnType": null,
+    //                                         "properties": null
+    //                                     }
+    //                                 ],
+    //                                 "returnType": [
+    //                                     {
+    //                                         "concept": "TypeAnnotation",
+    //                                         "typeKind": "primitive",
+    //                                         "typeNamespace": "nasl.core",
+    //                                         "typeName": "String",
+    //                                         "typeArguments": null,
+    //                                         "returnType": null,
+    //                                         "properties": null
+    //                                     }
+    //                                 ],
+    //                                 "properties": null
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false,
+    //                             "changedTime": 1711351957157,
+    //                             "spread": true
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "description": "",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null
+    //                         }
+    //                     ],
+    //                     "playground": [],
+    //                     "changedTime": 1711009353914
+    //                 }
+    //             ],
+    //             "viewComponents": []
+    //         },
+    //         {
+    //             "concept": "FrontendLibrary",
+    //             "name": "h5",
+    //             "type": "h5",
+    //             "logics": [
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "decryptDataWithSalt",
+    //                     "description": "加盐解密算法",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "encryptedData",
+    //                             "description": "加密数据",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "secretKey",
+    //                             "description": "密钥",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         }
+    //                     ],
+    //                     "playground": []
+    //                 },
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "encryptByDes",
+    //                     "description": "Des加密",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "data",
+    //                             "description": "需要加密的内容",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "key",
+    //                             "description": "加密的key",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "iv",
+    //                             "description": "加密的iv",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         }
+    //                     ],
+    //                     "playground": []
+    //                 },
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "encryptDataWithSalt",
+    //                     "description": "加盐加密算法",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "data",
+    //                             "description": "待加密数据",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         },
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "secretKey",
+    //                             "description": "密钥",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         }
+    //                     ],
+    //                     "playground": []
+    //                 },
+    //                 {
+    //                     "concept": "Logic",
+    //                     "name": "encryptSha256",
+    //                     "description": "RSA-SHA256加密",
+    //                     "typeParams": null,
+    //                     "params": [
+    //                         {
+    //                             "concept": "Param",
+    //                             "name": "rsa",
+    //                             "description": "加密私钥",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null,
+    //                             "cascader": false
+    //                         }
+    //                     ],
+    //                     "returns": [
+    //                         {
+    //                             "concept": "Return",
+    //                             "name": "result",
+    //                             "typeAnnotation": {
+    //                                 "concept": "TypeAnnotation",
+    //                                 "typeKind": "primitive",
+    //                                 "typeNamespace": "nasl.core",
+    //                                 "typeName": "String",
+    //                                 "typeArguments": null,
+    //                                 "returnType": null,
+    //                                 "properties": null,
+    //                                 "name": ""
+    //                             },
+    //                             "defaultValue": null
+    //                         }
+    //                     ],
+    //                     "variables": [],
+    //                     "body": [
+    //                         {
+    //                             "concept": "Start",
+    //                             "label": "开始",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         },
+    //                         {
+    //                             "concept": "End",
+    //                             "label": "结束",
+    //                             "description": null,
+    //                             "folded": false,
+    //                             "offsetX": null,
+    //                             "offsetY": null,
+    //                             "name": ""
+    //                         }
+    //                     ],
+    //                     "playground": []
+    //                 }
+    //             ],
+    //             "viewComponents": []
+    //         }
+    //     ],
+    //     "triggerLaunchers": [],
+    //     "connections": [],
+    //     "metadataTypes": [],
+    //     "dependencies": [],
+    //     "changedTime": 1711359928093
+    // })
+    //   this.update({
+    //     dependencies: [a, b, c, module],
+    //   });
+    // }
+    toNaturalTS(state = (0, nasl_translator_1.createCompilerState)()) {
+        let code = '';
+        this.dependencies?.forEach((dep) => {
+            code += dep.toNaturalTS(state) + '\n\n';
+        });
+        this.interfaceDependencies?.forEach((dep) => {
+            code += dep.toNaturalTS(state) + '\n\n';
+        });
+        this.dataSources?.forEach((dataSource) => {
+            code += dataSource.toNaturalTS(state) + '\n';
+        });
+        this.structures?.forEach((structure) => {
+            code += structure.toNaturalTS(state) + '\n';
+        });
+        this.enums?.forEach((enumeration) => {
+            code += enumeration.toNaturalTS(state) + '\n';
+        });
+        this.metadataTypes?.forEach((metadataType) => {
+            code += metadataType.toNaturalTS(state) + '\n';
+        });
+        if (this.metadataTypes.length)
+            code += '\n';
+        this.logics?.forEach((logic) => {
+            code += logic.toNaturalTS(state) + '\n\n';
+        });
+        this.overriddenLogics?.forEach((logic) => {
+            code += logic.toNaturalTS(state) + '\n\n';
+        });
+        this.interfaces?.forEach((inter) => {
+            code += inter.toNaturalTS(state) + '\n';
+        });
+        this.roles?.forEach((role) => {
+            code += role.toNaturalTS(state) + '\n';
+        });
+        this.frontendTypes?.forEach((frontendType, index) => {
+            code += frontendType.toNaturalTS(state);
+            if (index !== this.frontendTypes.length - 1)
+                code += '\n';
+        });
+        return code;
+    }
+    toTextualNASL(state = (0, nasl_translator_1.createCompilerState)()) {
+        let code = '';
+        this.dependencies?.forEach((dep) => {
+            code += dep.toTextualNASL(state) + '\n';
+        });
+        this.interfaceDependencies?.forEach((dep) => {
+            code += dep.toTextualNASL(state) + '\n';
+        });
+        this.dataSources?.forEach((dataSource) => {
+            code += dataSource.toTextualNASL(state) + '\n';
+        });
+        this.structures?.forEach((structure) => {
+            code += structure.toTextualNASL(state) + '\n';
+        });
+        this.enums?.forEach((enumeration) => {
+            code += enumeration.toTextualNASL(state) + '\n';
+        });
+        this.metadataTypes?.forEach((metadataType) => {
+            code += metadataType.toTextualNASL(state) + '\n';
+        });
+        this.logics?.forEach((logic) => {
+            code += logic.toTextualNASL(state) + '\n\n';
+        });
+        this.overriddenLogics?.forEach((logic) => {
+            code += logic.toTextualNASL(state) + '\n\n';
+        });
+        this.interfaces?.forEach((inter) => {
+            code += inter.toTextualNASL(state) + '\n';
+        });
+        this.roles?.forEach((role) => {
+            code += role.toTextualNASL(state) + '\n';
+        });
+        this.frontendTypes?.forEach((frontendType, index) => {
+            code += frontendType.toTextualNASL(state);
+            if (index !== this.frontendTypes.length - 1)
+                code += '\n';
+        });
+        return code;
+    }
+};
+exports.App = App;
+__decorate([
+    (0, decorators_1.property)()
+    // @ts-ignore
+], App.prototype, "concept", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "id", 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, "hasUserCenter", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "hasAuth", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'DataSource',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "dataSources", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Structure',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "structures", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Enum',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "enums", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Logic',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "logics", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'OverriddenLogic',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "overriddenLogics", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'AbstractInterface',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "interfaces", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'FrontendType',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "frontendTypes", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Backend',
+    })
+], App.prototype, "backend", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Process',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "processes", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'ProcessV2',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "processV2s", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Role',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "roles", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Configuration',
+    })
+], App.prototype, "configuration", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Connector',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "connectorDependencies", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Module',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "interfaceDependencies", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Module',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "dependencies", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Integration',
+    })
+], App.prototype, "integration", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'AuthLogic',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "authLogics", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'AuthLogicForCallInterface',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "authLogicsForCallInterface", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Connection',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "connections", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'TriggerLauncher',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "triggerLaunchers", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'MetadataType',
+        isArray: true,
+        defaultValue: [],
+    })
+], App.prototype, "metadataTypes", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], App.prototype, "preferenceMap", 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);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "naslServer", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], App.prototype, "newProcessVersion", void 0);
+__decorate([
+    (0, nasl_translator_1.withSourceMap)()
+], App.prototype, "toNaturalTS", null);
+__decorate([
+    (0, nasl_translator_1.withSourceMap)()
+], App.prototype, "toTextualNASL", null);
+exports.App = App = App_1 = __decorate([
+    (0, decorators_1.concept)('应用')
+], App);
+exports.default = App;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================
+//# sourceMappingURL=App__.js.map