@lcap/nasl 1.0.0-alpha.7 → 1.0.0

package/src/concepts/Module__.ts

@@ -1,7 +1,7 @@
 type PropertyType = 'structures' | 'enums' | 'entities' | 'interfaces' | 'processes' | 'views';
 const moduleNameSpace = {
     dependencies: 'extensions',
-    interfaceDependencies: 'Minterfaces',
+    interfaceDependencies: 'apis',
     componentDependencies: 'components',
 };
 type ModuleKeyType = 'dependencies' | 'interfaceDependencies' | 'componentDependencies';
@@ -71,7 +71,7 @@ export class Module extends BaseNode {
      * 外部语言依赖
      */
     @property()
-    externalDependencyMap: { maven?: Array<{ groupId: string; artifactId: string; version: string }> } = undefined;
+    externalDependencyMap: { maven?: Array<{ groupId: string, artifactId: string, version: string }> } = undefined;
 
     /**
      * 实体列表
@@ -152,8 +152,9 @@ export class Module extends BaseNode {
         }
         return params;
     }
+    
 
-    getEntityExistingNames(excludedList: Array<Entity> = []) {
+        getEntityExistingNames(excludedList: Array<Entity> = []) {
         const excludedSet = new Set(excludedList);
         return (this.entities || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -162,24 +163,24 @@ export class Module extends BaseNode {
     }
 
     /**
-     * 插入实体
-     * @internal
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入实体
+    * @internal
+    * @param name 实体名称，如果不填会自动生成一个唯一名称
+    */
     _insertEntityAt(name: string, index: number): Entity;
 
     /**
-     * 插入实体
-     * @internal
-     * @param entityOptions 实体参数
-     */
+    * 插入实体
+    * @internal
+    * @param entityOptions 实体参数
+    */
     _insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
 
     /**
-     * 插入实体
-     * @internal
-     * @param entity 已有的实体实例
-     */
+    * 插入实体
+    * @internal
+    * @param entity 已有的实体实例
+    */
     _insertEntityAt(entity: Entity, index: number): Entity;
 
     _insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
@@ -197,7 +198,7 @@ export class Module extends BaseNode {
                 name: options,
             }, this, 'entities');
         } else if (options instanceof Entity) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             entity = options;
             Object.assign(entity, relationOptions);
         } else {
@@ -285,7 +286,7 @@ export class Module extends BaseNode {
 
     addEntity(options?: string | Partial<Entity> | Entity) {
         const node = this._addEntity(options as any);
-        const index = 0;
+        const index = this.entities.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -294,6 +295,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getStructureExistingNames(excludedList: Array<Structure> = []) {
         const excludedSet = new Set(excludedList);
         return (this.structures || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -303,24 +305,24 @@ export class Module extends BaseNode {
     }
 
     /**
-     * 插入数据结构
-     * @internal
-     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入数据结构
+    * @internal
+    * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+    */
     _insertStructureAt(name: string, index: number): Structure;
 
     /**
-     * 插入数据结构
-     * @internal
-     * @param structureOptions 数据结构参数
-     */
+    * 插入数据结构
+    * @internal
+    * @param structureOptions 数据结构参数
+    */
     _insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
 
     /**
-     * 插入数据结构
-     * @internal
-     * @param structure 已有的数据结构实例
-     */
+    * 插入数据结构
+    * @internal
+    * @param structure 已有的数据结构实例
+    */
     _insertStructureAt(structure: Structure, index: number): Structure;
 
     _insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
@@ -338,7 +340,7 @@ export class Module extends BaseNode {
                 name: options,
             }, this, 'structures');
         } else if (options instanceof Structure) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             structure = options;
             Object.assign(structure, relationOptions);
         } else {
@@ -426,7 +428,7 @@ export class Module extends BaseNode {
 
     addStructure(options?: string | Partial<Structure> | Structure) {
         const node = this._addStructure(options as any);
-        const index = 0;
+        const index = this.structures.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -435,6 +437,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getEnumExistingNames(excludedList: Array<Enum> = []) {
         const excludedSet = new Set(excludedList);
         return (this.enums || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -444,24 +447,24 @@ export class Module extends BaseNode {
     }
 
     /**
-     * 插入枚举
-     * @internal
-     * @param name 枚举名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入枚举
+    * @internal
+    * @param name 枚举名称，如果不填会自动生成一个唯一名称
+    */
     _insertEnumAt(name: string, index: number): Enum;
 
     /**
-     * 插入枚举
-     * @internal
-     * @param enumerationOptions 枚举参数
-     */
+    * 插入枚举
+    * @internal
+    * @param enumerationOptions 枚举参数
+    */
     _insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
 
     /**
-     * 插入枚举
-     * @internal
-     * @param enumeration 已有的枚举实例
-     */
+    * 插入枚举
+    * @internal
+    * @param enumeration 已有的枚举实例
+    */
     _insertEnumAt(enumeration: Enum, index: number): Enum;
 
     _insertEnumAt(options: string | Partial<Enum> | Enum, index: number) {
@@ -479,7 +482,7 @@ export class Module extends BaseNode {
                 name: options,
             }, this, 'enums');
         } else if (options instanceof Enum) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             enumeration = options;
             Object.assign(enumeration, relationOptions);
         } else {
@@ -567,7 +570,7 @@ export class Module extends BaseNode {
 
     addEnum(options?: string | Partial<Enum> | Enum) {
         const node = this._addEnum(options as any);
-        const index = 0;
+        const index = this.enums.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -576,6 +579,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getLogicExistingNames(excludedList: Array<Logic> = []) {
         const excludedSet = new Set(excludedList);
         return (this.logics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -585,24 +589,24 @@ export class Module extends BaseNode {
     }
 
     /**
-     * 插入逻辑
-     * @internal
-     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入逻辑
+    * @internal
+    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+    */
     _insertLogicAt(name: string, index: number): Logic;
 
     /**
-     * 插入逻辑
-     * @internal
-     * @param logicOptions 逻辑参数
-     */
+    * 插入逻辑
+    * @internal
+    * @param logicOptions 逻辑参数
+    */
     _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
 
     /**
-     * 插入逻辑
-     * @internal
-     * @param logic 已有的逻辑实例
-     */
+    * 插入逻辑
+    * @internal
+    * @param logic 已有的逻辑实例
+    */
     _insertLogicAt(logic: Logic, index: number): Logic;
 
     _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
@@ -620,7 +624,7 @@ export class Module extends BaseNode {
                 name: options,
             }, this, 'logics');
         } else if (options instanceof Logic) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logic = options;
             Object.assign(logic, relationOptions);
         } else {
@@ -708,7 +712,7 @@ export class Module extends BaseNode {
 
     addLogic(options?: string | Partial<Logic> | Logic) {
         const node = this._addLogic(options as any);
-        const index = 0;
+        const index = this.logics.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -717,6 +721,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getInterfaceExistingNames(excludedList: Array<Interface> = []) {
         const excludedSet = new Set(excludedList);
         return (this.interfaces || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -726,24 +731,24 @@ export class Module extends BaseNode {
     }
 
     /**
-     * 插入接口
-     * @internal
-     * @param name 接口名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入接口
+    * @internal
+    * @param name 接口名称，如果不填会自动生成一个唯一名称
+    */
     _insertInterfaceAt(name: string, index: number): Interface;
 
     /**
-     * 插入接口
-     * @internal
-     * @param itfaceOptions 接口参数
-     */
+    * 插入接口
+    * @internal
+    * @param itfaceOptions 接口参数
+    */
     _insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
 
     /**
-     * 插入接口
-     * @internal
-     * @param itface 已有的接口实例
-     */
+    * 插入接口
+    * @internal
+    * @param itface 已有的接口实例
+    */
     _insertInterfaceAt(itface: Interface, index: number): Interface;
 
     _insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
@@ -761,7 +766,7 @@ export class Module extends BaseNode {
                 name: options,
             }, this, 'interfaces');
         } else if (options instanceof Interface) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             itface = options;
             Object.assign(itface, relationOptions);
         } else {
@@ -849,7 +854,7 @@ export class Module extends BaseNode {
 
     addInterface(options?: string | Partial<Interface> | Interface) {
         const node = this._addInterface(options as any);
-        const index = 0;
+        const index = this.interfaces.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -858,6 +863,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getViewExistingNames(excludedList: Array<View> = []) {
         const excludedSet = new Set(excludedList);
         return (this.views || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -867,24 +873,24 @@ export class Module extends BaseNode {
     }
 
     /**
-     * 插入页面
-     * @internal
-     * @param name 页面名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入页面
+    * @internal
+    * @param name 页面名称，如果不填会自动生成一个唯一名称
+    */
     _insertViewAt(name: string, index: number): View;
 
     /**
-     * 插入页面
-     * @internal
-     * @param viewOptions 页面参数
-     */
+    * 插入页面
+    * @internal
+    * @param viewOptions 页面参数
+    */
     _insertViewAt(viewOptions: Partial<View>, index: number): View;
 
     /**
-     * 插入页面
-     * @internal
-     * @param view 已有的页面实例
-     */
+    * 插入页面
+    * @internal
+    * @param view 已有的页面实例
+    */
     _insertViewAt(view: View, index: number): View;
 
     _insertViewAt(options: string | Partial<View> | View, index: number) {
@@ -902,7 +908,7 @@ export class Module extends BaseNode {
                 name: options,
             }, this, 'views');
         } else if (options instanceof View) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             view = options;
             Object.assign(view, relationOptions);
         } else {
@@ -990,7 +996,7 @@ export class Module extends BaseNode {
 
     addView(options?: string | Partial<View> | View) {
         const node = this._addView(options as any);
-        const index = this.views.length;
+        const index = this.views.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -999,6 +1005,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getProcessExistingNames(excludedList: Array<Process> = []) {
         const excludedSet = new Set(excludedList);
         return (this.processes || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -1008,24 +1015,24 @@ export class Module extends BaseNode {
     }
 
     /**
-     * 插入流程
-     * @internal
-     * @param name 流程名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入流程
+    * @internal
+    * @param name 流程名称，如果不填会自动生成一个唯一名称
+    */
     _insertProcessAt(name: string, index: number): Process;
 
     /**
-     * 插入流程
-     * @internal
-     * @param processOptions 流程参数
-     */
+    * 插入流程
+    * @internal
+    * @param processOptions 流程参数
+    */
     _insertProcessAt(processOptions: Partial<Process>, index: number): Process;
 
     /**
-     * 插入流程
-     * @internal
-     * @param process 已有的流程实例
-     */
+    * 插入流程
+    * @internal
+    * @param process 已有的流程实例
+    */
     _insertProcessAt(process: Process, index: number): Process;
 
     _insertProcessAt(options: string | Partial<Process> | Process, index: number) {
@@ -1043,7 +1050,7 @@ export class Module extends BaseNode {
                 name: options,
             }, this, 'processes');
         } else if (options instanceof Process) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             process = options;
             Object.assign(process, relationOptions);
         } else {
@@ -1131,7 +1138,7 @@ export class Module extends BaseNode {
 
     addProcess(options?: string | Partial<Process> | Process) {
         const node = this._addProcess(options as any);
-        const index = 0;
+        const index = this.processes.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -1140,6 +1147,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getViewComponentExistingNames(excludedList: Array<ViewComponent> = []) {
         const excludedSet = new Set(excludedList);
         return (this.viewComponents || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -1149,24 +1157,24 @@ export class Module extends BaseNode {
     }
 
     /**
-     * 插入页面组件
-     * @internal
-     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
-     */
+    * 插入页面组件
+    * @internal
+    * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+    */
     _insertViewComponentAt(name: string, index: number): ViewComponent;
 
     /**
-     * 插入页面组件
-     * @internal
-     * @param viewComponentOptions 页面组件参数
-     */
+    * 插入页面组件
+    * @internal
+    * @param viewComponentOptions 页面组件参数
+    */
     _insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
 
     /**
-     * 插入页面组件
-     * @internal
-     * @param viewComponent 已有的页面组件实例
-     */
+    * 插入页面组件
+    * @internal
+    * @param viewComponent 已有的页面组件实例
+    */
     _insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
 
     _insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
@@ -1184,7 +1192,7 @@ export class Module extends BaseNode {
                 name: options,
             }, this, 'viewComponents');
         } else if (options instanceof ViewComponent) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             viewComponent = options;
             Object.assign(viewComponent, relationOptions);
         } else {
@@ -1272,7 +1280,7 @@ export class Module extends BaseNode {
 
     addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
         const node = this._addViewComponent(options as any);
-        const index = this.viewComponents.length;
+        const index = this.viewComponents.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -1281,10 +1289,13 @@ export class Module extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
-     * 删除实体
-     * @param name 实体名称
-     */
+    * 删除实体
+    * @param name 实体名称
+    */
     removeEntity(name: string): void;
 
     /**
@@ -1329,10 +1340,12 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
-     * 删除数据结构
-     * @param name 数据结构名称
-     */
+    * 删除数据结构
+    * @param name 数据结构名称
+    */
     removeStructure(name: string): void;
 
     /**
@@ -1377,10 +1390,12 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
-     * 删除枚举
-     * @param name 枚举名称
-     */
+    * 删除枚举
+    * @param name 枚举名称
+    */
     removeEnum(name: string): void;
 
     /**
@@ -1425,10 +1440,12 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
-     * 删除逻辑
-     * @param name 逻辑名称
-     */
+    * 删除逻辑
+    * @param name 逻辑名称
+    */
     removeLogic(name: string): void;
 
     /**
@@ -1473,10 +1490,12 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
-     * 删除接口
-     * @param name 接口名称
-     */
+    * 删除接口
+    * @param name 接口名称
+    */
     removeInterface(name: string): void;
 
     /**
@@ -1521,10 +1540,12 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
-     * 删除页面
-     * @param name 页面名称
-     */
+    * 删除页面
+    * @param name 页面名称
+    */
     removeView(name: string): void;
 
     /**
@@ -1569,10 +1590,12 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
-     * 删除流程
-     * @param name 流程名称
-     */
+    * 删除流程
+    * @param name 流程名称
+    */
     removeProcess(name: string): void;
 
     /**
@@ -1617,10 +1640,12 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
-     * 删除页面组件
-     * @param name 页面组件名称
-     */
+    * 删除页面组件
+    * @param name 页面组件名称
+    */
     removeViewComponent(name: string): void;
 
     /**
@@ -1670,6 +1695,13 @@ export class Module extends BaseNode {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
 
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name = this.name) {
+        return `/embedded/${this.app.name}/${this.parentKey}/${this.name}`;
+    }
     /**
      * 获取命名空间和
      * 暂时不考虑 Module 嵌套的情况
@@ -1678,6 +1710,10 @@ export class Module extends BaseNode {
         return `${moduleNameSpace[this.parentKey as ModuleKeyType]}.${this.name}`;
     }
 
+    getTsNamespace() {
+        return `${moduleNameSpace[this.parentKey as ModuleKeyType]}.${this.tsName}`;
+    }
+
     /**
      *  获取属性节点是否存在
      */
@@ -1692,7 +1728,7 @@ export class Module extends BaseNode {
     //================================================================================
 }
 
-classMap.Module = Module;
+classMap['Module'] = Module;
 export default Module;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑