@lcap/nasl 3.4.0-beta.6 → 3.5.0-alpha.1

package/src/concepts/StructureProperty__.ts

@@ -1,4 +1,3 @@
-import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
 import { dataTypesMap } from './basics/types';
 import {
   TranslatorState,
@@ -9,35 +8,39 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
+
+interface defaultCode {
+  code?: string;
+  executeCode?: boolean;
+}
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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 TypeAnnotation from './TypeAnnotation__';
-import DefaultValue from './DefaultValue__';
-import Structure from './Structure__';
-import Module from './Module__';
-import App from './App__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type DefaultValue from './DefaultValue__';
+import type Structure from './Structure__';
+import type Module from './Module__';
+import type App from './App__';
 
 /**
  * 数据结构属性
  */
-@className
 @concept('数据结构属性')
-// @ts-ignore
 export class StructureProperty extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'StructureProperty';
+  static readonly ConceptName: string = 'StructureProperty';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -50,21 +53,18 @@ export class StructureProperty extends BaseNode {
    * 数据结构属性名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 数据结构属性标题
    */
   @property()
-  // @ts-ignore
   label!: string;
 
   /**
    * 数据结构属性描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
@@ -73,14 +73,12 @@ export class StructureProperty extends BaseNode {
   @property({
     objectRef: 'TypeAnnotation',
   })
-  // @ts-ignore
   typeAnnotation!: TypeAnnotation;
 
   /**
    * 是否必填
    */
   @property()
-  // @ts-ignore
   required!: boolean;
 
   /**
@@ -89,14 +87,12 @@ export class StructureProperty extends BaseNode {
   @property({
     objectRef: 'DefaultValue',
   })
-  // @ts-ignore
   defaultValue!: DefaultValue;
 
   /**
    * 数据结构字段 JSON 的序列化别名
    */
   @property()
-  // @ts-ignore
   jsonName!: string;
 
   /**
@@ -330,7 +326,7 @@ export class StructureProperty extends BaseNode {
    * 默认值toJS的结果
    */
   @property()
-  defaultCode: string = undefined;
+  defaultCode: defaultCode = {};
 
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {

package/src/concepts/Structure__.ts

@@ -10,7 +10,7 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import Namespace from './Namespace__';
+import type Namespace from './Namespace__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 
 //================================================================================
@@ -18,28 +18,28 @@ import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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 TypeParam from './TypeParam__';
-import StructureProperty from './StructureProperty__';
-import Module from './Module__';
-import App from './App__';
+import type TypeParam from './TypeParam__';
+import type StructureProperty from './StructureProperty__';
+import type Module from './Module__';
+import type App from './App__';
 
 /**
  * 数据结构
  */
-@className
 @concept('数据结构')
-// @ts-ignore
 export class Structure extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'Structure';
+  static readonly ConceptName: string = 'Structure';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -52,21 +52,18 @@ export class Structure extends BaseNode {
    * 数据结构名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 数据结构描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
    * 数据结构来源
    */
   @property()
-  // @ts-ignore
   origin!: 'CallQueryComponent';
 
   /**
@@ -183,6 +180,7 @@ export class Structure extends BaseNode {
   _insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
     const typeParamOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'typeParams' };
+    const TypeParam = getConceptConstructor('TypeParam');
     let typeParam: TypeParam;
     if (!options) {
       typeParam = TypeParam.from(
@@ -202,7 +200,7 @@ export class Structure extends BaseNode {
         this,
         'typeParams',
       );
-    } else if (options instanceof TypeParam) {
+    } else if (asserts.isTypeParam(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       typeParam = options;
       Object.assign(typeParam, relationOptions);
@@ -338,6 +336,7 @@ export class Structure extends BaseNode {
   _insertPropertyAt(options: string | Partial<StructureProperty> | StructureProperty, index: number) {
     const propertyOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'properties' };
+    const StructureProperty = getConceptConstructor('StructureProperty');
     let property: StructureProperty;
     if (!options) {
       property = StructureProperty.from(
@@ -357,7 +356,7 @@ export class Structure extends BaseNode {
         this,
         'properties',
       );
-    } else if (options instanceof StructureProperty) {
+    } else if (asserts.isStructureProperty(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       property = options;
       Object.assign(property, relationOptions);

package/src/concepts/SwitchCase__.ts

@@ -14,25 +14,24 @@ import {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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 LogicItem from './LogicItem__';
 
 /**
  * 选择分支情况
  */
-@className
 @concept('选择分支情况')
-// @ts-ignore
 export class SwitchCase extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'SwitchCase';
+  static readonly ConceptName: string = 'SwitchCase';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -47,7 +46,6 @@ export class SwitchCase extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  // @ts-ignore
   test!: LogicItem;
 
   /**
@@ -105,8 +103,9 @@ export class SwitchCase extends LogicItem {
   _insertItemAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'consequent' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (options instanceof LogicItem) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);

package/src/concepts/SwitchStatement__.ts

@@ -14,26 +14,25 @@ import {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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 SwitchCase from './SwitchCase__';
 import LogicItem from './LogicItem__';
+import type SwitchCase from './SwitchCase__';
 
 /**
  * 选择分支
  */
-@className
 @concept('选择分支')
-// @ts-ignore
 export class SwitchStatement extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'SwitchStatement';
+  static readonly ConceptName: string = 'SwitchStatement';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -82,8 +81,9 @@ export class SwitchStatement extends LogicItem {
   _insertSwitchCaseAt(options: Partial<SwitchCase> | SwitchCase, index: number) {
     const switchCaseOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'cases' };
+    const SwitchCase = getConceptConstructor('SwitchCase');
     let switchCase: SwitchCase;
-    if (options instanceof SwitchCase) {
+    if (asserts.isSwitchCase(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       switchCase = options;
       Object.assign(switchCase, relationOptions);

package/src/concepts/Theme__.ts

@@ -3,24 +3,24 @@
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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';
 
 /**
  * 主题
  */
-@className
 @concept('主题')
-// @ts-ignore
 export class Theme extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'Theme';
+  static readonly ConceptName: string = 'Theme';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Transactional__.ts

@@ -3,32 +3,32 @@
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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 Logic from './Logic__';
-import Module from './Module__';
-import App from './App__';
-import Connector from './Connector__';
-import View from './View__';
-import Frontend from './Frontend__';
-import ProcessElement from './ProcessElement__';
-import Process from './Process__';
+import type Logic from './Logic__';
+import type Module from './Module__';
+import type App from './App__';
+import type Connector from './Connector__';
+import type View from './View__';
+import type Frontend from './Frontend__';
+import type ProcessElement from './ProcessElement__';
+import type Process from './Process__';
 
 /**
  * 事务
  */
-@className
 @concept('事务')
-// @ts-ignore
 export class Transactional extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'Transactional';
+  static readonly ConceptName: string = 'Transactional';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -41,21 +41,18 @@ export class Transactional extends BaseNode {
    * 事务是否生效
    */
   @property()
-  // @ts-ignore
   enabled!: boolean;
 
   /**
    * 事务的传播机制
    */
   @property()
-  // @ts-ignore
   propagation!: 'REQUIRED' | 'REQUIRES_NEW' | 'SUPPORTS' | 'NOT_SUPPORTED' | 'MANDATORY' | 'NEVER';
 
   /**
    * 事务的隔离级别
    */
   @property()
-  // @ts-ignore
   isolation!: 'DEFAULT' | 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE';
 
   /**

package/src/concepts/TriggerEvent__.ts

@@ -3,25 +3,25 @@
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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 TypeAnnotation from './TypeAnnotation__';
+import type TypeAnnotation from './TypeAnnotation__';
 
 /**
  * 触发器事件
  */
-@className
 @concept('触发器事件')
-// @ts-ignore
 export class TriggerEvent extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'TriggerEvent';
+  static readonly ConceptName: string = 'TriggerEvent';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -34,18 +34,15 @@ export class TriggerEvent extends BaseNode {
    * 触发器事件名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
-   * 类型标注列表
+   * 类型标注
    */
   @property({
     objectRef: 'TypeAnnotation',
-    isArray: true,
-    defaultValue: [],
   })
-  callBackLogic: Array<TypeAnnotation> = [];
+  callBackLogic!: TypeAnnotation;
 
   /**
    * @param source 需要合并的部分参数
@@ -85,9 +82,12 @@ 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,
     };
@@ -96,184 +96,29 @@ 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' };
-    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 (options instanceof TypeAnnotation) {
-      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;
+  removeCallBackLogic(name: string): void;
 
   /**
    * 删除类型标注
-   * @param typeAnnotation 已有的类型标注实例
+   * @param callBackLogic 已有的类型标注实例
    */
-  removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
+  removeCallBackLogic(callBackLogic: TypeAnnotation): void;
 
-  removeTypeAnnotation(options: string | TypeAnnotation) {
-    let typeAnnotation: TypeAnnotation;
+  removeCallBackLogic(options: string | TypeAnnotation) {
+    let callBackLogic: TypeAnnotation;
     if (typeof options === 'string') {
-      typeAnnotation = (this.callBackLogic as TypeAnnotation[]).find((item) => item.name === options);
-      if (!typeAnnotation) {
+      callBackLogic = this.callBackLogic;
+      if (!callBackLogic) {
         throw new Error('找不到类型标注 ' + options);
       }
     } else {
-      typeAnnotation = options;
+      callBackLogic = options;
     }
-    return typeAnnotation.delete();
+    return callBackLogic.delete();
   }
 
   __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {