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

package/src/concepts/TypeAnnotation__.ts

@@ -79,7 +79,12 @@ export const GENERIC_DESC: Record<string, string> = {
  * @returns
  */
 export function isUnion(typeAnnotation: TypeAnnotation): boolean {
-  return typeAnnotation && typeAnnotation.typeKind === 'union' && typeAnnotation.typeNamespace === 'nasl.core' && typeAnnotation.typeName === 'Union';
+  return (
+    typeAnnotation &&
+    typeAnnotation.typeKind === 'union' &&
+    typeAnnotation.typeNamespace === 'nasl.core' &&
+    typeAnnotation.typeName === 'Union'
+  );
 }
 
 //================================================================================
@@ -87,72 +92,90 @@ export function isUnion(typeAnnotation: TypeAnnotation): boolean {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property } from '../decorators';
+import { concept, excludedInJSON, property, className } from '../decorators';
 
 import * as utils from '../utils';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import classMap from '../common/classMap';
 import StructureProperty from './StructureProperty__';
 
 /**
  * 类型标注
  */
+@className
 @concept('类型标注')
+// @ts-ignore
 export class TypeAnnotation extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName = 'TypeAnnotation';
+
   /**
    * 产品概念
    */
-  @property()
-  concept: 'TypeAnnotation' = 'TypeAnnotation';
+  // @ts-ignore
+  readonly concept!: 'TypeAnnotation';
 
   /**
    * 类型种类
    */
   @property()
-  typeKind: 'primitive' | 'reference' | 'generic' | 'typeParam' | 'function' | 'union' | 'anonymousStructure' = undefined;
+  // @ts-ignore
+  typeKind!: 'primitive' | 'reference' | 'generic' | 'typeParam' | 'function' | 'union' | 'anonymousStructure';
 
   /**
    * 类型命名空间
    */
   @property()
-  typeNamespace?: string = undefined;
+  // @ts-ignore
+  typeNamespace!: string;
 
   /**
    * 类型名称
    */
   @property()
-  typeName: string = undefined;
+  // @ts-ignore
+  typeName!: string;
 
   /**
    * 类型参数
    */
-  @property('TypeAnnotation')
+  @property({
+    objectRef: 'TypeAnnotation',
+    isArray: true,
+  })
   typeArguments?: Array<TypeAnnotation> = null;
 
   /**
    * 返回类型
    */
-  @property('TypeAnnotation')
+  @property({
+    objectRef: 'TypeAnnotation',
+    isArray: true,
+  })
   returnType?: Array<TypeAnnotation> = null;
 
   /**
    * 是否是推断出来的
    */
   @property()
-  inferred?: boolean = undefined;
+  // @ts-ignore
+  inferred!: boolean;
 
   /**
    * 匿名数据结构属性
    */
-  @property('StructureProperty')
+  @property({
+    objectRef: 'StructureProperty',
+    isArray: true,
+  })
   properties?: Array<StructureProperty> = null;
 
   /**
    * 规则对象
    */
   @property()
-  ruleMap: Object = undefined;
+  // @ts-ignore
+  ruleMap!: Object;
 
   /**
    * @param source 需要合并的部分参数
@@ -162,9 +185,6 @@ export class TypeAnnotation extends BaseNode {
     super(source);
     super.subConstructor(source);
   }
-  getClassName() {
-    return 'TypeAnnotation';
-  }
 
   static from(source: any, parentNode?: any, parentKey?: string): TypeAnnotation {
     return super.from(source, parentNode, parentKey) as TypeAnnotation;
@@ -222,7 +242,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'typeArguments'
+        'typeArguments',
       );
     }
     this.typeArguments.splice(index, 0, typeAnnotation);
@@ -322,7 +342,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'returnType'
+        'returnType',
       );
     }
     this.returnType.splice(index, 0, typeAnnotation);
@@ -422,7 +442,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'properties'
+        'properties',
       );
     }
     this.properties.splice(index, 0, structureProperty);
@@ -500,7 +520,7 @@ export class TypeAnnotation extends BaseNode {
   removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
 
   removeTypeAnnotationInTypeArguments(options: TypeAnnotation) {
-    const typeAnnotation: TypeAnnotation = options;
+    let typeAnnotation: TypeAnnotation = options;
     return typeAnnotation.delete();
   }
 
@@ -511,7 +531,7 @@ export class TypeAnnotation extends BaseNode {
   removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
 
   removeTypeAnnotationInReturnType(options: TypeAnnotation) {
-    const typeAnnotation: TypeAnnotation = options;
+    let typeAnnotation: TypeAnnotation = options;
     return typeAnnotation.delete();
   }
 
@@ -545,7 +565,7 @@ export class TypeAnnotation extends BaseNode {
   removeStructureProperty(structureProperty: StructureProperty): void;
 
   removeStructureProperty(options: StructureProperty) {
-    const structureProperty: StructureProperty = options;
+    let structureProperty: StructureProperty = options;
     return structureProperty.delete();
   }
 
@@ -588,7 +608,7 @@ export class TypeAnnotation extends BaseNode {
     callback: (arg: TypeAnnotation) => void,
     enter: (arg: TypeAnnotation) => void,
     leave: (arg: TypeAnnotation) => void,
-    onJoin: (arg: TypeAnnotation, arg2: TypeAnnotation) => void
+    onJoin: (arg: TypeAnnotation, arg2: TypeAnnotation) => void,
   ) {
     enter(this);
     callback(this);
@@ -610,7 +630,9 @@ export class TypeAnnotation extends BaseNode {
     } else if (this.typeKind === 'generic') {
       return `${this.typeNamespace}.${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeKey)}>`;
     } else if (this.typeKind === 'anonymousStructure') {
-      return `{ ${this.properties.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.typeKey : '未知'}`).join(', ')} }`;
+      return `{ ${this.properties
+        .map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.typeKey : '未知'}`)
+        .join(', ')} }`;
     } else if (this.typeKind === 'union') {
       return `${this.typeArguments.map((arg) => arg.typeKey).join(' | ')}`;
     } else {
@@ -679,10 +701,14 @@ export class TypeAnnotation extends BaseNode {
       return typeTitle;
     } else if (this.typeKind === 'generic') {
       if (this.typeArguments && this.typeArguments.length)
-        return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.headTitle || arg.name || 'T').join(', ')}>`;
+        return `${this.typeName}<${(this.typeArguments || [])
+          .map((arg) => arg.headTitle || arg.name || 'T')
+          .join(', ')}>`;
       else return this.typeName;
     } else if (this.typeKind === 'anonymousStructure') {
-      return `{ ${this.properties?.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation.headTitle}`).join(', ')} }`;
+      return `{ ${this.properties
+        ?.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation.headTitle}`)
+        .join(', ')} }`;
     } else if (this.typeKind === 'union') {
       return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' 或 ')}`;
     } else {
@@ -702,9 +728,13 @@ export class TypeAnnotation extends BaseNode {
     } else if (this.typeKind === 'reference') {
       return this.typeName;
     } else if (this.typeKind === 'generic') {
-      return `${this.typeName}<${!this.typeArguments.length ? 'T' : this.typeArguments.map((arg) => arg.typeTitle || arg.name || 'T').join(', ')}>`;
+      return `${this.typeName}<${
+        !this.typeArguments.length ? 'T' : this.typeArguments.map((arg) => arg.typeTitle || arg.name || 'T').join(', ')
+      }>`;
     } else if (this.typeKind === 'anonymousStructure') {
-      return `{ ${this.properties?.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`).join(', ')} }`;
+      return `{ ${this.properties
+        ?.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`)
+        .join(', ')} }`;
     } else if (this.typeKind === 'union') {
       return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' 或 ')}`;
     } else {
@@ -725,7 +755,9 @@ export class TypeAnnotation extends BaseNode {
       return this.typeName;
     } else if (this.typeKind === 'generic') {
       return `${this.typeName}<${
-        !this.typeArguments.length ? 'T' : this.typeArguments.map((arg) => arg.typeInlineTitle || arg.name || 'T').join(', ')
+        !this.typeArguments.length
+          ? 'T'
+          : this.typeArguments.map((arg) => arg.typeInlineTitle || arg.name || 'T').join(', ')
       }>`;
     } else if (this.typeKind === 'anonymousStructure') {
       return `{ ${this.properties
@@ -804,8 +836,8 @@ export class TypeAnnotation extends BaseNode {
             typeName,
             typeNamespace: 'nasl.core',
           },
-          source
-        )
+          source,
+        ),
       );
     }
   }
@@ -818,8 +850,8 @@ export class TypeAnnotation extends BaseNode {
           typeName,
           typeNamespace: 'nasl.core',
         },
-        source
-      )
+        source,
+      ),
     );
   }
 
@@ -831,8 +863,8 @@ export class TypeAnnotation extends BaseNode {
           typeName,
           typeNamespace: 'nasl.collection',
         },
-        source
-      )
+        source,
+      ),
     );
   }
 
@@ -843,8 +875,8 @@ export class TypeAnnotation extends BaseNode {
           typeKind: 'typeParam',
           typeName,
         },
-        source
-      )
+        source,
+      ),
     );
   }
 
@@ -855,8 +887,8 @@ export class TypeAnnotation extends BaseNode {
           typeKind: 'anonymousStructure',
           properties,
         },
-        source
-      )
+        source,
+      ),
     );
   }
   /**
@@ -927,10 +959,13 @@ export class TypeAnnotation extends BaseNode {
       let code = `{ `;
       (this.properties || []).forEach((property, i) => {
         code += `${property.name}: `;
-        code += `${property.typeAnnotation
-          ? property.typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 }))
-          : '`未知`'
-          }`;
+        code += `${
+          property.typeAnnotation
+            ? property.typeAnnotation.toEmbeddedTS(
+                shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 }),
+              )
+            : '`未知`'
+        }`;
         code += ', ';
       });
       code += `__name: "AStructure_${this.hash}" `;
@@ -997,14 +1032,19 @@ export class TypeAnnotation extends BaseNode {
    */
   get anonymousStructureTypeDesc(): string {
     if (this.typeKind === 'generic') {
-      return `${this.typeName}<${this.typeArguments.map((arg) => arg.anonymousStructureTypeDesc || arg.name || 'T').join(', ')}>`;
+      return `${this.typeName}<${this.typeArguments
+        .map((arg) => arg.anonymousStructureTypeDesc || arg.name || 'T')
+        .join(', ')}>`;
     } else if (this.typeKind === 'anonymousStructure') {
       return `{ ${[...this.properties]
         .sort(({ name: aName }, { name: bName }) => {
           if (aName > bName) return 1;
           return aName < bName ? -1 : 0;
         })
-        .map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.anonymousStructureTypeDesc : '未知'}`)
+        .map(
+          ({ name, typeAnnotation }) =>
+            `${name}: ${typeAnnotation ? typeAnnotation.anonymousStructureTypeDesc : '未知'}`,
+        )
         .join(', ')} }`;
     } else {
       return this.typeName;
@@ -1085,7 +1125,7 @@ export class TypeAnnotation extends BaseNode {
         TypeAnnotation.from(typeItem, {
           parentNode: this,
           parentKey: 'typeArguments',
-        })
+        }),
       );
     }
   }
@@ -1093,7 +1133,10 @@ export class TypeAnnotation extends BaseNode {
   // 是否是复合类型 List|Map|entities|structures
   isComplexType() {
     const namespaceType = this.typeNamespace?.split('.').pop();
-    return ['Map', 'List'].includes(this.typeName) || (this.typeKind === 'reference' && ['entities', 'structures'].includes(namespaceType));
+    return (
+      ['Map', 'List'].includes(this.typeName) ||
+      (this.typeKind === 'reference' && ['entities', 'structures'].includes(namespaceType))
+    );
   }
   /*  类型签名 */
   get sign() {
@@ -1127,16 +1170,21 @@ export class TypeAnnotation extends BaseNode {
     return JSON.stringify(typeAnnotation1) === JSON.stringify(typeAnnotation2);
   }
 
+  // 是否是系统类型
+  isSystemType() {
+    return ['nasl.ui', 'nasl.auth', 'nasl.http', 'nasl.process'].includes(this.typeNamespace);
+  }
+
   // 是否包含系统类型
-  hasSystemType() {
-    const disableTypeNamespaces = ['nasl.ui', 'nasl.auth', 'nasl.http', 'nasl.process'];
+  hasSystemType(app: App) {
     const traverseChild = (item: TypeAnnotation, cb: (arg: TypeAnnotation) => boolean | void): boolean => {
       const res = cb(item);
       if (res === false) return true;
       if (item && item.concept === 'TypeAnnotation') {
         if (item.typeKind === 'anonymousStructure') {
           return item.properties.some((prop) => traverseChild(prop.typeAnnotation, cb));
-        } else if (item.typeArguments && ['generic', 'union'].includes(item.typeKind)) {
+        }
+        if (item.typeArguments && ['generic', 'union'].includes(item.typeKind)) {
           return item.typeArguments.some((arg) => traverseChild(arg, cb));
         }
       }
@@ -1144,13 +1192,14 @@ export class TypeAnnotation extends BaseNode {
     let result = false;
     traverseChild(this, (node: TypeAnnotation) => {
       if (node.typeNamespace?.endsWith('.structures')) {
-        const structure = this.rootNode.findNodeByCompleteName(node.typeNamespace + '.' + node.typeName);
-        const res = !structure.properties.some((prop: StructureProperty) => prop.typeAnnotation.hasSystemType());
+        const structure = app.findNodeByCompleteName(`${node.typeNamespace}.${node.typeName}`);
+        const res = !structure?.properties.some((prop: StructureProperty) => prop.typeAnnotation.hasSystemType(app));
         if (res === false) {
           result = true;
         }
         return res;
-      } else if (disableTypeNamespaces.includes(node.typeNamespace)) {
+      }
+      if (node.isSystemType()) {
         result = true;
         return false;
       }
@@ -1164,7 +1213,6 @@ export class TypeAnnotation extends BaseNode {
   //================================================================================
 }
 
-classMap.TypeAnnotation = TypeAnnotation;
 export default TypeAnnotation;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/TypeParam__.ts

@@ -1,56 +1,56 @@
-import { v4 as uuidv4 } from 'uuid';
 import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
 
-//= ===============================================================================
+//================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//= ===============================================================================
+//================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property } from '../decorators';
+import { concept, excludedInJSON, property, className } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import classMap from '../common/classMap';
 
 /**
  * 类型参数
  */
+@className
 @concept('类型参数')
+// @ts-ignore
 export class TypeParam extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName = 'TypeParam';
+
   /**
    * 产品概念
    */
-  @property()
-  concept: 'TypeParam' = 'TypeParam';
+  // @ts-ignore
+  readonly concept!: 'TypeParam';
 
   /**
    * 类型名称
    */
   @property()
-  name: string = undefined;
+  // @ts-ignore
+  name!: string;
 
   /**
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<TypeParam>) {
-    // @ts-ignore
-    source = { ...TypeParam.getDefaultOptions(), ...source };
+    source = Object.assign({}, TypeParam.getDefaultOptions(), source);
     super(source);
     super.subConstructor(source);
   }
 
-  getClassName() {
-    return 'TypeParam';
-  }
-
   static from(source: any, parentNode?: any, parentKey?: string): TypeParam {
     return super.from(source, parentNode, parentKey) as TypeParam;
   }
 
-  //= ===============================================================================
+  //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
-  //= ===============================================================================
+  //================================================================================
 
   // 使用什么组件
   useComponent: any = undefined;
@@ -68,12 +68,11 @@ export class TypeParam extends BaseNode {
   //= ===============================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //= ===============================================================================
+  //================================================================================
 }
 
-classMap.TypeParam = TypeParam;
 export default TypeParam;
-//= ===============================================================================
+//================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//= ===============================================================================
+//================================================================================

package/src/concepts/UnaryExpression__.ts

@@ -1,56 +1,59 @@
-import { v4 as uuidv4 } from 'uuid';
 import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 
-//= ===============================================================================
+//================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//= ===============================================================================
+//================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property } from '../decorators';
+import { concept, excludedInJSON, property, className } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
 
 /**
  * 一元表达式
  */
+@className
 @concept('一元表达式')
+// @ts-ignore
 export class UnaryExpression extends LogicItem {
+  /** 类名 */
+  static readonly ConceptName = 'UnaryExpression';
+
   /**
    * 产品概念
    */
-  @property()
-  concept: 'UnaryExpression' = 'UnaryExpression';
+  // @ts-ignore
+  readonly concept!: 'UnaryExpression';
 
   /**
    * 参数
    */
-  @property('LogicItem')
-  argument: LogicItem = undefined;
+  @property({
+    objectRef: 'LogicItem',
+  })
+  // @ts-ignore
+  argument!: LogicItem;
 
   /**
    * 运算符
    */
   @property()
-  operator: '!' | 'isNull' = undefined;
+  // @ts-ignore
+  operator!: '!' | 'isNull';
 
   /**
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<UnaryExpression>) {
-    // @ts-ignore
-    source = { ...UnaryExpression.getDefaultOptions(), ...source };
+    source = Object.assign({}, UnaryExpression.getDefaultOptions(), source);
     super(source);
     super.subConstructor(source);
   }
 
-  getClassName() {
-    return 'UnaryExpression';
-  }
-
   static from(source: any, parentNode?: any, parentKey?: string): UnaryExpression {
     return super.from(source, parentNode, parentKey) as UnaryExpression;
   }
@@ -87,7 +90,7 @@ export class UnaryExpression extends LogicItem {
     if (typeof options === 'string') {
       argument = this.argument;
       if (!argument) {
-        throw new Error(`找不到逻辑项 ${options}`);
+        throw new Error('找不到逻辑项 ' + options);
       }
     } else {
       argument = options;
@@ -96,7 +99,7 @@ export class UnaryExpression extends LogicItem {
   }
 
   __removeLogicItem(logicItem: LogicItem) {
-    const { parentKey } = logicItem;
+    const parentKey = logicItem.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -118,10 +121,10 @@ export class UnaryExpression extends LogicItem {
     return params;
   }
 
-  //= ===============================================================================
+  //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
-  //= ===============================================================================
+  //================================================================================
 
   toVue(options?: ElementToVueOptions) {
     if (this.operator === 'isNull') {
@@ -193,12 +196,11 @@ export class UnaryExpression extends LogicItem {
   //= ===============================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //= ===============================================================================
+  //================================================================================
 }
 
-classMap.UnaryExpression = UnaryExpression;
 export default UnaryExpression;
-//= ===============================================================================
+//================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//= ===============================================================================
+//================================================================================