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

package/src/concepts/NewList__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach, runGeneratorSync as runSync } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import ForEachStatement from './ForEachStatement__';
 import Logic from './Logic__';
 //================================================================================
@@ -282,9 +292,12 @@ export class NewList 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;
@@ -335,9 +348,12 @@ export class NewList 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;
@@ -398,44 +414,42 @@ export class NewList extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     const indent0 = indent(state?.tabSize || 0);
     const indent1 = indent((state?.tabSize || 0) + 1);
     const indent2 = indent((state?.tabSize || 0) + 2);
-
-    const typeCode = (codestr: string) => {
+    const typeCode = function* typeCode(codestr: string) {
       codestr += `nasl.util.New<`;
-      codestr += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, codestr, { inline: true }))}`;
+      codestr += `${yield * self.typeAnnotation.toEmbeddedTS(shiftState(state, codestr, { inline: true }))}`;
       codestr += `>()`;
       return codestr;
     };
-
     let code = '';
-    if (this.typeAnnotation) {
+    if (self.typeAnnotation) {
       code += `${indent0}(() => { \n`;
       // ts报错检查
       code += `${indent1}function __newComposite() {\n`;
-      this.items.forEach((item) => {
+      yield* wrapForEach(self.items, function* warpForEachGenerator(item) {
         code += `${indent2}nasl.util.Add(`;
-        code = `${typeCode(code)}, `;
-        code += item.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code = `${yield* typeCode(code)}, `;
+        code += yield* item.toEmbeddedTS(shiftState(state, code, { inline: true }));
         code += ');';
         code += '\n';
       });
       code += `${indent2}return `;
-      code = `${typeCode(code)};\n`;
+      code = `${yield* typeCode(code)};\n`;
       code += `${indent1}};\n`;
-
       code += `${indent1}return __newComposite();\n`;
       code += `${indent0}})()`;
     } else {
       code += `${indent0}(() => { \n`;
       const arr: any = [];
-      this.items.forEach((item, index) => {
+      yield* wrapForEach(self.items, function* warpForEachGenerator(item, index) {
         if (item.concept === 'Unparsed') return;
         code += `${indent1}nasl.core.ensureVoid(`;
-        arr.push(item.toEmbeddedTS(shiftState(state, code, { inline: true })));
+        arr.push(yield* item.toEmbeddedTS(shiftState(state, code, { inline: true })));
         code += arr[index];
         code += '); ';
       });
@@ -444,32 +458,32 @@ export class NewList extends LogicItem {
         code += `${indent1}__IDENTIFIER__;\n`;
       // ts报错检查
       code += `${indent1}function __newComposite() {\n`;
-      if (this.items.length === 0) {
+      if (self.items.length === 0) {
         code += `${indent2}return nasl.util.NewList();\n`;
       } else {
         code += `${indent2}let arr = [`;
-        this.items.forEach((item, index) => {
+        yield* wrapForEach(self.items, function* warpForEachGenerator(item, index) {
           code += ['__IDENTIFIER__', '__IDENTIFIER__()'].includes(arr[index]) ? null : arr[index];
-          if (index + 1 < this.items.length) code += ', ';
+          if (index + 1 < self.items.length) code += ', ';
         });
         code += ']\n';
         code += `${indent2}return nasl.util.NewList(...arr);\n`;
       }
       code += `${indent1}};\n`;
-
       code += `${indent1}return __newComposite();\n`;
       code += `${indent0}})()`;
     }
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedIgnoreTS(state?: TranslatorState): string {
+  @withSourceMapGenerator
+  *toEmbeddedIgnoreTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     const indent0 = indent(state?.tabSize || 0);
     let code = '';
     code += `${indent0}nasl.util.NewList({items:[`;
-    this.items.forEach((item) => {
-      code += item.toEmbeddedTS(shiftState(state, code, { inline: true }));
+    yield* wrapForEach(self.items, function* warpForEachGenerator(item) {
+      code += yield* item.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += ', ';
     });
     code += ']})';
@@ -494,39 +508,39 @@ export class NewList extends LogicItem {
     return code;
   }
 
-  getInitCode(state?: TranslatorState): string {
+  *getInitCode(state?: TranslatorState) {
+    const self = this;
     const indent1 = indent((state?.tabSize || 0) + 1);
     const indent2 = indent((state?.tabSize || 0) + 2);
     const indent3 = indent((state?.tabSize || 0) + 3);
     let code = '';
     code += '(() => { \n';
     code += `${indent2}function __newComposite() {\n`;
-    if (this.items.length === 0) {
+    if (self.items.length === 0) {
       code += `${indent3}return nasl.util.NewList();\n`;
     } else {
       code += `${indent3}let arr = [`;
-      this.items.forEach((item, index) => {
-        let ts = item.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        ts = this.getForeachCode(ts);
+      yield* wrapForEach(self.items, function* wrapForEach(item, index) {
+        let ts = yield* item.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        ts = yield* self.getForeachCode(ts);
         code += ['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts) ? null : ts;
-        if (index + 1 < this.items.length) code += ', ';
+        if (index + 1 < self.items.length) code += ', ';
       });
       code += ']\n';
       code += `${indent3}return nasl.util.NewList(...arr);\n`;
     }
     code += `${indent2}};\n`;
-
     code += `${indent2}return __newComposite();\n`;
     code += `${indent1}})()`;
     return code;
   }
 
-  getForeachCode(code: string): string {
+  *getForeachCode(code: string) {
     // ForEachStatement 内部变量需要替换处理，如 item、index
     const forEachStatement = this.getAncestor('ForEachStatement') as ForEachStatement;
     if (forEachStatement && code) {
       code = code.replaceAll('\n', ' ');
-      code = new Logic().handleForEachCode(code, forEachStatement);
+      code = yield* new Logic().handleForEachCode(code, forEachStatement);
     }
     return code;
   }

package/src/concepts/NewMap__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach, runGeneratorSync as runSync } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import ForEachStatement from './ForEachStatement__';
 import Logic from './Logic__';
@@ -446,9 +456,12 @@ export class NewMap 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;
@@ -524,9 +537,12 @@ export class NewMap 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;
@@ -595,65 +611,63 @@ export class NewMap extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     const indent0 = indent(state?.tabSize || 0);
     const indent1 = indent((state?.tabSize || 0) + 1);
     const indent2 = indent((state?.tabSize || 0) + 2);
-
-    const typeCode = (codestr: string) => {
+    const typeCode = function* typeCode(codestr: string) {
       codestr += `nasl.util.New<`;
-      codestr += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, codestr, { inline: true }))}`;
+      codestr += `${yield * self.typeAnnotation.toEmbeddedTS(shiftState(state, codestr, { inline: true }))}`;
       codestr += `>()`;
       return codestr;
     };
-
     let code = '';
-    if (this.typeAnnotation) {
+    if (self.typeAnnotation) {
       code += `${indent0}(() => { \n`;
       // 方便ts报错检查
       code += `${indent1}function __newComposite() {\n`;
-      this.keys.forEach((item, index) => {
+      yield* wrapForEach(self.keys, function* warpForEachGenerator(item, index) {
         const key = item;
         code += `${indent2}nasl.util.MapPut(`;
-        code = `${typeCode(code)}, `;
-        code += `${key ? key.toEmbeddedTS(shiftState(state, code, { inline: true })) : null}`;
+        code = `${yield* typeCode(code)}, `;
+        code += `${key ? yield* key.toEmbeddedTS(shiftState(state, code, { inline: true })) : null}`;
         code += ', null)\n';
       });
-      this.values.forEach((item, index) => {
-        const value = this.values[index];
+      yield* wrapForEach(self.values, function* warpForEachGenerator(item, index) {
+        const value = self.values[index];
         code += `${indent2}nasl.util.MapPut(`;
-        code = `${typeCode(code)}, null, `;
-        code += `${value ? value.toEmbeddedTS(shiftState(state, code, { inline: true })) : null}`;
+        code = `${yield* typeCode(code)}, null, `;
+        code += `${value ? yield* value.toEmbeddedTS(shiftState(state, code, { inline: true })) : null}`;
         code += ')';
         code += '\n';
       });
       code += `${indent2}return `;
-      code = `${typeCode(code)};\n`;
+      code = `${yield* typeCode(code)};\n`;
       code += `${indent1}};\n`;
-
       code += `${indent1}return __newComposite();\n`;
       code += `${indent0}})()`;
-    } else if (this.keys.some((key) => key) || this.values.some((value) => value)) {
+    } else if (self.keys.some((key) => key) || self.values.some((value) => value)) {
       code += `${indent0}(() => { \n`;
       const valueTsArr: any = [];
       let keyTs = 'null';
       let valueTs = false;
       let keyIndex = -1;
-      this.keys.forEach((key, index) => {
+      yield* wrapForEach(self.keys, function* warpForEachGenerator(key, index) {
         if (key) {
-          const ts = key.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          const ts = yield* key.toEmbeddedTS(shiftState(state, code, { inline: true }));
           if (keyIndex === -1 && !['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
             keyIndex = index;
             keyTs = ts;
           }
         }
       });
-      this.values.length && (code += indent1);
-      this.values.forEach((item, index) => {
+      self.values.length && (code += indent1);
+      yield* wrapForEach(self.values, function* warpForEachGenerator(item, index) {
         if (item) valueTs = true;
         code += `nasl.core.ensureVoid(`;
-        const ts = item ? item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
+        const ts = item ? yield* item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
         valueTsArr.push(ts);
         code += valueTsArr[index];
         code += '); ';
@@ -664,26 +678,24 @@ export class NewMap extends LogicItem {
       }
       // 方便ts报错检查
       code += `${indent1}function __newComposite() {\n`;
-      this.keys.forEach((key: any) => {
+      yield* wrapForEach(self.keys, function* warpForEachGenerator(key: any) {
         if (!key) return;
         code += `${indent2}nasl.core.compareNew(${keyTs}, `;
-        code += key.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += yield* key.toEmbeddedTS(shiftState(state, code, { inline: true }));
         code += ');\n';
       });
       if (keyIndex !== -1) {
         code += `${indent2}nasl.util.ValidMapKey(`;
-        code += `${this.keys[keyIndex].toEmbeddedTS(shiftState(state, code, { inline: true }))});\n`;
+        code += `${yield* self.keys[keyIndex].toEmbeddedTS(shiftState(state, code, { inline: true }))});\n`;
       }
       code += `${indent2}return nasl.util.NewMap(`;
       code += `${keyIndex === -1 ? 'null' : keyTs}, ...[`;
-      valueTsArr.forEach((ts: any, index: number) => {
+      yield* wrapForEach(valueTsArr, function* warpForEachGenerator(ts: any, index: number) {
         code += ['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts) ? null : ts;
-        if (index + 1 < this.values.length) code += ', ';
+        if (index + 1 < self.values.length) code += ', ';
       });
       code += ']);\n';
-
       code += `${indent1}};\n`;
-
       code += `${indent1}return __newComposite();\n`;
       code += `${indent0}})()`;
     } else {
@@ -692,7 +704,6 @@ export class NewMap extends LogicItem {
       code += `${indent1}function __newComposite() {\n`;
       code += `${indent2}return nasl.util.NewMap(${null}, ${null});\n`;
       code += `${indent1}};\n`;
-
       code += `${indent1}return __newComposite();\n`;
       code += `${indent0}})()`;
     }
@@ -717,28 +728,30 @@ export class NewMap extends LogicItem {
     return code;
   }
 
-  getInitCode(state?: TranslatorState): string {
+  *getInitCode(state?: TranslatorState) {
+    const self = this;
     let code = '';
     if (this.keys.some((key) => key) || this.values.some((value) => value)) {
       let keyBol = false;
       code += `nasl.util.NewMap(`;
-      this.keys.forEach((key) => {
+      for (const key of this.keys) {
         if (key && !keyBol) {
-          let ts = key.toEmbeddedTS(shiftState(state, code, { inline: true }));
-          ts = this.getForeachCode(ts);
+          let ts = yield* key.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          ts = yield* this.getForeachCode(ts);
           if (!['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
             keyBol = true;
             code += ts;
           }
         }
-      });
+      };
       if (!keyBol) code += 'null';
       code += `, ...[`;
-      this.values.forEach((item, index) => {
-        let ts = item ? item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
-        ts = this.getForeachCode(ts);
+
+      yield* wrapForEach(this.values, function* wrapForEach(item, index) {
+        let ts = item ? yield* item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
+        ts = yield* self.getForeachCode(ts);
         code += ['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts) ? null : ts;
-        if (index + 1 < this.values.length) code += ', ';
+        if (index + 1 < self.values.length) code += ', ';
       });
       code += '])';
     } else {
@@ -747,12 +760,12 @@ export class NewMap extends LogicItem {
     return code;
   }
 
-  getForeachCode(code: string): string {
+  *getForeachCode(code: string) {
     // ForEachStatement 内部变量需要替换处理，如 item、index
     const forEachStatement = this.getAncestor('ForEachStatement') as ForEachStatement;
     if (forEachStatement && code) {
       code = code.replaceAll('\n', ' ');
-      code = new Logic().handleForEachCode(code, forEachStatement);
+      code = yield* new Logic().handleForEachCode(code, forEachStatement);
     }
     return code;
   }

package/src/concepts/New__.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 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -50,8 +59,9 @@ export class New extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     const code = '__IDENTIFIER__';
     return code;
   }

package/src/concepts/NullLiteral__.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';
 import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
@@ -63,8 +71,8 @@ export class NullLiteral extends LogicItem {
     return 'null';
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()) {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     return 'null';
   }
 

package/src/concepts/NumericLiteral__.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';
 import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
@@ -103,9 +111,12 @@ export class NumericLiteral 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;
@@ -127,6 +138,7 @@ export class NumericLiteral extends LogicItem {
   }
 
   toJS(): string {
+    // const code = this.value ? `new window.NaslDecimal("${String(this.value)}")` : '';
     const code = this.value ? `"${String(this.value)}"` : '';
     return code;
   }
@@ -135,10 +147,11 @@ export class NumericLiteral extends LogicItem {
     return `${this.value}`;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    const type = `${this.typeAnnotation.typeNamespace}.${this.typeAnnotation.typeName}`;
-    const code = this.value ? `new ${type}(${this.value})` : '__IDENTIFIER__';
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    const type = `${self.typeAnnotation.typeNamespace}.${self.typeAnnotation.typeName}`;
+    const code = self.value ? `new ${type}(${self.value})` : '__IDENTIFIER__';
     return code;
   }
 

package/src/concepts/OqlQueryComponent__.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 { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 import StructureProperty from './StructureProperty__';
 import Structure from './Structure__';
@@ -134,9 +144,12 @@ export class OqlQueryComponent 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;
@@ -242,29 +255,29 @@ export class OqlQueryComponent extends LogicItem {
     return sqlTypeBan;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code: string;
-    const { typeAnnotation } = this;
+    const { typeAnnotation } = self;
     if (typeAnnotation) {
-      code = `(function(): ${typeAnnotation.toEmbeddedTS()} {\n`;
+      code = `(function(): ${yield* typeAnnotation.toEmbeddedTS()} {\n`;
     } else {
-      code = `(function __oqlQueryFn${String(this.id).slice(0, 8)} () {\n`;
+      code = `(function __oqlQueryFn${String(self.id).slice(0, 8)} () {\n`;
     }
-
     const indent1 = indent((state?.tabSize || 0) + 1);
     // this.dataSource: 'app.dataSources.defaultDS';
-    if (this.dataSource) {
+    if (self.dataSource) {
       code += indent1;
-      code += `const dataSource = ${this.dataSource || 'app.dataSources.defaultDS'};\n`;
+      code += `const dataSource = ${self.dataSource || 'app.dataSources.defaultDS'};\n`;
     }
-    const hasSyntaxErrors = !!this.codeSourceMap?.oqlSyntaxError?.syntaxErrors?.length;
+    const hasSyntaxErrors = !!self.codeSourceMap?.oqlSyntaxError?.syntaxErrors?.length;
     // 生成内部的ts内容
-    if (!this.code) {
+    if (!self.code) {
       // SQL 为空
       code += `${indent1}__OQL_EMPTY_ERROR__;\n`;
     } else if (hasSyntaxErrors) {
-      const syntaxErrors = this.codeSourceMap?.oqlSyntaxError?.syntaxErrors || [];
+      const syntaxErrors = self.codeSourceMap?.oqlSyntaxError?.syntaxErrors || [];
       const warningList = syntaxErrors.filter((err: any) => err.errorMsg.includes('别名不符合规范'));
       if (warningList.length === syntaxErrors.length) {
         // SQL 别名警告
@@ -279,21 +292,19 @@ export class OqlQueryComponent extends LogicItem {
       }
     }
     // insert typescript code
-    const typescript = this.codeSourceMap?.typescript;
+    const typescript = self.codeSourceMap?.typescript;
     if (typescript) {
       code += `${indent1}const __oqlQueryResult = ${typescript};`;
     }
-
     // 临时方案拼接字符串
-    this.getTextVariables();
+    self.getTextVariables();
     // 翻译字段
     code += '\n';
-    this._TsVariables.forEach((variable) => {
-      code += variable.toEmbeddedTS(shiftState(state, code));
+    yield* wrapForEach(self._TsVariables, function* warpForEachGenerator(variable) {
+      code += yield* variable.toEmbeddedTS(shiftState(state, code));
       code += ';\n';
     });
     code += '\n';
-
     if (typescript && !typeAnnotation) {
       code += `${indent1}return __oqlQueryResult;\n`;
     } else {