@lcap/nasl 3.3.0-alpha.3 → 3.3.0-beta.0

package/src/concepts/TypeAnnotation__.ts

@@ -1,6 +1,6 @@
 import App from './App__';
 import Structure from './Structure__';
-import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
+import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import { genHash } from '../generator';
 import { firstUpperCase } from '../utils/string';
 
@@ -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,42 +92,49 @@ 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;
 
   /**
    * 类型参数
@@ -140,7 +152,8 @@ export class TypeAnnotation extends BaseNode {
    * 是否是推断出来的
    */
   @property()
-  inferred?: boolean = undefined;
+  // @ts-ignore
+  inferred!: boolean;
 
   /**
    * 匿名数据结构属性
@@ -152,7 +165,8 @@ export class TypeAnnotation extends BaseNode {
    * 规则对象
    */
   @property()
-  ruleMap: Object = undefined;
+  // @ts-ignore
+  ruleMap!: Object;
 
   /**
    * @param source 需要合并的部分参数
@@ -162,9 +176,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 +233,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'typeArguments'
+        'typeArguments',
       );
     }
     this.typeArguments.splice(index, 0, typeAnnotation);
@@ -322,7 +333,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'returnType'
+        'returnType',
       );
     }
     this.returnType.splice(index, 0, typeAnnotation);
@@ -422,7 +433,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'properties'
+        'properties',
       );
     }
     this.properties.splice(index, 0, structureProperty);
@@ -500,7 +511,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 +522,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 +556,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 +599,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 +621,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 +692,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 +719,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 +746,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 +827,8 @@ export class TypeAnnotation extends BaseNode {
             typeName,
             typeNamespace: 'nasl.core',
           },
-          source
-        )
+          source,
+        ),
       );
     }
   }
@@ -818,8 +841,8 @@ export class TypeAnnotation extends BaseNode {
           typeName,
           typeNamespace: 'nasl.core',
         },
-        source
-      )
+        source,
+      ),
     );
   }
 
@@ -831,8 +854,8 @@ export class TypeAnnotation extends BaseNode {
           typeName,
           typeNamespace: 'nasl.collection',
         },
-        source
-      )
+        source,
+      ),
     );
   }
 
@@ -843,8 +866,8 @@ export class TypeAnnotation extends BaseNode {
           typeKind: 'typeParam',
           typeName,
         },
-        source
-      )
+        source,
+      ),
     );
   }
 
@@ -855,8 +878,8 @@ export class TypeAnnotation extends BaseNode {
           typeKind: 'anonymousStructure',
           properties,
         },
-        source
-      )
+        source,
+      ),
     );
   }
   /**
@@ -902,7 +925,7 @@ export class TypeAnnotation extends BaseNode {
   }
 
   @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  toEmbeddedTS(state?: TranslatorState): string {
     if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
       if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
         return `${this.tsCalleeNamespace}.${this.typeName}`;
@@ -927,10 +950,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}" `;
@@ -947,64 +973,24 @@ export class TypeAnnotation extends BaseNode {
     }
   }
 
-  @withSourceMap()
-  toNaturalTS(state = createCompilerState()): string {
-    if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
-      if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
-        return this.tsCalleeNamespace.startsWith('nasl.ui') ? `${this.tsCalleeNamespace}.${this.typeName}` : `${this.typeName}`;
-      }
-      return this.tsCalleeNamespace.startsWith('nasl.ui') ? `${this.tsCalleeNamespace}.${this.typeName}` : `${this.typeName}`;
-    }
-    if (this.typeKind === 'generic') {
-      let code = `${this.typeName}<`;
-      (this.typeArguments || []).forEach((arg, index) => {
-        code += arg.toNaturalTS(shiftState(state, code, { inline: true }));
-        if (index !== this.typeArguments.length - 1)
-          code += ', ';
-      });
-      code += '>';
-      return code;
-    }
-    if (this.typeKind === 'union') {
-      let code = '';
-      (this.typeArguments || []).forEach((arg, index) => {
-        code += arg.toNaturalTS(shiftState(state, code, { inline: true }));
-        if (index !== this.typeArguments.length - 1)
-          code += ' | ';
-      });
-      return code;
-    }
-    if (this.typeKind === 'anonymousStructure') {
-      let code = `{ `;
-      (this.properties || []).forEach((property, i) => {
-        code += `${property.name}: `;
-        code += `${property.typeAnnotation.toNaturalTS(shiftState(state, code, { inline: true, tabSize: state.tabSize + 1 }))}`;
-        code += i < this.properties?.length - 1 ? ', ' : ' }';
-      });
-      return code;
-    }
-    if (this.tsCalleeNamespace && this.typeName) {
-      return `${this.typeName}`;
-    }
-    if (this.typeName) {
-      return this.typeName;
-    }
-    return '__IDENTIFIER__';
-  }
-
   /**
    * 用于标准化数据结构，便于计算 anonymousStructure 的 __name
    */
   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 +1071,7 @@ export class TypeAnnotation extends BaseNode {
         TypeAnnotation.from(typeItem, {
           parentNode: this,
           parentKey: 'typeArguments',
-        })
+        }),
       );
     }
   }
@@ -1093,7 +1079,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 +1116,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 +1138,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 +1159,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';
+import { TranslatorState, withSourceMap } 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;
@@ -59,21 +59,14 @@ export class TypeParam extends BaseNode {
   toEmbeddedTS(state?: TranslatorState, prefix?: string): string {
     return this.name;
   }
-
-  @withSourceMap()
-  toNaturalTS(state = createCompilerState(), prefix?: string): string {
-    return this.name;
-  }
-
-  //= ===============================================================================
+  //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //= ===============================================================================
+  //================================================================================
 }
 
-classMap.TypeParam = TypeParam;
 export default TypeParam;
-//= ===============================================================================
+//================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//= ===============================================================================
+//================================================================================