@lcap/nasl 3.3.3-beta.5 → 3.3.3-beta.7

package/src/concepts/TypeAnnotation__.ts

@@ -1,6 +1,15 @@
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
 import App from './App__';
 import Structure from './Structure__';
-import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { genHash } from '../generator';
 import { firstUpperCase } from '../utils/string';
 
@@ -547,9 +556,12 @@ export class TypeAnnotation extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -586,9 +598,12 @@ export class TypeAnnotation extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -939,49 +954,50 @@ export class TypeAnnotation extends BaseNode {
     return JSON.stringify(this);
   }
 
-  @withSourceMap()
-  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}`;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    if (self.typeKind === 'primitive' || self.typeKind === 'reference') {
+      if (self.typeKind === 'reference' && self.typeNamespace && self.typeNamespace.endsWith('enums')) {
+        return `${self.tsCalleeNamespace}.${self.typeName}`;
       }
-      return `${this.tsCalleeNamespace}.${this.typeName}`;
-    } else if (this.typeKind === 'generic') {
-      let code = `${this.tsCalleeNamespace}.${this.typeName}<`;
-      (this.typeArguments || []).forEach((arg, index) => {
-        code += arg?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        if (index !== this.typeArguments.length - 1) code += ', ';
+      return `${self.tsCalleeNamespace}.${self.typeName}`;
+    } else if (self.typeKind === 'generic') {
+      let code = `${self.tsCalleeNamespace}.${self.typeName}<`;
+      yield* wrapForEach(self.typeArguments || [], function* warpForEachGenerator(arg, index) {
+        code += yield* arg?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? utils.returnOrigin('');
+        if (index !== self.typeArguments.length - 1) code += ', ';
       });
       code += '>';
       return code;
-    } else if (this.typeKind === 'union') {
+    } else if (self.typeKind === 'union') {
       let code = '';
-      (this.typeArguments || []).forEach((arg, index) => {
-        code += arg?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        if (index !== this.typeArguments.length - 1) code += ' | ';
+      yield* wrapForEach(self.typeArguments || [], function* warpForEachGenerator(arg, index) {
+        code += yield* arg?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? utils.returnOrigin('');
+        if (index !== self.typeArguments.length - 1) code += ' | ';
       });
       return code;
-    } else if (this.typeKind === 'anonymousStructure') {
+    } else if (self.typeKind === 'anonymousStructure') {
       let code = `{ `;
-      (this.properties || []).forEach((property, i) => {
+      yield* wrapForEach(self.properties || [], function* warpForEachGenerator(property, i) {
         code += `${property.name}: `;
         code += `${
           property.typeAnnotation
-            ? property.typeAnnotation?.toEmbeddedTS(
+            ? yield* property.typeAnnotation.toEmbeddedTS(
                 shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 }),
               )
             : '`未知`'
         }`;
         code += ', ';
       });
-      code += `__name: "AStructure_${this.hash}" `;
+      code += `__name: "AStructure_${self.hash}" `;
       code += ' }';
       return code;
     } else {
-      if (this.tsCalleeNamespace && this.typeName) {
-        return `${this.tsCalleeNamespace}.${this.typeName}`;
-      } else if (this.typeName) {
-        return this.typeName;
+      if (self.tsCalleeNamespace && self.typeName) {
+        return `${self.tsCalleeNamespace}.${self.typeName}`;
+      } else if (self.typeName) {
+        return self.typeName;
       } else {
         return '__IDENTIFIER__';
       }

package/src/concepts/TypeParam__.ts

@@ -1,4 +1,12 @@
-import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -56,9 +64,10 @@ export class TypeParam extends BaseNode {
   // 使用什么组件
   useComponent: any = undefined;
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, prefix?: string): string {
-    return this.name;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), prefix?: string): TranslatorGenerator {
+    const self = this;
+    return self.name;
   }
 
   @withSourceMap()

package/src/concepts/UnaryExpression__.ts

@@ -1,4 +1,13 @@
-import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
@@ -117,9 +126,12 @@ export class UnaryExpression extends LogicItem {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -159,21 +171,25 @@ export class UnaryExpression extends LogicItem {
     return `!(${this.argument.toBrief()})`;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    if (this.operator === 'isNull') {
-      const fnName = this.operator.toUpperCase();
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    if (self.operator === 'isNull') {
+      const fnName = self.operator.toUpperCase();
       let code = '';
       code += `nasl.langUtil.${fnName}(`;
-      code += this.argument?.toEmbeddedTS ? this.argument.toEmbeddedTS(shiftState(state, code)) : '__IDENTIFIER__';
+      code += self.argument?.toEmbeddedTS
+        ? yield* self.argument.toEmbeddedTS(shiftState(state, code))
+        : '__IDENTIFIER__';
       code += ')';
       return code;
     }
-
-    if (this.operator === '!') {
+    if (self.operator === '!') {
       let code = '';
       code += 'nasl.langUtil.NOT(';
-      code += this.argument?.toEmbeddedTS ? this.argument.toEmbeddedTS(shiftState(state, code)) : '__IDENTIFIER__';
+      code += self.argument?.toEmbeddedTS
+        ? yield* self.argument.toEmbeddedTS(shiftState(state, code))
+        : '__IDENTIFIER__';
       code += ')';
       return code;
     }

package/src/concepts/Unparsed__.ts

@@ -1,4 +1,11 @@
-import { withSourceMap } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  withSourceMap,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+  createCompilerState,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -82,8 +89,8 @@ export class Unparsed extends LogicItem {
     return this.code || '';
   }
 
-  @withSourceMap()
-  toEmbeddedTS(): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     return 'nasl.core.universalVariable';
   }
 

package/src/concepts/ValidationRule__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import Function from './Function__';
 import { ElementToVueOptions } from './ViewElement__';
 import { getValidationInFunction } from '../server/getFunctions';
@@ -317,9 +327,12 @@ export class ValidationRule extends LogicItem {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -470,50 +483,44 @@ export class ValidationRule extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-
-    const { calleeName, target, calleeKey, arguments: args, errorMessage, view } = this;
-
+    const { calleeName, target, calleeKey, arguments: args, errorMessage, view } = self;
     if (calleeName) {
       // 调用逻辑时绑定的验证器
-      if (this?.parentNode?.parentKey !== 'metadataTypes' && (this.getAncestor('CallLogic') || !view)) {
-        code += target.toEmbeddedTS(shiftState(state, code));
+      if (self?.parentNode?.parentKey !== 'metadataTypes' && (self.getAncestor('CallLogic') || !view)) {
+        code += yield* target.toEmbeddedTS(shiftState(state, code));
         code += ';\n';
       }
-
       if (args.length > 0) {
         const validationInFunction = getValidationInFunction(calleeName);
         code += calleeKey;
         code += '(';
-        args.forEach((arg, index) => {
+        yield* wrapForEach(args, function* warpForEachGenerator(arg, index) {
           const param = validationInFunction?.params?.[index];
-
           // 当前参数缺失 keyword，且原始形参中有名称，则补充参数
           if (!arg.keyword && param.name) {
             arg.keyword = param.name;
           }
-
           // 如果找到函数而且有参数，就用参数的必填非必填
           if (validationInFunction && param) {
-            code += arg.toEmbeddedTS(shiftState(state, code), param.required, false);
+            code += yield* arg.toEmbeddedTS(shiftState(state, code), param.required, false);
           }
           // 如果没有就默认不必填
           else {
-            code += arg.toEmbeddedTS(shiftState(state, code), false, false);
+            code += yield* arg.toEmbeddedTS(shiftState(state, code), false, false);
           }
-
           if (index !== args.length - 1) {
             code += ', ';
           }
         });
         code += ');';
       }
-
       if (errorMessage) {
         code += 'nasl.validation.errorMessage(';
-        code += errorMessage.toEmbeddedTS(shiftState(state, code));
+        code += yield* errorMessage.toEmbeddedTS(shiftState(state, code));
         code += ')';
       }
     } else {

package/src/concepts/Variable__.ts

@@ -1,5 +1,15 @@
+import type { EmbeddedTSFileGenerator } from '../utils';
 import { dataTypesMap } from './basics/types';
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import EntityProperty from './EntityProperty__';
 import StructureProperty from './StructureProperty__';
@@ -251,9 +261,12 @@ export class Variable extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -331,18 +344,19 @@ export class Variable extends BaseNode {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    let code = this.name;
-    if (this.typeAnnotation) {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = self.name;
+    if (self.typeAnnotation) {
       code += ': ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      code += yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code));
       // toTS暂时只需要翻译引用数据类型的，因为值都是字符串
       // 就不在这里赋值了，这里单纯就为了快速查找
       // 并且屏蔽了一些异常的错误
-      if (this.typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
-        if (this.isEnum()) {
-          code += `= ${this.typeAnnotation.typeKey}['${this.defaultValue}']`;
+      if (self.typeAnnotation?.typeKind !== 'primitive' && self.defaultValue) {
+        if (self.isEnum()) {
+          code += `= ${self.typeAnnotation.typeKey}['${self.defaultValue}']`;
         }
       }
     }
@@ -395,12 +409,12 @@ export class Variable extends BaseNode {
     return `/embedded/${this.app.name}/frontends/${this.parentNode.name}/variables/${name}.ts`;
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getNamespace()} {\n`;
     code += `${indent(1)}export let `;
     const state = createCompilerState(code, { tabSize: 1 });
     try {
-      code += `${this.toEmbeddedTS(state)}\n`;
+      code += `${yield* this.toEmbeddedTS(state)}\n`;
     } catch (err) {
       code += '\n';
     }
@@ -413,12 +427,13 @@ export class Variable extends BaseNode {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTSInProcess(state?: TranslatorState): string {
-    let code = this.name;
-    if (this.typeAnnotation) {
+  @withSourceMapGenerator
+  *toEmbeddedTSInProcess(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = self.name;
+    if (self.typeAnnotation) {
       code += ': undefined as ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      code += yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code));
     }
     // if (this.defaultValue) {
     //     code += `: ${this.defaultValue}`;