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

package/src/concepts/TypeAnnotation__.ts

@@ -1,6 +1,6 @@
 import App from './App__';
 import Structure from './Structure__';
-import { TranslatorState, shiftState, withSourceMap } from '../translator';
+import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
 import { genHash } from '../generator';
 import { firstUpperCase } from '../utils/string';
 
@@ -79,12 +79,7 @@ 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';
 }
 
 //================================================================================
@@ -92,49 +87,42 @@ export function isUnion(typeAnnotation: TypeAnnotation): boolean {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property } 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';
-
   /**
    * 产品概念
    */
-  // @ts-ignore
-  readonly concept!: 'TypeAnnotation';
+  @property()
+  concept: 'TypeAnnotation' = 'TypeAnnotation';
 
   /**
    * 类型种类
    */
   @property()
-  // @ts-ignore
-  typeKind!: 'primitive' | 'reference' | 'generic' | 'typeParam' | 'function' | 'union' | 'anonymousStructure';
+  typeKind: 'primitive' | 'reference' | 'generic' | 'typeParam' | 'function' | 'union' | 'anonymousStructure' = undefined;
 
   /**
    * 类型命名空间
    */
   @property()
-  // @ts-ignore
-  typeNamespace!: string;
+  typeNamespace?: string = undefined;
 
   /**
    * 类型名称
    */
   @property()
-  // @ts-ignore
-  typeName!: string;
+  typeName: string = undefined;
 
   /**
    * 类型参数
@@ -152,8 +140,7 @@ export class TypeAnnotation extends BaseNode {
    * 是否是推断出来的
    */
   @property()
-  // @ts-ignore
-  inferred!: boolean;
+  inferred?: boolean = undefined;
 
   /**
    * 匿名数据结构属性
@@ -165,8 +152,7 @@ export class TypeAnnotation extends BaseNode {
    * 规则对象
    */
   @property()
-  // @ts-ignore
-  ruleMap!: Object;
+  ruleMap: Object = undefined;
 
   /**
    * @param source 需要合并的部分参数
@@ -176,6 +162,9 @@ 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;
@@ -233,7 +222,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'typeArguments',
+        'typeArguments'
       );
     }
     this.typeArguments.splice(index, 0, typeAnnotation);
@@ -333,7 +322,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'returnType',
+        'returnType'
       );
     }
     this.returnType.splice(index, 0, typeAnnotation);
@@ -433,7 +422,7 @@ export class TypeAnnotation extends BaseNode {
           ...options,
         },
         this,
-        'properties',
+        'properties'
       );
     }
     this.properties.splice(index, 0, structureProperty);
@@ -511,7 +500,7 @@ export class TypeAnnotation extends BaseNode {
   removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
 
   removeTypeAnnotationInTypeArguments(options: TypeAnnotation) {
-    let typeAnnotation: TypeAnnotation = options;
+    const typeAnnotation: TypeAnnotation = options;
     return typeAnnotation.delete();
   }
 
@@ -522,7 +511,7 @@ export class TypeAnnotation extends BaseNode {
   removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
 
   removeTypeAnnotationInReturnType(options: TypeAnnotation) {
-    let typeAnnotation: TypeAnnotation = options;
+    const typeAnnotation: TypeAnnotation = options;
     return typeAnnotation.delete();
   }
 
@@ -556,7 +545,7 @@ export class TypeAnnotation extends BaseNode {
   removeStructureProperty(structureProperty: StructureProperty): void;
 
   removeStructureProperty(options: StructureProperty) {
-    let structureProperty: StructureProperty = options;
+    const structureProperty: StructureProperty = options;
     return structureProperty.delete();
   }
 
@@ -599,7 +588,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);
@@ -621,9 +610,7 @@ 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 {
@@ -692,14 +679,10 @@ 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 {
@@ -719,13 +702,9 @@ 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 {
@@ -746,9 +725,7 @@ 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
@@ -827,8 +804,8 @@ export class TypeAnnotation extends BaseNode {
             typeName,
             typeNamespace: 'nasl.core',
           },
-          source,
-        ),
+          source
+        )
       );
     }
   }
@@ -841,8 +818,8 @@ export class TypeAnnotation extends BaseNode {
           typeName,
           typeNamespace: 'nasl.core',
         },
-        source,
-      ),
+        source
+      )
     );
   }
 
@@ -854,8 +831,8 @@ export class TypeAnnotation extends BaseNode {
           typeName,
           typeNamespace: 'nasl.collection',
         },
-        source,
-      ),
+        source
+      )
     );
   }
 
@@ -866,8 +843,8 @@ export class TypeAnnotation extends BaseNode {
           typeKind: 'typeParam',
           typeName,
         },
-        source,
-      ),
+        source
+      )
     );
   }
 
@@ -878,8 +855,8 @@ export class TypeAnnotation extends BaseNode {
           typeKind: 'anonymousStructure',
           properties,
         },
-        source,
-      ),
+        source
+      )
     );
   }
   /**
@@ -925,7 +902,7 @@ export class TypeAnnotation extends BaseNode {
   }
 
   @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState): string {
+  toEmbeddedTS(state = createCompilerState()): string {
     if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
       if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
         return `${this.tsCalleeNamespace}.${this.typeName}`;
@@ -950,13 +927,10 @@ 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}" `;
@@ -973,24 +947,64 @@ 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;
@@ -1071,7 +1085,7 @@ export class TypeAnnotation extends BaseNode {
         TypeAnnotation.from(typeItem, {
           parentNode: this,
           parentKey: 'typeArguments',
-        }),
+        })
       );
     }
   }
@@ -1079,10 +1093,7 @@ 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() {
@@ -1116,21 +1127,16 @@ 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(app: App) {
+  hasSystemType() {
+    const disableTypeNamespaces = ['nasl.ui', 'nasl.auth', 'nasl.http', 'nasl.process'];
     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));
-        }
-        if (item.typeArguments && ['generic', 'union'].includes(item.typeKind)) {
+        } else if (item.typeArguments && ['generic', 'union'].includes(item.typeKind)) {
           return item.typeArguments.some((arg) => traverseChild(arg, cb));
         }
       }
@@ -1138,14 +1144,13 @@ export class TypeAnnotation extends BaseNode {
     let result = false;
     traverseChild(this, (node: TypeAnnotation) => {
       if (node.typeNamespace?.endsWith('.structures')) {
-        const structure = app.findNodeByCompleteName(`${node.typeNamespace}.${node.typeName}`);
-        const res = !structure?.properties.some((prop: StructureProperty) => prop.typeAnnotation.hasSystemType(app));
+        const structure = this.rootNode.findNodeByCompleteName(node.typeNamespace + '.' + node.typeName);
+        const res = !structure.properties.some((prop: StructureProperty) => prop.typeAnnotation.hasSystemType());
         if (res === false) {
           result = true;
         }
         return res;
-      }
-      if (node.isSystemType()) {
+      } else if (disableTypeNamespaces.includes(node.typeNamespace)) {
         result = true;
         return false;
       }
@@ -1159,6 +1164,7 @@ export class TypeAnnotation extends BaseNode {
   //================================================================================
 }
 
+classMap.TypeAnnotation = TypeAnnotation;
 export default TypeAnnotation;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/TypeParam__.ts

@@ -1,56 +1,56 @@
-import { TranslatorState, withSourceMap } from '../translator';
+import { v4 as uuidv4 } from 'uuid';
+import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
 
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property } 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';
-
   /**
    * 产品概念
    */
-  // @ts-ignore
-  readonly concept!: 'TypeParam';
+  @property()
+  concept: 'TypeParam' = 'TypeParam';
 
   /**
    * 类型名称
    */
   @property()
-  // @ts-ignore
-  name!: string;
+  name: string = undefined;
 
   /**
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<TypeParam>) {
-    source = Object.assign({}, TypeParam.getDefaultOptions(), source);
+    // @ts-ignore
+    source = { ...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,14 +59,21 @@ 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;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================