@lcap/nasl 3.4.0-beta.5 → 3.4.0-beta.6

package/src/concepts/SwitchCase__.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';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -289,24 +299,23 @@ export class SwitchCase extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, isLast?: boolean): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), isLast?: boolean): TranslatorGenerator {
+    const self = this;
     let code = '\n';
     if (!isLast) {
       code += 'if (nasl.core.ensureBoolean(';
-      code += this.test
-        ? this.test.toEmbeddedTS(
+      code += self.test
+        ? yield* self.test.toEmbeddedTS(
             shiftState(state, code, {
               tabSize: (state?.tabSize || 0) + 1,
             }),
           )
         : '__IDENTIFIER__';
-
       code += ')) {\n';
-
-      if (Array.isArray(this.consequent)) {
-        this.consequent.forEach((logicItem) => {
-          code += `${logicItem.toEmbeddedTS(
+      if (Array.isArray(self.consequent)) {
+        yield* wrapForEach(self.consequent, function* warpForEachGenerator(logicItem) {
+          code += `${yield* logicItem.toEmbeddedTS(
             shiftState(state, code, {
               tabSize: (state?.tabSize || 0) + 1,
             }),
@@ -316,9 +325,9 @@ export class SwitchCase extends LogicItem {
       code += `${indent(state?.tabSize || 0)}}\n`;
     } else {
       code += 'else {\n';
-      if (Array.isArray(this.consequent)) {
-        this.consequent.forEach((logicItem) => {
-          code += `${logicItem.toEmbeddedTS(
+      if (Array.isArray(self.consequent)) {
+        yield* wrapForEach(self.consequent, function* warpForEachGenerator(logicItem) {
+          code += `${yield* logicItem.toEmbeddedTS(
             shiftState(state, code, {
               tabSize: (state?.tabSize || 0) + 1,
             }),
@@ -327,7 +336,6 @@ export class SwitchCase extends LogicItem {
       }
       code += `${indent(state?.tabSize || 0)}}\n`;
     }
-
     return code;
   }
 

package/src/concepts/SwitchStatement__.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';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -236,16 +245,17 @@ export class SwitchStatement extends LogicItem {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
     //  最后一项是else
-    this.cases.forEach((item, index) => {
+    yield* wrapForEach(self.cases, function* warpForEachGenerator(item, index) {
       // 如果是最后一项
-      if (index === this.cases.length - 1) {
-        code += item.toEmbeddedTS(shiftState(state, code), true);
+      if (index === self.cases.length - 1) {
+        code += yield* item.toEmbeddedTS(shiftState(state, code), true);
       } else {
-        code += item.toEmbeddedTS(shiftState(state, code));
+        code += yield* item.toEmbeddedTS(shiftState(state, code));
       }
     });
     return code;

package/src/concepts/TriggerLauncher__.ts

@@ -1,4 +1,13 @@
-import { createCompilerState, withSourceMap, TranslatorState, shiftState } from '../translator';
+import type { EmbeddedTSFileGenerator } from '../utils';
+import {
+  createCompilerState,
+  withSourceMap,
+  TranslatorState,
+  shiftState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import Connector from './Connector__';
 import LogicItem from './LogicItem__';
 import Identifier from './Identifier__';
@@ -155,13 +164,14 @@ export class TriggerLauncher extends BaseNode {
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-    code += `export function ${this.name} () {\n`;
+    code += `export function ${self.name} () {\n`;
     try {
       // 仅仅作引用查找不需要入参校验
-      code += `${this.callBackLogicKey}`;
+      code += `${self.callBackLogicKey}`;
       code += ';\n';
       code += '}\n';
     } catch (error) {
@@ -175,12 +185,12 @@ export class TriggerLauncher extends BaseNode {
     return `${namespace}.${name}`;
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getTsNamespace()} {\n`;
 
     const state = createCompilerState(code, { tabSize: 1 });
     try {
-      code += this.toEmbeddedTS(state);
+      code += yield* this.toEmbeddedTS(state);
     } catch (err) {
       console.log(err, '有问题翻译失败');
       code += '';

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';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
@@ -971,53 +980,54 @@ 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}`;
       }
       // 针对 集成中心中的编辑态的连接器相关需要特殊处理
-      if (this.connector && this.integration && this.typeKind === 'reference') {
-        return `${this.tsCalleeNamespace}.${this.typeName}${CUSTOM_CONNECTOR_EDITABLE_SUFFIX}`;
+      if (self.connector && self.integration && self.typeKind === 'reference') {
+        return `${self.tsCalleeNamespace}.${self.typeName}${CUSTOM_CONNECTOR_EDITABLE_SUFFIX}`;
       }
-      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}.${this.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 自动生成，请不手动修改！
@@ -59,9 +67,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__';
 
 //================================================================================
@@ -167,21 +176,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,12 @@
-import { withSourceMap, TranslatorState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  withSourceMap,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorState,
+  TranslatorGenerator,
+  createCompilerState,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -85,8 +93,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';
@@ -487,50 +497,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__';
@@ -13,7 +23,7 @@ function tryJSONParse(str: string) {
 
   try {
     result = JSON.parse(str);
-  } catch (e) {}
+  } catch (e) { }
 
   return result;
 }
@@ -345,15 +355,8 @@ export class Variable extends BaseNode {
     }
 
     if (this.defaultValue?.expression) {
-      let expressionJS = this.defaultValue.expression?.toJS?.() || `""`;
+      const expressionJS = this.defaultValue.expression?.toJS?.() || `""`;
       const { typeKind, typeName } = typeAnnotation || {};
-      const isDecimal = typeKind === 'primitive' && ['Decimal', 'Double'].includes(typeName);
-      const isInteger = typeKind === 'primitive' && ['Long', 'Integer'].includes(typeName);
-      if (isDecimal) {
-        expressionJS = `new NaslDecimal('${expressionJS}')`;
-      } else if (isInteger) {
-        expressionJS = `new NaslLong('${expressionJS}')`;
-      }
       code += expressionJS;
     } else {
       code += 'undefined';
@@ -364,39 +367,40 @@ 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));
     }
     if (
-      this.defaultValue?.expression &&
-      !['__IDENTIFIER__', '__IDENTIFIER__()'].includes(this.defaultValue?.toEmbeddedTS())
+      self.defaultValue?.expression &&
+      !['__IDENTIFIER__', '__IDENTIFIER__()'].includes(yield* self.defaultValue?.toEmbeddedTS?.() ?? utils.returnOrigin(''))
     ) {
-      if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(this.typeAnnotation?.typeKey)) {
-        code += this.defaultValue.toEmbeddedTS(shiftState(state, code), true);
+      if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(self.typeAnnotation?.typeKey)) {
+        code += yield* self.defaultValue.toEmbeddedTS(shiftState(state, code), true);
       } else {
         code += ` = `;
-        code += this.defaultValue.toEmbeddedTS(shiftState(state, code));
+        code += yield* self.defaultValue.toEmbeddedTS(shiftState(state, code));
       }
     }
 
     /* 前端全局变量默认值草稿区 */
     // @ts-ignore
-    if (this.defaultValue && this.concept === 'FrontendVariable') {
+    if (self.defaultValue && self.concept === 'FrontendVariable') {
       code += `${indent(1)}function __playground(){\n`;
-      if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(this.defaultValue.toEmbeddedTS())) {
+      if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(yield* self.defaultValue?.toEmbeddedTS?.() ?? utils.returnOrigin(''))) {
         code += `${indent(2)}`;
-        code += this.defaultValue.toEmbeddedTS(shiftState(state, code));
+        code += yield* self.defaultValue.toEmbeddedTS(shiftState(state, code));
         code += '\n';
       }
       code += `${indent(2)}return\n`;
-      this.defaultValue.playground?.forEach((item) => {
-        code += item.toEmbeddedTS(shiftState(state, code));
+      for (const item of self.defaultValue?.playground ?? []) {
+        code += yield* item.toEmbeddedTS(shiftState(state, code));
         code += ';\n';
-      });
+      }
       code += `${indent(1)}}\n`;
     }
     return code;
@@ -448,12 +452,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';
     }
@@ -466,8 +470,8 @@ export class Variable extends BaseNode {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTSInProcess(state?: TranslatorState): string {
+  @withSourceMapGenerator
+  *toEmbeddedTSInProcess(state = createCompilerState()): TranslatorGenerator {
     let code = this.name;
     if (this.typeAnnotation) {
       code += `: `;
@@ -478,15 +482,15 @@ export class Variable extends BaseNode {
           ['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(this.typeAnnotation.typeKey)
         )
       ) {
-        code += `${this.defaultValue.toEmbeddedTS(shiftState(state, code))}`;
+        code += `${yield* this.defaultValue.toEmbeddedTS(shiftState(state, code))}`;
       } else {
         if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(this.typeAnnotation?.typeKey)) {
-          code += this.defaultValue.toEmbeddedTS(shiftState(state, code), true);
+          code += yield* this.defaultValue.toEmbeddedTS(shiftState(state, code), true);
         }
         code += 'undefined';
       }
       code += ' as ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      code += yield* this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
     }
     return code;
   }