@lcap/nasl 1.0.1 → 2.12.0-beta.1

package/out/concepts/Module__.d.ts

@@ -1,7 +1,6 @@
 declare type PropertyType = 'structures' | 'enums' | 'entities' | 'interfaces' | 'processes' | 'views';
 import { Params } from '../common/EventEmitter';
 import BaseNode from '../common/BaseNode';
-import Entity from './Entity__';
 import Structure from './Structure__';
 import Enum from './Enum__';
 import Logic from './Logic__';
@@ -48,10 +47,6 @@ export declare class Module extends BaseNode {
             version: string;
         }>;
     };
-    /**
-     * 实体列表
-     */
-    entities: Array<Entity>;
     /**
      * 数据结构列表
      */
@@ -94,94 +89,25 @@ export declare class Module extends BaseNode {
      * @internal
      */
     _delete(): Params;
-    getEntityExistingNames(excludedList?: Array<Entity>): string[];
-    getEntityUniqueName(name?: string): string;
-    /**
-    * 插入实体
-    * @internal
-    * @param name 实体名称，如果不填会自动生成一个唯一名称
-    */
-    _insertEntityAt(name: string, index: number): Entity;
-    /**
-    * 插入实体
-    * @internal
-    * @param entityOptions 实体参数
-    */
-    _insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
-    /**
-    * 插入实体
-    * @internal
-    * @param entity 已有的实体实例
-    */
-    _insertEntityAt(entity: Entity, index: number): Entity;
-    /**
-     * 插入实体
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
-     */
-    insertEntityAt(name: string, index: number): Entity;
-    /**
-     * 插入实体
-     * @param entityOptions 实体参数
-     */
-    insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
-    /**
-     * 插入实体
-     * @param entity 已有的实体实例
-     */
-    insertEntityAt(entity: Entity, index: number): Entity;
-    /**
-     * 添加实体
-     * @internal
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
-     */
-    _addEntity(name?: string): Entity;
+    getStructureExistingNames(excludedList?: Array<Structure>): string[];
+    getStructureUniqueName(name?: string): string;
     /**
-     * 添加实体
+     * 插入数据结构
      * @internal
-     * @param entityOptions 实体参数
+     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
      */
-    _addEntity(entityOptions: Partial<Entity>): Entity;
+    _insertStructureAt(name: string, index: number): Structure;
     /**
-     * 添加实体
+     * 插入数据结构
      * @internal
-     * @param entity 已有的实体实例
+     * @param structureOptions 数据结构参数
      */
-    _addEntity(entity: Entity): Entity;
+    _insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
     /**
-     * 添加实体
+     * 插入数据结构
      * @internal
-     * @param name 实体名称，如果不填会自动生成一个唯一名称
-     */
-    addEntity(name?: string): Entity;
-    /**
-     * 添加实体
-     * @param entityOptions 实体参数
-     */
-    addEntity(entityOptions: Partial<Entity>): Entity;
-    /**
-     * 添加实体
-     * @param entity 已有的实体实例
+     * @param structure 已有的数据结构实例
      */
-    addEntity(entity: Entity): Entity;
-    getStructureExistingNames(excludedList?: Array<Structure>): string[];
-    getStructureUniqueName(name?: string): string;
-    /**
-    * 插入数据结构
-    * @internal
-    * @param name 数据结构名称，如果不填会自动生成一个唯一名称
-    */
-    _insertStructureAt(name: string, index: number): Structure;
-    /**
-    * 插入数据结构
-    * @internal
-    * @param structureOptions 数据结构参数
-    */
-    _insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
-    /**
-    * 插入数据结构
-    * @internal
-    * @param structure 已有的数据结构实例
-    */
     _insertStructureAt(structure: Structure, index: number): Structure;
     /**
      * 插入数据结构
@@ -235,22 +161,22 @@ export declare class Module extends BaseNode {
     getEnumExistingNames(excludedList?: Array<Enum>): string[];
     getEnumUniqueName(name?: string): string;
     /**
-    * 插入枚举
-    * @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;
     /**
      * 插入枚举
@@ -304,22 +230,22 @@ export declare class Module extends BaseNode {
     getLogicExistingNames(excludedList?: Array<Logic>): string[];
     getLogicUniqueName(name?: string): string;
     /**
-    * 插入逻辑
-    * @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;
     /**
      * 插入逻辑
@@ -373,22 +299,22 @@ export declare class Module extends BaseNode {
     getInterfaceExistingNames(excludedList?: Array<Interface>): string[];
     getInterfaceUniqueName(name?: string): string;
     /**
-    * 插入接口
-    * @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;
     /**
      * 插入接口
@@ -442,22 +368,22 @@ export declare class Module extends BaseNode {
     getViewExistingNames(excludedList?: Array<View>): string[];
     getViewUniqueName(name?: string): string;
     /**
-    * 插入页面
-    * @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;
     /**
      * 插入页面
@@ -511,22 +437,22 @@ export declare class Module extends BaseNode {
     getProcessExistingNames(excludedList?: Array<Process>): string[];
     getProcessUniqueName(name?: string): string;
     /**
-    * 插入流程
-    * @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;
     /**
      * 插入流程
@@ -580,22 +506,22 @@ export declare class Module extends BaseNode {
     getViewComponentExistingNames(excludedList?: Array<ViewComponent>): string[];
     getViewComponentUniqueName(name?: string): string;
     /**
-    * 插入页面组件
-    * @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;
     /**
      * 插入页面组件
@@ -647,20 +573,9 @@ export declare class Module extends BaseNode {
      */
     addViewComponent(viewComponent: ViewComponent): ViewComponent;
     /**
-    * 删除实体
-    * @param name 实体名称
-    */
-    removeEntity(name: string): void;
-    /**
-     * 删除实体
-     * @param entity 已有的实体实例
+     * 删除数据结构
+     * @param name 数据结构名称
      */
-    removeEntity(entity: Entity): void;
-    __removeEntity(entity: Entity): Params;
-    /**
-    * 删除数据结构
-    * @param name 数据结构名称
-    */
     removeStructure(name: string): void;
     /**
      * 删除数据结构
@@ -669,9 +584,9 @@ export declare class Module extends BaseNode {
     removeStructure(structure: Structure): void;
     __removeStructure(structure: Structure): Params;
     /**
-    * 删除枚举
-    * @param name 枚举名称
-    */
+     * 删除枚举
+     * @param name 枚举名称
+     */
     removeEnum(name: string): void;
     /**
      * 删除枚举
@@ -680,9 +595,9 @@ export declare class Module extends BaseNode {
     removeEnum(enumeration: Enum): void;
     __removeEnum(enumeration: Enum): Params;
     /**
-    * 删除逻辑
-    * @param name 逻辑名称
-    */
+     * 删除逻辑
+     * @param name 逻辑名称
+     */
     removeLogic(name: string): void;
     /**
      * 删除逻辑
@@ -691,9 +606,9 @@ export declare class Module extends BaseNode {
     removeLogic(logic: Logic): void;
     __removeLogic(logic: Logic): Params;
     /**
-    * 删除接口
-    * @param name 接口名称
-    */
+     * 删除接口
+     * @param name 接口名称
+     */
     removeInterface(name: string): void;
     /**
      * 删除接口
@@ -702,9 +617,9 @@ export declare class Module extends BaseNode {
     removeInterface(itface: Interface): void;
     __removeInterface(itface: Interface): Params;
     /**
-    * 删除页面
-    * @param name 页面名称
-    */
+     * 删除页面
+     * @param name 页面名称
+     */
     removeView(name: string): void;
     /**
      * 删除页面
@@ -713,9 +628,9 @@ export declare class Module extends BaseNode {
     removeView(view: View): void;
     __removeView(view: View): Params;
     /**
-    * 删除流程
-    * @param name 流程名称
-    */
+     * 删除流程
+     * @param name 流程名称
+     */
     removeProcess(name: string): void;
     /**
      * 删除流程
@@ -724,9 +639,9 @@ export declare class Module extends BaseNode {
     removeProcess(process: Process): void;
     __removeProcess(process: Process): Params;
     /**
-    * 删除页面组件
-    * @param name 页面组件名称
-    */
+     * 删除页面组件
+     * @param name 页面组件名称
+     */
     removeViewComponent(name: string): void;
     /**
      * 删除页面组件
@@ -735,19 +650,26 @@ export declare class Module extends BaseNode {
     removeViewComponent(viewComponent: ViewComponent): void;
     __removeViewComponent(viewComponent: ViewComponent): Params;
     /**
-     * 生成宿主语言的文件路径
-     * @param name 一般不用传，用于 rename
+     * 用于区分存量应用新导入模块,存量应用替换数据结构使用
      */
+    isAdd: boolean;
+    setIsAdd(isAdd: boolean): void;
+    /**
+    * 生成宿主语言的文件路径
+    * @param name 一般不用传，用于 rename
+    */
     getEmbeddedFilePath(name?: string): string;
     /**
-     * 获取命名空间和
-     * 暂时不考虑 Module 嵌套的情况
-     */
+    * 获取命名空间和
+    * 暂时不考虑 Module 嵌套的情况
+    */
     getNamespace(): string;
     getTsNamespace(): string;
+    getTsNamespaceAndName(): string;
+    findEnumByName(name: string): Enum;
     /**
-     *  获取属性节点是否存在
-     */
+    *  获取属性节点是否存在
+    */
     findProperty(name: string, propertyType: PropertyType): any;
 }
 export default Module;

package/out/concepts/Module__.js

@@ -43,7 +43,6 @@ const decorators_1 = require("../decorators");
 const utils = __importStar(require("../utils"));
 const BaseNode_1 = __importDefault(require("../common/BaseNode"));
 const classMap_1 = __importDefault(require("../common/classMap"));
-const Entity__1 = __importDefault(require("./Entity__"));
 const Structure__1 = __importDefault(require("./Structure__"));
 const Enum__1 = __importDefault(require("./Enum__"));
 const Logic__1 = __importDefault(require("./Logic__"));
@@ -83,10 +82,6 @@ let Module = Module_1 = class Module extends BaseNode_1.default {
      * 外部语言依赖
      */
     externalDependencyMap = undefined;
-    /**
-     * 实体列表
-     */
-    entities = [];
     /**
      * 数据结构列表
      */
@@ -143,66 +138,6 @@ let Module = Module_1 = class Module extends BaseNode_1.default {
         }
         return params;
     }
-    getEntityExistingNames(excludedList = []) {
-        const excludedSet = new Set(excludedList);
-        return (this.entities || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getEntityUniqueName(name = 'Entity1') {
-        return utils.unique(name, this.getEntityExistingNames(), undefined, false);
-    }
-    _insertEntityAt(options, index) {
-        const entityOptions = {};
-        const relationOptions = { parentNode: this, parentKey: 'entities' };
-        let entity;
-        if (!options) {
-            entity = Entity__1.default.from({
-                ...entityOptions,
-                name: this.getEntityUniqueName(),
-            }, this, 'entities');
-        }
-        else if (typeof options === 'string') {
-            entity = Entity__1.default.from({
-                ...entityOptions,
-                name: options,
-            }, this, 'entities');
-        }
-        else if (options instanceof Entity__1.default) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            entity = options;
-            Object.assign(entity, relationOptions);
-        }
-        else {
-            entity = Entity__1.default.from({
-                ...entityOptions,
-                ...options,
-            }, this, 'entities');
-        }
-        this.entities.splice(index, 0, entity);
-        return entity;
-    }
-    insertEntityAt(options, index) {
-        const node = this._insertEntityAt(options, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'entities',
-        });
-        return node;
-    }
-    _addEntity(options) {
-        const index = 0;
-        return this._insertEntityAt(options, index);
-    }
-    addEntity(options) {
-        const node = this._addEntity(options);
-        const index = this.entities.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'entities',
-        });
-        return node;
-    }
     getStructureExistingNames(excludedList = []) {
         const excludedSet = new Set(excludedList);
         return (this.structures || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -623,42 +558,6 @@ let Module = Module_1 = class Module extends BaseNode_1.default {
         });
         return node;
     }
-    removeEntity(options) {
-        let entity;
-        if (typeof options === 'string') {
-            entity = this.entities.find((item) => item.name === options);
-            if (!entity) {
-                throw new Error('找不到实体 ' + options);
-            }
-        }
-        else {
-            entity = options;
-        }
-        return entity.delete();
-    }
-    __removeEntity(entity) {
-        const parentKey = entity.parentKey;
-        const params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: entity,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray(this[parentKey])) {
-                const index = this[parentKey].indexOf(entity);
-                ~index && this[parentKey].splice(index, 1);
-                params.index = index;
-            }
-            else if (this[parentKey] === entity) {
-                params.index = 0;
-                this[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
     removeStructure(options) {
         let structure;
         if (typeof options === 'string') {
@@ -916,25 +815,43 @@ let Module = Module_1 = class Module extends BaseNode_1.default {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
     /**
-     * 生成宿主语言的文件路径
-     * @param name 一般不用传，用于 rename
+     * 用于区分存量应用新导入模块,存量应用替换数据结构使用
      */
+    isAdd;
+    setIsAdd(isAdd) {
+        const object = {
+            isAdd,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    /**
+    * 生成宿主语言的文件路径
+    * @param name 一般不用传，用于 rename
+    */
     getEmbeddedFilePath(name = this.name) {
         return `/embedded/${this.app.name}/${this.parentKey}/${this.name}`;
     }
     /**
-     * 获取命名空间和
-     * 暂时不考虑 Module 嵌套的情况
-     */
+    * 获取命名空间和
+    * 暂时不考虑 Module 嵌套的情况
+    */
     getNamespace() {
-        return `${moduleNameSpace[this.parentKey]}.${this.name}`;
+        return `${moduleNameSpace[this.parentKey]}`;
     }
     getTsNamespace() {
-        return `${moduleNameSpace[this.parentKey]}.${this.tsName}`;
+        return `${moduleNameSpace[this.parentKey]}`;
+    }
+    getTsNamespaceAndName() {
+        return `${moduleNameSpace[this.parentKey]}.${this.name}`;
+    }
+    findEnumByName(name) {
+        return this.enums.find((enumItem) => enumItem.name === name);
     }
     /**
-     *  获取属性节点是否存在
-     */
+    *  获取属性节点是否存在
+    */
     findProperty(name, propertyType) {
         return this[propertyType].find((item) => item.name === name);
     }
@@ -960,9 +877,6 @@ __decorate([
 __decorate([
     (0, decorators_1.property)()
 ], Module.prototype, "externalDependencyMap", void 0);
-__decorate([
-    (0, decorators_1.property)('Entity')
-], Module.prototype, "entities", void 0);
 __decorate([
     (0, decorators_1.property)('Structure')
 ], Module.prototype, "structures", void 0);
@@ -984,11 +898,14 @@ __decorate([
 __decorate([
     (0, decorators_1.property)('ViewComponent')
 ], Module.prototype, "viewComponents", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "isAdd", void 0);
 Module = Module_1 = __decorate([
     (0, decorators_1.concept)('模块')
 ], Module);
 exports.Module = Module;
-classMap_1.default['Module'] = Module;
+classMap_1.default.Module = Module;
 exports.default = Module;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑