@lcap/nasl 3.7.0-alpha.1 → 3.7.0-beta.1

package/src/concepts/MetadataType__.ts

@@ -12,23 +12,22 @@ import {
 } from '../translator';
 import type Namespace from './Namespace__';
 
+import Module from './Module__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import type TypeAnnotation from './TypeAnnotation__';
-import type ValidationRule from './ValidationRule__';
-import type LogicItem from './LogicItem__';
-import type Module from './Module__';
-import type App from './App__';
+import TypeAnnotation from './TypeAnnotation__';
+import ValidationRule from './ValidationRule__';
+import LogicItem from './LogicItem__';
 
 /**
  * 元数据类型
@@ -37,7 +36,11 @@ import type App from './App__';
 export class MetadataType extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'MetadataType';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['BaseNode'];
 
@@ -47,24 +50,29 @@ export class MetadataType extends BaseNode {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'MetadataType';
-
   /**
    * 名称
    */
-  @property()
-  name!: string;
+  @property({
+    objectRef: '',
+  })
+  name: string = '';
 
   /**
    * 标题
    */
-  @property()
+  @property({
+    objectRef: '',
+  })
   label: string = '元数据';
 
   /**
    * 描述
    */
-  @property()
-  description!: string;
+  @property({
+    objectRef: '',
+  })
+  description: string;
 
   /**
    * 类型
@@ -72,7 +80,7 @@ export class MetadataType extends BaseNode {
   @property({
     objectRef: 'TypeAnnotation',
   })
-  typeAnnotation!: TypeAnnotation;
+  typeAnnotation: TypeAnnotation;
 
   /**
    * 验证规则
@@ -97,22 +105,11 @@ export class MetadataType extends BaseNode {
   /**
    * 唯一标识
    */
-  @property()
+  @property({
+    objectRef: '',
+  })
   uuid: string = uuidv4().replace(/-/g, '');
 
-  /**
-   * 祖先 Module
-   */
-  get module() {
-    return this.getAncestor('Module') as Module;
-  }
-  /**
-   * 祖先 App
-   */
-  get app() {
-    return this.getAncestor('App') as App;
-  }
-
   /**
    * @param source 需要合并的部分参数
    */
@@ -126,21 +123,9 @@ export class MetadataType extends BaseNode {
     return super.from(source, parentNode, parentKey) as MetadataType;
   }
 
-  /**
-   * 从父级删除该节点
-   * @internal
-   */
-  _delete() {
-    let params: Params = null;
-    if (this.parentNode) {
-      params = (this.parentNode as any)?.__removeMetadataType?.(this);
-    }
-    return params;
-  }
-
   getValidationRuleExistingNames(excludedList: Array<ValidationRule> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.rules as ValidationRule[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.rules as ValidationRule[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getValidationRuleUniqueName(name = 'validationRule1') {
     return utils.unique(name, this.getValidationRuleExistingNames(), undefined, false);
@@ -151,23 +136,23 @@ export class MetadataType extends BaseNode {
    * @internal
    * @param name 验证规则名称，如果不填会自动生成一个唯一名称
    */
-  _insertValidationRuleInRulesAt(name: string, index: number): ValidationRule;
+  _insertValidationRuleAt(name: string, index: number): ValidationRule;
 
   /**
    * 插入验证规则
    * @internal
    * @param validationRuleOptions 验证规则参数
    */
-  _insertValidationRuleInRulesAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
+  _insertValidationRuleAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
 
   /**
    * 插入验证规则
    * @internal
    * @param validationRule 已有的验证规则实例
    */
-  _insertValidationRuleInRulesAt(validationRule: ValidationRule, index: number): ValidationRule;
+  _insertValidationRuleAt(validationRule: ValidationRule, index: number): ValidationRule;
 
-  _insertValidationRuleInRulesAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
+  _insertValidationRuleAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
     const validationRuleOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'rules' };
     const ValidationRule = getConceptConstructor('ValidationRule');
@@ -212,22 +197,22 @@ export class MetadataType extends BaseNode {
    * 插入验证规则
    * @param name 验证规则名称，如果不填会自动生成一个唯一名称
    */
-  insertValidationRuleInRulesAt(name: string, index: number): ValidationRule;
+  insertValidationRuleAt(name: string, index: number): ValidationRule;
 
   /**
    * 插入验证规则
    * @param validationRuleOptions 验证规则参数
    */
-  insertValidationRuleInRulesAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
+  insertValidationRuleAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
 
   /**
    * 插入验证规则
    * @param validationRule 已有的验证规则实例
    */
-  insertValidationRuleInRulesAt(validationRule: ValidationRule, index: number): ValidationRule;
+  insertValidationRuleAt(validationRule: ValidationRule, index: number): ValidationRule;
 
-  insertValidationRuleInRulesAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
-    const node = this._insertValidationRuleInRulesAt(options as any, index);
+  insertValidationRuleAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
+    const node = this._insertValidationRuleAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -241,25 +226,25 @@ export class MetadataType extends BaseNode {
    * @internal
    * @param name 验证规则名称，如果不填会自动生成一个唯一名称
    */
-  _addValidationRuleInRules(name?: string): ValidationRule;
+  _addValidationRule(name?: string): ValidationRule;
 
   /**
    * 添加验证规则
    * @internal
    * @param validationRuleOptions 验证规则参数
    */
-  _addValidationRuleInRules(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
+  _addValidationRule(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
 
   /**
    * 添加验证规则
    * @internal
    * @param validationRule 已有的验证规则实例
    */
-  _addValidationRuleInRules(validationRule: ValidationRule): ValidationRule;
+  _addValidationRule(validationRule: ValidationRule): ValidationRule;
 
-  _addValidationRuleInRules(options?: string | Partial<ValidationRule> | ValidationRule) {
+  _addValidationRule(options?: string | Partial<ValidationRule> | ValidationRule) {
     const index = this.rules.length;
-    return this._insertValidationRuleInRulesAt(options as any, index);
+    return this._insertValidationRuleAt(options as any, index);
   }
 
   /**
@@ -267,22 +252,22 @@ export class MetadataType extends BaseNode {
    * @internal
    * @param name 验证规则名称，如果不填会自动生成一个唯一名称
    */
-  addValidationRuleInRules(name?: string): ValidationRule;
+  addValidationRule(name?: string): ValidationRule;
 
   /**
    * 添加验证规则
    * @param validationRuleOptions 验证规则参数
    */
-  addValidationRuleInRules(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
+  addValidationRule(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
 
   /**
    * 添加验证规则
    * @param validationRule 已有的验证规则实例
    */
-  addValidationRuleInRules(validationRule: ValidationRule): ValidationRule;
+  addValidationRule(validationRule: ValidationRule): ValidationRule;
 
-  addValidationRuleInRules(options?: string | Partial<ValidationRule> | ValidationRule) {
-    const node = this._addValidationRuleInRules(options as any);
+  addValidationRule(options?: string | Partial<ValidationRule> | ValidationRule) {
+    const node = this._addValidationRule(options as any);
     const index = this.rules.indexOf(node);
     node.create({
       index,
@@ -297,16 +282,16 @@ export class MetadataType extends BaseNode {
    * @internal
    * @param logicItemOptions 逻辑项参数
    */
-  _insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+  _insertItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
 
   /**
    * 插入逻辑项
    * @internal
    * @param logicItem 已有的逻辑项实例
    */
-  _insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+  _insertItemAt(logicItem: LogicItem, index: number): LogicItem;
 
-  _insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+  _insertItemAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'playground' };
     const LogicItem = getConceptConstructor('LogicItem');
@@ -333,16 +318,16 @@ export class MetadataType extends BaseNode {
    * 插入逻辑项
    * @param logicItemOptions 逻辑项参数
    */
-  insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+  insertItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
 
   /**
    * 插入逻辑项
    * @param logicItem 已有的逻辑项实例
    */
-  insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+  insertItemAt(logicItem: LogicItem, index: number): LogicItem;
 
-  insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
-    const node = this._insertItemInPlaygroundAt(options as any, index);
+  insertItemAt(options: Partial<LogicItem> | LogicItem, index: number) {
+    const node = this._insertItemAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -356,34 +341,34 @@ export class MetadataType extends BaseNode {
    * @internal
    * @param logicItemOptions 逻辑项参数
    */
-  _addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+  _addItem(logicItemOptions: Partial<LogicItem>): LogicItem;
 
   /**
    * 添加逻辑项
    * @internal
    * @param logicItem 已有的逻辑项实例
    */
-  _addItemInPlayground(logicItem: LogicItem): LogicItem;
+  _addItem(logicItem: LogicItem): LogicItem;
 
-  _addItemInPlayground(options?: Partial<LogicItem> | LogicItem) {
+  _addItem(options?: Partial<LogicItem> | LogicItem) {
     const index = this.playground.length;
-    return this._insertItemInPlaygroundAt(options as any, index);
+    return this._insertItemAt(options as any, index);
   }
 
   /**
    * 添加逻辑项
    * @param logicItemOptions 逻辑项参数
    */
-  addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+  addItem(logicItemOptions: Partial<LogicItem>): LogicItem;
 
   /**
    * 添加逻辑项
    * @param logicItem 已有的逻辑项实例
    */
-  addItemInPlayground(logicItem: LogicItem): LogicItem;
+  addItem(logicItem: LogicItem): LogicItem;
 
-  addItemInPlayground(options?: Partial<LogicItem> | LogicItem) {
-    const node = this._addItemInPlayground(options as any);
+  addItem(options?: Partial<LogicItem> | LogicItem) {
+    const node = this._addItem(options as any);
     const index = this.playground.indexOf(node);
     node.create({
       index,
@@ -393,75 +378,19 @@ export class MetadataType extends BaseNode {
     return node;
   }
 
-  /**
-   * 删除类型标注
-   * @param name 类型标注名称
-   */
-  removeTypeAnnotation(name: string): void;
-
-  /**
-   * 删除类型标注
-   * @param typeAnnotation 已有的类型标注实例
-   */
-  removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
-
-  removeTypeAnnotation(options: string | TypeAnnotation) {
-    let typeAnnotation: TypeAnnotation;
-    if (typeof options === 'string') {
-      typeAnnotation = this.typeAnnotation;
-      if (!typeAnnotation) {
-        throw new Error('找不到类型标注 ' + options);
-      }
-    } else {
-      typeAnnotation = options;
-    }
-    return typeAnnotation.delete();
-  }
-
-  __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
-    const parentKey = typeAnnotation.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: typeAnnotation,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = typeAnnotation.__v_raw || typeAnnotation;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除验证规则
    * @param name 验证规则名称
    */
-  removeValidationRuleInRules(name: string): void;
+  removeValidationRule(name: string): void;
 
   /**
    * 删除验证规则
    * @param validationRule 已有的验证规则实例
    */
-  removeValidationRuleInRules(validationRule: ValidationRule): void;
+  removeValidationRule(validationRule: ValidationRule): void;
 
-  removeValidationRuleInRules(options: string | ValidationRule) {
+  removeValidationRule(options: string | ValidationRule) {
     let validationRule: ValidationRule;
     if (typeof options === 'string') {
       validationRule = (this.rules as ValidationRule[]).find((item) => item.name === options);
@@ -478,48 +407,24 @@ export class MetadataType extends BaseNode {
    * 删除逻辑项
    * @param logicItem 已有的逻辑项实例
    */
-  removeItemInPlayground(logicItem: LogicItem): void;
+  removeItem(logicItem: LogicItem): void;
 
-  removeItemInPlayground(options: LogicItem) {
+  removeItem(options: LogicItem) {
     let logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
-  __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
+  /**
+   * 祖先 Module
+   */
+  get module() {
+    return this.getAncestor('Module') as Module;
+  }
+
   /**
    * 是否可编辑
    *

package/src/concepts/MicroApp__.ts

@@ -3,7 +3,7 @@
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
@@ -18,7 +18,11 @@ import BaseNode from '../common/BaseNode';
 export class MicroApp extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'MicroApp';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['BaseNode'];
 
@@ -28,48 +32,61 @@ export class MicroApp extends BaseNode {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'MicroApp';
-
   /**
    * 微前端框架
    */
-  @property()
-  framework!: 'qiankun' | 'icestark';
+  @property({
+    objectRef: '',
+  })
+  framework: 'qiankun' | 'icestark';
 
   /**
    * 微应用名称
    */
-  @property()
-  name!: string;
+  @property({
+    objectRef: '',
+  })
+  name: string = '';
 
   /**
    * 页面路径前缀
    */
-  @property()
-  routePrefix!: string;
+  @property({
+    objectRef: '',
+  })
+  routePrefix: string;
 
   /**
    * 接口和静态资源前缀
    */
-  @property()
-  proxyPrefix!: string;
+  @property({
+    objectRef: '',
+  })
+  proxyPrefix: string;
 
   /**
    * 登录页面地址
    */
-  @property()
-  loginUrl!: string;
+  @property({
+    objectRef: '',
+  })
+  loginUrl: string;
 
   /**
    * 无权限页面地址
    */
-  @property()
-  noAuthUrl!: string;
+  @property({
+    objectRef: '',
+  })
+  noAuthUrl: string;
 
   /**
    * 404页面地址
    */
-  @property()
-  notFoundUrl!: string;
+  @property({
+    objectRef: '',
+  })
+  notFoundUrl: string;
 
   /**
    * @param source 需要合并的部分参数
@@ -84,18 +101,6 @@ export class MicroApp extends BaseNode {
     return super.from(source, parentNode, parentKey) as MicroApp;
   }
 
-  /**
-   * 从父级删除该节点
-   * @internal
-   */
-  _delete() {
-    let params: Params = null;
-    if (this.parentNode) {
-      params = (this.parentNode as any)?.__removeMicroApp?.(this);
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。