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

package/src/concepts/MatchCase__.ts

@@ -1,5 +1,14 @@
-// @ts-nocheck
-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 Match from './Match__';
 import MemberExpression from './MemberExpression__';
 import BooleanLiteral from './BooleanLiteral__';
@@ -774,30 +783,29 @@ export class MatchCase extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, index?: number, parentCode?: string): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), index?: number, parentCode?: string): TranslatorGenerator {
+    const self = this;
     let code = '\n';
-
-    const parentNode = this.parentNode as Match;
+    const parentNode = self.parentNode as Match;
     const { length } = parentNode.cases;
-
     if (length > 1) {
       if (index !== length - 1) {
         code += indent(state?.tabSize || 0);
         code += 'if (';
-        if (Array.isArray(this.patterns) && this.patterns.length) {
-          this.patterns.forEach((pattern, index) => {
+        if (Array.isArray(self.patterns) && self.patterns.length) {
+          yield* wrapForEach(self.patterns, function* warpForEachGenerator(pattern, index) {
             // nasl.code.isUnionType<typeof ccc, List<Integer> | List<Boolean>>
             if (pattern instanceof TypeAnnotation) {
               if (index === 0) {
                 code += `nasl.core.isUnionType<typeof `;
                 code += `${parentCode},`;
-                code += pattern.toEmbeddedTS(shiftState(state, code));
+                code += yield* pattern.toEmbeddedTS(shiftState(state, code));
               } else {
                 code += '|';
-                code += pattern.toEmbeddedTS(shiftState(state, code));
+                code += yield* pattern.toEmbeddedTS(shiftState(state, code));
               }
-              if (index === this.patterns.length - 1) {
+              if (index === self.patterns.length - 1) {
                 code += '>';
                 code += `(${parentCode})`;
               }
@@ -807,7 +815,7 @@ export class MatchCase extends LogicItem {
               }
               code += parentCode;
               code += ' === ';
-              code += pattern.toEmbeddedTS(
+              code += yield* pattern.toEmbeddedTS(
                 shiftState(state, code, {
                   tabSize: state?.tabSize || 0,
                 }),
@@ -818,14 +826,13 @@ export class MatchCase extends LogicItem {
           code += '__IDENTIFIER__';
         }
         code += ') {\n';
-
-        if (Array.isArray(this.body)) {
-          this.body.forEach((logicItem, bodyIndex) => {
-            if (parentNode.isExpression && bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+        if (Array.isArray(self.body)) {
+          yield* wrapForEach(self.body, function* warpForEachGenerator(logicItem, bodyIndex) {
+            if (parentNode.isExpression && bodyIndex === self.body.length - 1 && logicItem.concept !== 'Assignment') {
               code += indent(state?.tabSize || 0);
               code += `return `;
             }
-            code += `${logicItem.toEmbeddedTS(
+            code += `${yield* logicItem.toEmbeddedTS(
               shiftState(state, code, {
                 tabSize: state?.tabSize || 0,
               }),
@@ -836,13 +843,13 @@ export class MatchCase extends LogicItem {
       } else {
         code += indent(state?.tabSize || 0);
         code += 'else {\n';
-        if (Array.isArray(this.body)) {
-          this.body.forEach((logicItem, bodyIndex) => {
-            if (parentNode.isExpression && bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+        if (Array.isArray(self.body)) {
+          yield* wrapForEach(self.body, function* warpForEachGenerator(logicItem, bodyIndex) {
+            if (parentNode.isExpression && bodyIndex === self.body.length - 1 && logicItem.concept !== 'Assignment') {
               code += indent(state?.tabSize || 0);
               code += `return `;
             }
-            code += `${logicItem.toEmbeddedTS(
+            code += `${yield* logicItem.toEmbeddedTS(
               shiftState(state, code, {
                 tabSize: state?.tabSize || 0,
               }),
@@ -852,13 +859,13 @@ export class MatchCase extends LogicItem {
         code += `${indent(state?.tabSize || 0)}}\n`;
       }
     } else {
-      if (Array.isArray(this.body)) {
-        this.body.forEach((logicItem, bodyIndex) => {
-          if (parentNode.isExpression && bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+      if (Array.isArray(self.body)) {
+        yield* wrapForEach(self.body, function* warpForEachGenerator(logicItem, bodyIndex) {
+          if (parentNode.isExpression && bodyIndex === self.body.length - 1 && logicItem.concept !== 'Assignment') {
             code += indent(state?.tabSize || 0);
             code += `return `;
           }
-          code += `${logicItem.toEmbeddedTS(
+          code += `${yield* logicItem.toEmbeddedTS(
             shiftState(state, code, {
               tabSize: state?.tabSize || 0,
             }),
@@ -867,7 +874,6 @@ export class MatchCase extends LogicItem {
       }
       code += '\n';
     }
-
     return code;
   }
 

package/src/concepts/Match__.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 TypeAnnotation, { isUnion } from './TypeAnnotation__';
 import BooleanLiteral from './BooleanLiteral__';
 import MemberExpression from './MemberExpression__';
@@ -692,25 +702,25 @@ export class Match extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-
-    if (this.parentNode.concept === 'Logic') {
+    if (self.parentNode.concept === 'Logic') {
       code += '\n';
     }
     code += indent(state?.tabSize || 0);
     code += '(() => { \n';
     let parentCode: string;
-    if (this.expression) {
+    if (self.expression) {
       code += indent(state?.tabSize || 0);
       // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
-      if (this.expression instanceof Identifier || this.expression instanceof MemberExpression) {
-        code += parentCode = this.expression.toEmbeddedTS(shiftState(state, code));
+      if (self.expression instanceof Identifier || self.expression instanceof MemberExpression) {
+        code += parentCode = yield* self.expression.toEmbeddedTS(shiftState(state, code));
       } else {
         parentCode = '__matchExpression';
         code += `let ${parentCode} = `;
-        code += this.expression.toEmbeddedTS(shiftState(state, code));
+        code += yield* self.expression.toEmbeddedTS(shiftState(state, code));
       }
       code += ';\n';
     } else {
@@ -718,11 +728,10 @@ export class Match extends LogicItem {
     }
     code += indent(state?.tabSize + 1 || 0);
     code += ' function __MatchExpressionFuntion() {\n';
-
     //  最后一项是else
-    this.cases.forEach((item, index) => {
+    yield* wrapForEach(self.cases, function* warpForEachGenerator(item, index) {
       // 如果是最后一项
-      code += item.toEmbeddedTS(shiftState(state, code, { tabSize: state?.tabSize || 0 }), index, parentCode);
+      code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: state?.tabSize || 0 }), index, parentCode);
     });
     code += indent(state?.tabSize || 0);
     code += '};\n';
@@ -730,20 +739,19 @@ export class Match extends LogicItem {
     code += 'return __MatchExpressionFuntion();\n';
     code += indent(state?.tabSize || 0);
     code += '})()';
-
     if (
-      this.parentNode.concept !== 'Argument' &&
-      this.parentKey !== 'test' &&
-      this.parentKey !== 'patterns' &&
-      this.parentNode.concept !== 'Assignment' &&
-      this.parentNode.concept !== 'ForEachStatement' &&
-      this.parentNode.concept !== 'SelectMembers' &&
-      this.parentNode.concept !== 'UnaryExpression' &&
-      this.parentNode.concept !== 'BinaryExpression' &&
-      this.parentNode.concept !== 'StringInterpolation' &&
-      this.parentNode.concept !== 'MemberExpression' &&
-      !['NewMap', 'NewList'].includes(this.parentNode.concept) &&
-      this.parentKey !== 'returnExpression'
+      self.parentNode.concept !== 'Argument' &&
+      self.parentKey !== 'test' &&
+      self.parentKey !== 'patterns' &&
+      self.parentNode.concept !== 'Assignment' &&
+      self.parentNode.concept !== 'ForEachStatement' &&
+      self.parentNode.concept !== 'SelectMembers' &&
+      self.parentNode.concept !== 'UnaryExpression' &&
+      self.parentNode.concept !== 'BinaryExpression' &&
+      self.parentNode.concept !== 'StringInterpolation' &&
+      self.parentNode.concept !== 'MemberExpression' &&
+      !['NewMap', 'NewList'].includes(self.parentNode.concept) &&
+      self.parentKey !== 'returnExpression'
     ) {
       code += ';\n';
     }
@@ -776,7 +784,7 @@ export class Match extends LogicItem {
       code += item.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }), index, parentCode);
     });
     code += indent(state.tabSize);
-    code += `})(${this.expression.toNaturalTS(shiftState(state, code, { inline: true }))})`;
+    code += `})(${this.expression?.toNaturalTS(shiftState(state, code, { inline: true }))})`;
 
     if (
       this.parentNode?.concept !== 'Argument' &&

package/src/concepts/MemberExpression__.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 { Enum, TypeAnnotation } from '..';
 import { ElementToVueOptions } from './ViewElement__';
 import Identifier from './Identifier__';
@@ -452,12 +461,15 @@ export class MemberExpression extends LogicItem {
    * @param state
    * @returns
    */
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-    const leftCode = this.object ? `${this.object.toEmbeddedTS(shiftState(state, code, { inline: true }))}.` : '';
-    code += this.object ? `${this.object.toEmbeddedTS(shiftState(state, code, { inline: true }))}.` : '';
-    code += this.property ? this.property.toEmbeddedTS(shiftState(state, code, { inline: true })) : '';
+    const leftCode = self.object
+      ? `${yield* self.object.toEmbeddedTS(shiftState(state, code, { inline: true }))}.`
+      : '';
+    code += self.object ? `${yield* self.object.toEmbeddedTS(shiftState(state, code, { inline: true }))}.` : '';
+    code += self.property ? yield* self.property.toEmbeddedTS(shiftState(state, code, { inline: true })) : '';
     // 就说明这是一个枚举取值操作，直接啊app.enums.color.red 要转成字符串
     // 解决枚举可能全是数字的问题
     // app.enums.color  || extensions.tool.enums.color
@@ -467,27 +479,27 @@ export class MemberExpression extends LogicItem {
       code = newCode;
     }
     if (
-      this.object instanceof Identifier &&
-      this.object?.namespace?.startsWith('elements.') &&
-      this.object?.namespace?.endsWith('.property')
+      self.object instanceof Identifier &&
+      self.object?.namespace?.startsWith('elements.') &&
+      self.object?.namespace?.endsWith('.property')
     ) {
       let newCode = '';
-      if (this.object?.namespace?.startsWith('elements.$ce')) {
-        const elementName = this.getAncestor('ViewElement')?.name;
+      if (self.object?.namespace?.startsWith('elements.$ce')) {
+        const elementName = self.getAncestor('ViewElement')?.name;
         newCode += `__elements_completionProperty.${elementName}`;
-        if (this.property instanceof Identifier && this.property?.namespace) {
-          const namespace = this.property?.namespace ?? '';
+        if (self.property instanceof Identifier && self.property?.namespace) {
+          const namespace = self.property?.namespace ?? '';
           const namespaceList = namespace?.includes('.') ? namespace?.split('.') : [namespace];
-          namespaceList?.forEach((item) => {
+          yield* wrapForEach(namespaceList, function* warpForEachGenerator(item) {
             newCode += `.${attrConvertCamelCase(item)}`;
           });
         }
       } else {
-        newCode += `__elements_completionProperty.${this.object?.name}`;
-        if (this.property instanceof Identifier && this.property?.namespace) {
-          const namespace = this.property?.namespace ?? '';
+        newCode += `__elements_completionProperty.${self.object?.name}`;
+        if (self.property instanceof Identifier && self.property?.namespace) {
+          const namespace = self.property?.namespace ?? '';
           const namespaceList = namespace?.includes('.') ? namespace?.split('.') : [namespace];
-          namespaceList?.forEach((item) => {
+          yield* wrapForEach(namespaceList, function* warpForEachGenerator(item) {
             newCode += `.${attrConvertCamelCase(item)}`;
           });
         }
@@ -495,17 +507,17 @@ export class MemberExpression extends LogicItem {
       return newCode;
     }
     if (
-      this.object instanceof MemberExpression &&
-      this.object?.object?.name === 'elements' &&
-      this.object?.property?.name === '$ce'
+      self.object instanceof MemberExpression &&
+      self.object?.object?.name === 'elements' &&
+      self.object?.property?.name === '$ce'
     ) {
       let newCode = '';
-      const elementName = this.getAncestor('ViewElement')?.name;
+      const elementName = self.getAncestor('ViewElement')?.name;
       newCode += `__elements_completionProperty['${elementName}']`;
-      if (atrrParamsMap[this.property.name]) {
-        const name = atrrParamsMap[this.property.name];
+      if (atrrParamsMap[self.property.name]) {
+        const name = atrrParamsMap[self.property.name];
         const nameList = name.includes('.') ? name.split('.') : [name];
-        nameList.forEach((item) => {
+        yield* wrapForEach(nameList, function* warpForEachGenerator(item) {
           newCode += `.${attrConvertCamelCase(item)}`;
         });
       }

package/src/concepts/MetadataType__.ts

@@ -1,4 +1,15 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import type { EmbeddedTSFileGenerator } from '../utils';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import Namespace from './Namespace__';
 
 //================================================================================
@@ -576,15 +587,16 @@ export class MetadataType extends BaseNode {
       ...object,
     });
   }
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState): string {
-    const { typeNamespace, typeName } = this.typeAnnotation || {};
-    let code = `export class ${this.tsName} extends ${typeNamespace}.${typeName} {\n`;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    const { typeNamespace, typeName } = self.typeAnnotation || {};
+    let code = `export class ${self.tsName} extends ${typeNamespace}.${typeName} {\n`;
     code += indent((state?.tabSize || 0) + 2);
-    if (this.rules.length) {
+    if (self.rules.length) {
       code += 'function rule() {';
-      this.rules.forEach((item) => {
-        code += item.toEmbeddedTS(shiftState(state, code));
+      yield* wrapForEach(self.rules, function* warpForEachGenerator(item) {
+        code += yield* item.toEmbeddedTS(shiftState(state, code));
         code += ';\n';
       });
       code += '}\n';
@@ -628,11 +640,11 @@ export class MetadataType extends BaseNode {
     return `/embedded/${this.app.name}${_path}/metadataTypes/${name}.ts`;
   }
 
-  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) {
       code += '';
       console.log(err);