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

package/src/concepts/SwitchSetter__.ts

@@ -0,0 +1,65 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+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 BaseSetter from './BaseSetter__';
+
+/**
+ * 切换设置器
+ */
+@concept('切换设置器')
+export class SwitchSetter extends BaseSetter {
+  /** 类名 */
+  static readonly ConceptName: string = 'SwitchSetter';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseSetter', 'BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'SwitchSetter';
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<SwitchSetter>) {
+    source = Object.assign({}, SwitchSetter.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): SwitchSetter {
+    return super.from(source, parentNode, parentKey) as SwitchSetter;
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default SwitchSetter;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/SwitchStatement__.ts

@@ -31,6 +31,13 @@ import LogicItem from './LogicItem__';
 export class SwitchStatement extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'SwitchStatement';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/ThemeVariable__.ts

@@ -0,0 +1,71 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+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';
+
+/**
+ * 主题变量
+ */
+@concept('主题变量')
+export class ThemeVariable extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName: string = 'ThemeVariable';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'ThemeVariable';
+  /**
+   * 主题变量名称
+   */
+  @property({
+    objectRef: '',
+  })
+  name: string;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<ThemeVariable>) {
+    source = Object.assign({}, ThemeVariable.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): ThemeVariable {
+    return super.from(source, parentNode, parentKey) as ThemeVariable;
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default ThemeVariable;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/Theme__.ts

@@ -18,6 +18,13 @@ import BaseNode from '../common/BaseNode';
 export class Theme extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Theme';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Transactional__.ts

@@ -25,6 +25,13 @@ import BaseNode from '../common/BaseNode';
 export class Transactional extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Transactional';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/TriggerEvent__.ts

@@ -19,6 +19,13 @@ import TypeAnnotation from './TypeAnnotation__';
 export class TriggerEvent extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'TriggerEvent';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -39,10 +46,8 @@ export class TriggerEvent extends BaseNode {
    */
   @property({
     objectRef: 'TypeAnnotation',
-    isArray: true,
-    defaultValue: [],
   })
-  callBackLogic: Array<TypeAnnotation> = [];
+  callBackLogic: TypeAnnotation;
 
   /**
    * @param source 需要合并的部分参数
@@ -73,7 +78,10 @@ export class TriggerEvent extends BaseNode {
   /**
    * 设置逻辑签名
    */
-  setCallBackLogic(callBackLogic: Array<TypeAnnotation>) {
+  setCallBackLogic(callBackLogic: TypeAnnotation) {
+    callBackLogic._delete();
+    const relationOptions = { parentNode: this, parentKey: 'callBackLogic' };
+    Object.assign(callBackLogic, relationOptions);
     const object = {
       callBackLogic,
     };
@@ -82,187 +90,6 @@ export class TriggerEvent extends BaseNode {
     });
   }
 
-  getTypeAnnotationExistingNames(excludedList: Array<TypeAnnotation> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.callBackLogic as TypeAnnotation[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item.name);
-  }
-  getTypeAnnotationUniqueName(name = 'typeAnnotation1') {
-    return utils.unique(name, this.getTypeAnnotationExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入类型标注
-   * @internal
-   * @param name 类型标注名称，如果不填会自动生成一个唯一名称
-   */
-  _insertTypeAnnotationAt(name: string, index: number): TypeAnnotation;
-
-  /**
-   * 插入类型标注
-   * @internal
-   * @param typeAnnotationOptions 类型标注参数
-   */
-  _insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
-
-  /**
-   * 插入类型标注
-   * @internal
-   * @param typeAnnotation 已有的类型标注实例
-   */
-  _insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
-
-  _insertTypeAnnotationAt(options: string | Partial<TypeAnnotation> | TypeAnnotation, index: number) {
-    const typeAnnotationOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'callBackLogic' };
-    const TypeAnnotation = getConceptConstructor('TypeAnnotation');
-    let typeAnnotation: TypeAnnotation;
-    if (!options) {
-      typeAnnotation = TypeAnnotation.from(
-        {
-          ...typeAnnotationOptions,
-          name: this.getTypeAnnotationUniqueName(),
-        },
-        this,
-        'callBackLogic',
-      );
-    } else if (typeof options === 'string') {
-      typeAnnotation = TypeAnnotation.from(
-        {
-          ...typeAnnotationOptions,
-          name: options,
-        },
-        this,
-        'callBackLogic',
-      );
-    } else if (asserts.isTypeAnnotation(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      typeAnnotation = options;
-      Object.assign(typeAnnotation, relationOptions);
-    } else {
-      typeAnnotation = TypeAnnotation.from(
-        {
-          ...typeAnnotationOptions,
-          ...options,
-        },
-        this,
-        'callBackLogic',
-      );
-    }
-    this.callBackLogic.splice(index, 0, typeAnnotation);
-    return typeAnnotation;
-  }
-
-  /**
-   * 插入类型标注
-   * @param name 类型标注名称，如果不填会自动生成一个唯一名称
-   */
-  insertTypeAnnotationAt(name: string, index: number): TypeAnnotation;
-
-  /**
-   * 插入类型标注
-   * @param typeAnnotationOptions 类型标注参数
-   */
-  insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
-
-  /**
-   * 插入类型标注
-   * @param typeAnnotation 已有的类型标注实例
-   */
-  insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
-
-  insertTypeAnnotationAt(options: string | Partial<TypeAnnotation> | TypeAnnotation, index: number) {
-    const node = this._insertTypeAnnotationAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'callBackLogic',
-    });
-    return node;
-  }
-
-  /**
-   * 添加类型标注
-   * @internal
-   * @param name 类型标注名称，如果不填会自动生成一个唯一名称
-   */
-  _addTypeAnnotation(name?: string): TypeAnnotation;
-
-  /**
-   * 添加类型标注
-   * @internal
-   * @param typeAnnotationOptions 类型标注参数
-   */
-  _addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
-
-  /**
-   * 添加类型标注
-   * @internal
-   * @param typeAnnotation 已有的类型标注实例
-   */
-  _addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
-
-  _addTypeAnnotation(options?: string | Partial<TypeAnnotation> | TypeAnnotation) {
-    const index = this.callBackLogic.length;
-    return this._insertTypeAnnotationAt(options as any, index);
-  }
-
-  /**
-   * 添加类型标注
-   * @internal
-   * @param name 类型标注名称，如果不填会自动生成一个唯一名称
-   */
-  addTypeAnnotation(name?: string): TypeAnnotation;
-
-  /**
-   * 添加类型标注
-   * @param typeAnnotationOptions 类型标注参数
-   */
-  addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
-
-  /**
-   * 添加类型标注
-   * @param typeAnnotation 已有的类型标注实例
-   */
-  addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
-
-  addTypeAnnotation(options?: string | Partial<TypeAnnotation> | TypeAnnotation) {
-    const node = this._addTypeAnnotation(options as any);
-    const index = this.callBackLogic.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'callBackLogic',
-    });
-    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.callBackLogic as TypeAnnotation[]).find((item) => item.name === options);
-      if (!typeAnnotation) {
-        throw new Error('找不到类型标注 ' + options);
-      }
-    } else {
-      typeAnnotation = options;
-    }
-    return typeAnnotation.delete();
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。

package/src/concepts/TriggerLauncher__.ts

@@ -34,6 +34,13 @@ import Identifier from './Identifier__';
 export class TriggerLauncher extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'TriggerLauncher';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/TypeAnnotation__.ts

@@ -9,6 +9,7 @@ import {
   withSourceMapGenerator,
   withGenerator,
   TranslatorGenerator,
+  transfromMetadataType,
 } from '../translator';
 import { genHash } from '../generator';
 import { firstUpperCase } from '../utils/string';
@@ -118,6 +119,13 @@ import StructureProperty from './StructureProperty__';
 export class TypeAnnotation extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'TypeAnnotation';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -606,6 +614,7 @@ export class TypeAnnotation extends BaseNode {
 
   // 排过序的类型标识
   get sortedTypeKey(): string {
+    const app = this.app;
     if (this.typeKind === 'anonymousStructure') {
       // 按匿名数据结构的key排序
       return `{${[...this.properties]
@@ -615,24 +624,35 @@ export class TypeAnnotation extends BaseNode {
     } else if (this.typeKind === 'union') {
       // 按返回的每个具体项排序
       return `${this.typeArguments
-        .map((arg) => arg?.sortedTypeKey)
+        .map((arg) => transfromMetadataType(arg, app)?.sortedTypeKey)
         .sort((name1, name2) => (name1 > name2 ? 1 : -1))
-        .join(' | ')}`;
+        .join(' | ')}`
+    }
+    let { typeNamespace, typeName, typeKind } = this
+    // 统一处理元数据sortedTypeKey值，不需要再在每个调用sortedTypeKey单独处理
+    if (typeNamespace?.endsWith('.metadataTypes')) {
+      const referenceNode = this.app?.findNodeByCompleteName?.(typeNamespace + '.' + typeName);
+      const typeAn = referenceNode?.typeAnnotation
+      if (typeAn) {
+        typeKind = typeAn.typeKind;
+        typeNamespace = typeAn.typeNamespace;
+        typeName = typeAn.typeName;
+      }
     }
     const typeArr = [];
-    if (this.typeNamespace) {
-      typeArr.push(this.typeNamespace);
+    if (typeNamespace) {
+      typeArr.push(typeNamespace);
     }
-    if (this.typeName) {
-      typeArr.push(this.typeName);
+    if (typeName) {
+      typeArr.push(typeName);
     }
     const typeKey = typeArr.join('.');
-    if (this.typeKind === 'generic') {
+    if (typeKind === 'generic') {
       let code = typeKey;
       code += '<';
       if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
         // 必须按typeArguments定义的顺序，否则实参位置不对
-        code += `${(this.typeArguments || []).map((arg) => arg?.sortedTypeKey).join(', ')}`;
+        code += `${(this.typeArguments || []).map((arg) => transfromMetadataType(arg, app)?.sortedTypeKey).join(', ')}`;
       }
       code += '>';
       return code;
@@ -1136,10 +1156,7 @@ export class TypeAnnotation extends BaseNode {
   typeArgumentsPush(typeItem: TypeAnnotation) {
     if (asserts.isTypeAnnotation(typeItem)) {
       this.typeArguments.push(
-        TypeAnnotation.from(typeItem, {
-          parentNode: this,
-          parentKey: 'typeArguments',
-        }),
+        TypeAnnotation.from(typeItem, this, 'typeArguments'),
       );
     }
   }

package/src/concepts/TypeParam__.ts

@@ -28,6 +28,13 @@ import BaseNode from '../common/BaseNode';
 export class TypeParam extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'TypeParam';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/UnaryExpression__.ts

@@ -31,6 +31,13 @@ import LogicItem from './LogicItem__';
 export class UnaryExpression extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'UnaryExpression';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Unparsed__.ts

@@ -29,6 +29,13 @@ import LogicItem from './LogicItem__';
 export class Unparsed extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'Unparsed';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/UseComponent__.ts

@@ -18,6 +18,13 @@ import BaseNode from '../common/BaseNode';
 export class UseComponent extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'UseComponent';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/ValidationRule__.ts

@@ -37,6 +37,13 @@ import LogicItem from './LogicItem__';
 export class ValidationRule extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'ValidationRule';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -435,7 +442,7 @@ export class ValidationRule extends LogicItem {
           }
           // 如果找到函数而且有参数，就用参数的必填非必填
           if (validationInFunction && param) {
-            code += yield* arg.toEmbeddedTS(shiftState(state, code), param.required, false);
+            code += yield* arg.toEmbeddedTS(shiftState(state, code), !!param.required, false);
           }
           // 如果没有就默认不必填
           else {

package/src/concepts/Variable__.ts

@@ -58,6 +58,13 @@ import DefaultValue from './DefaultValue__';
 export class Variable extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Variable';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -95,7 +102,7 @@ export class Variable extends BaseNode {
   @property({
     objectRef: 'DefaultValue',
   })
-  defaultValue: DefaultValue;
+  defaultValue?: DefaultValue = null;
 
   /**
    * @param source 需要合并的部分参数