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

package/src/concepts/Logic__.ts

@@ -1,3 +1,11 @@
+import {
+  wrapForEachToGenerator as wrapForEach,
+  wrapIteratorToGenerator as wrapIterator,
+  runGeneratorSync as runSync,
+  returnOrigin,
+} from '../utils/time-slicing';
+import { waitOqlQueryComponentChildrenFinish } from '../common';
+import type { EmbeddedTSFileGenerator } from '../utils';
 import { FrontendLibrary } from './FrontendLibrary__';
 import {
   TranslatorState,
@@ -6,6 +14,9 @@ import {
   indent,
   createCompilerState,
   embeddedTSEmitter,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
 } from '../translator';
 import Namespace from './Namespace__';
 import CallQueryComponent from './CallQueryComponent__';
@@ -22,7 +33,6 @@ import CallInterface from './CallInterface__';
 import CallLogic from './CallLogic__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 import type Interface from './Interface__';
-import InterfaceFromExample from './InterfaceFromExample__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -1711,65 +1721,70 @@ export class Logic extends BaseNode {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTSInProcess(state?: TranslatorState, prependCode?: string, noName?: boolean, prefix?: boolean): string {
+  @withSourceMapGenerator
+  *toEmbeddedTSInProcess(
+    state = createCompilerState(),
+    prependCode?: string,
+    noName?: boolean,
+    prefix?: boolean,
+  ): TranslatorGenerator {
+    const self = this;
     let code = '';
-    if (!prefix) code += `${noName ? '' : `${this.name}:`} function(`;
-    else code += `function ${this.name}(`; // 加空格会导致无法查询到引用
-    this.params.forEach((param, index) => {
-      code += param.toEmbeddedTS(shiftState(state, code, { inline: true }), null, true);
-      if (index !== this.params.length - 1) code += ', ';
-    });
+    if (!prefix) code += `${noName ? '' : `${self.name}:`} function(`;
+    else code += `function ${self.name}(`; // 加空格会导致无法查询到引用
+    yield* wrapForEach(
+      self.params,
+      function* warpForEachGenerator(param, index) {
+        code += yield* param.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        if (index !== self.params.length - 1) code += ', ';
+      },
+    );
     code += `) {\n`;
     code += prependCode || '';
     code += '\n';
-    this.variables.forEach((variable) => {
+    yield* wrapForEach(self.variables, function* warpForEachGenerator(variable) {
       code += `${indent((state?.tabSize || 0) + 1)}let `;
-      code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += ';\n';
     });
-
-    this.returns.forEach((ret) => {
+    yield* wrapForEach(self.returns, function* warpForEachGenerator(ret) {
       code += `${indent((state?.tabSize || 0) + 1)}let `;
-      code += ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += ';\n';
     });
-
-    if (!this.body.length && this.returns.length) {
-      code += `${indent((state?.tabSize || 0) + 1)}return ${this.returns[0].name};\n`;
+    if (!self.body.length && self.returns.length) {
+      code += `${indent((state?.tabSize || 0) + 1)}return ${self.returns[0].name};\n`;
     } else {
-      if ((this.parentNode as any).type === 'ExclusiveGateway') {
-        if (this.body.length <= 1) {
+      if ((self.parentNode as any).type === 'ExclusiveGateway') {
+        if (self.body.length <= 1) {
           code += indent((state?.tabSize || 0) + 1);
           code += 'const __LogicEmpty: any = null;';
         }
       } else if (
-        this.body.length <= 2 &&
-        !(this.parentNode instanceof Namespace) &&
-        !(this.parentNode instanceof Process)
+        self.body.length <= 2 &&
+        !(self.parentNode instanceof Namespace) &&
+        !(self.parentNode instanceof Process)
       ) {
         code += indent((state?.tabSize || 0) + 1);
         code += `${indent(state?.tabSize || 0 + 4)}const __LogicEmpty: any = null;`;
       }
-      this.body.forEach((item) => {
-        code += item.toEmbeddedTS && item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+      yield* wrapForEach(self.body, function* warpForEachGenerator(item) {
+        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ?? returnOrigin('');
         code += ';\n';
       });
     }
-
     // 在body渲染完成之后把其余的节点放到下面
-    this.playground.forEach((item) => {
-      code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+    yield* wrapForEach(self.playground, function* warpForEachGenerator(item) {
+      code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
       code += '\n';
     });
-
     code += `${indent(state?.tabSize || 0 + 4)}}`;
     code += '\n';
     return code;
   }
 
   toEmbeddedTSNoExport(state?: TranslatorState): string {
-    return this.toEmbeddedTS(state, 'noExport');
+    return runSync(this.toEmbeddedTS(state, 'noExport'));
   }
 
   get tsName() {
@@ -1781,155 +1796,134 @@ export class Logic extends BaseNode {
     return this.name;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, prefix?: string, hideDefaultValue?: boolean): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), prefix?: string, hideDefaultValue?: boolean): TranslatorGenerator {
+    const self = this;
+    // 等待 oql 查询返回内容
+    yield waitOqlQueryComponentChildrenFinish(self);
     // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
     let code = '';
     // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
-    const IDENTIFIERMAP = new Set();
+    const IDENTIFIERMAP = new Set<Variable | Return>();
 
     if (!prefix) {
-      code += `export function ${this.tsName}`;
+      code += `export function ${self.name}`;
     } else if (prefix === 'noExport') {
-      code += `function ${this.tsName}`;
+      code += `function ${self.name}`;
     } else if (prefix === 'inObject') {
-      code += `${this.tsName}`;
+      code += `${self.name}`;
     }
-    if (this.typeParams?.length) {
+    if (self.typeParams?.length) {
       code += '<';
-      this.typeParams.forEach((typeParam, typeParamIndex) => {
-        code += typeParam.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        if (typeParamIndex !== this.typeParams.length - 1) code += ', ';
+      yield* wrapForEach(self.typeParams, function* warpForEachGenerator(typeParam, typeParamIndex) {
+        code += yield* typeParam.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        if (typeParamIndex !== self.typeParams.length - 1) code += ', ';
       });
       code += '>';
     }
     // 有参数长度
-    if (this.params.length) {
+    if (self.params.length) {
       code += '(';
-      this.params.forEach((param, index) => {
-        code += param.toEmbeddedTS(shiftState(state, code));
-        if (index !== this.params.length - 1) code += ', ';
+      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
+        code += yield* param.toEmbeddedTS(shiftState(state, code));
+        if (index !== self.params.length - 1) code += ', ';
       });
       code += ')';
     } else {
       // 没有参数的
       code += '()';
     }
-
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
-    const needGetSourceMapOqlList: Promise<any>[] = [];
-    this.traverseChildren((el) => {
+    // const needGetSourceMapOqlList: Promise<any>[] = [];
+    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
       if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
         if (el instanceof Assignment) {
-          const advanceVar = this.variables?.find(
+          const advanceVar = self.variables?.find(
             (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
           );
           if (advanceVar && !advanceMap.get(advanceVar)) {
             advanceMap.set(advanceVar, el);
           }
-          const advanceRn = this.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
+          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
           if (advanceRn && !advanceMap.get(advanceRn)) {
             advanceMap.set(advanceRn, el);
           }
         } else if (el instanceof BatchAssignment) {
-          el.assignmentLines.forEach(({ leftIndex }) => {
+          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
             const leftCode =
               leftIndex.length === 1
-                ? el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            const advanceVar = this.variables?.find(
+                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
+                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+            const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
             if (advanceVar && !advanceMap.get(advanceVar)) {
               advanceMap.set(advanceVar, el);
             }
-            const advanceRn = this.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
+            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
             if (advanceRn && !advanceMap.get(advanceRn)) {
               advanceMap.set(advanceRn, el);
             }
           });
         }
       }
-      // 如果有sql查询组件就需要把他们存起来
-      if (el instanceof OqlQueryComponent) {
-        if (!el.codeSourceMap) {
-          needGetSourceMapOqlList.push(el.requestEmbeddedTS());
-        }
-      }
     });
-
-    if (needGetSourceMapOqlList.length) {
-      Promise.all(needGetSourceMapOqlList).then(() => {
-        // 触发一下更新重新生成代码
-        (this.app as any)?.naslServer?.embeddedTSEmitter.emit('change', {
-          value: [
-            {
-              originEvent: {
-                action: 'update',
-                target: this,
-              },
-            },
-          ],
-        });
-      });
-    }
     // 兼容 return 没有类型情况
-    if (this.returns.length && this.returns[0].typeAnnotation) {
+    if (self.returns.length && self.returns[0].typeAnnotation) {
       code += ': ';
-      code += this.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
     }
     code += '{\n';
-
     // 用于虚拟节点的查找引用
-    this.virtualParams &&
-      Array.isArray(this.virtualParams) &&
-      this.virtualParams.forEach((param) => {
+    if (Array.isArray(self.virtualParams)) {
+      for (const param of self.virtualParams) {
         code += indent((state?.tabSize || 0) + 1);
-        code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
+        code += yield* param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
         code += '\n';
-      });
+      }
+    }
 
-    this.variables.forEach((variable) => {
-      const ts = variable.defaultValue?.toEmbeddedTS();
+    for (const variable of self.variables) {
+      const ts = yield* variable.defaultValue?.toEmbeddedTS?.() ?? utils.returnOrigin('');
       if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
         IDENTIFIERMAP.add(variable);
       }
       if (!advanceMap.get(variable)) {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
         code += ';\n';
       }
-    });
+    }
 
-    this.returns.forEach((ret) => {
-      const ts = ret.defaultValue?.toEmbeddedTS();
+    for (const ret of self.returns) {
+      const ts = yield* ret.defaultValue?.toEmbeddedTS?.() ?? returnOrigin('');
       if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
         IDENTIFIERMAP.add(ret);
       }
       if (!advanceMap.get(ret)) {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += yield* ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
         code += ';\n';
       }
-    });
+    }
 
-    advanceMap.forEach((assignment, node) => {
+    yield* wrapIterator(advanceMap.entries(), function* warpForEachGenerator([node, assignment]) {
       // 有默认值的用默认值来推导类型, 但是如果是__IDENTIFIER__或者__IDENTIFIER__()，就不需要默认值来推导了
       if (node.defaultValue?.expression && !IDENTIFIERMAP.has(node)) {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
         return;
       }
       code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
       code += `${indent((state?.tabSize || 0) + 1)}let `;
-      code += node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
       if (assignment instanceof BatchAssignment) {
-        assignment.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+        yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
           const leftCode =
             leftIndex.length === 1
-              ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-              : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+              ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
+              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
@@ -1939,18 +1933,18 @@ export class Logic extends BaseNode {
             if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && !rightNode.isAutoInfer())) {
               if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'anonymousStructure') {
                 code += '= ';
-                code += rightNode.getInitCode(shiftState(state, code, { inline: true })) || 'null';
+                code += (yield* rightNode.getInitCode(shiftState(state, code, { inline: true }))) || 'null';
               } else if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'generic') {
                 code += '= ';
-                code += rightNode.getNewCompositeCode(shiftState(state, code, { inline: true })) || 'null';
+                code += (yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }))) || 'null';
               } else {
                 code += ': ';
-                code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
+                code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('null');
               }
             } else {
               code += ' = ';
-              const rightCode = rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-              code += this.getRightCode(rightCode, assignment, rightNode);
+              const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+              code += yield* self.getRightCode(rightCode, assignment, rightNode);
             }
           }
         });
@@ -1960,27 +1954,27 @@ export class Logic extends BaseNode {
       ) {
         const rightNode: any = assignment.right;
         code += ' = ';
-        code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
+        code += yield* rightNode.getInitCode(shiftState(state, code, { inline: true }));
       } else if (
         assignment.right?.concept === 'NewComposite' &&
         (assignment.right as any)?.typeAnnotation?.typeKind === 'anonymousStructure'
       ) {
         const rightNode: any = assignment.right;
         code += ' = ';
-        code += rightNode.getInitCode(shiftState(state, code, { inline: true }));
+        code += yield* rightNode.getInitCode(shiftState(state, code, { inline: true }));
       } else if (
         assignment.right?.concept === 'NewComposite' &&
         (assignment.right as any)?.typeAnnotation?.typeKind === 'generic'
       ) {
         const rightNode: any = assignment.right;
         code += ' = ';
-        code += rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }));
+        code += (yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true })));
       } else {
         const rightNode: any = assignment.right;
         // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
         if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && !rightNode.isAutoInfer())) {
           code += ': ';
-          code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
+          code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('null');
         } else {
           code += ' = ';
           let rightCode = '';
@@ -1995,9 +1989,9 @@ export class Logic extends BaseNode {
           }
           rightCode +=
             rightNode && rightNode.toEmbeddedTS
-              ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true }))
+              ? yield* rightNode.toEmbeddedTS(shiftState(state, code, { inline: true }))
               : '__RIGHT__';
-          code += this.getRightCode(rightCode, assignment, rightNode);
+          code += yield* self.getRightCode(rightCode, assignment, rightNode);
         }
       }
       code += ';\n';
@@ -2005,10 +1999,10 @@ export class Logic extends BaseNode {
 
     // 参数的默认值是__IDENTIFIER__或者__IDENTIFIER__()时不赋默认值，但是需要ts翻译出来进行报错校验
     if (!hideDefaultValue) {
-      IDENTIFIERMAP.forEach((node: Variable | Return) => {
-        code += node.defaultValue.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      for (const node of IDENTIFIERMAP.values()) {
+        code += yield* node.defaultValue.toEmbeddedTS(shiftState(state, code, { inline: true }));
         code += '; ';
-      });
+      }
       code += '\n';
     }
 
@@ -2016,62 +2010,42 @@ export class Logic extends BaseNode {
       code += `${indent((state?.tabSize || 0) + 1)}return ${this.returns[0].name};\n`;
     } else {
       // 如果长度小于2 并且不是虚拟节点就 加 报错，
-      if (this.body.length <= 2 && !(this.parentNode instanceof Namespace)) {
-        if (this.body.length && this.body[0].concept === 'JavaLogic') {
+      if (self.body.length <= 2 && !(self.parentNode instanceof Namespace)) {
+        if (self.body.length && self.body[0].concept === 'JavaLogic') {
           code += '';
         } else {
           code += indent((state?.tabSize || 0) + 1);
           code += 'const __LogicEmpty: any = null;';
         }
       }
-      this.body.forEach((item) => {
-        code += item.toEmbeddedTS && item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+      yield* wrapForEach(self.body, function* warpForEachGenerator(item) {
+        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ?? returnOrigin('');
         code += ';\n';
       });
     }
-
     // 在body渲染完成之后把其余的节点放到下面
-    this.playground.forEach((item) => {
-      code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+    yield* wrapForEach(self.playground, function* warpForEachGenerator(item) {
+      code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
       code += ';\n';
     });
 
     if (!hideDefaultValue) {
-      if (this.variables.length) {
-        code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是variable的默认值草稿------ */\n`;
-      }
-      this.variables.forEach((variable) => {
-        if (variable.defaultValue) {
-          variable.defaultValue.playground?.forEach((item) => {
-            code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-            code += ';\n';
-          });
+      function* setPlaygroundCode(arr: Variable[] | Param[] | Return[], name: string) {
+        if (arr.length) {
+          code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是 ${name} 的默认值草稿------ */\n`;
         }
-      });
 
-      if (this.returns.length) {
-        code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是returns的默认值草稿------ */\n`;
-      }
-      this.returns.forEach((return_) => {
-        if (return_.defaultValue) {
-          return_.defaultValue.playground?.forEach((item) => {
-            code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+        for (const item1 of arr) {
+          for (const item of item1.defaultValue?.playground ?? []) {
+            code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
             code += ';\n';
-          });
+          }
         }
-      });
-
-      if (this.params.length) {
-        code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是params的默认值草稿------ */\n`;
       }
-      this.params.forEach((param) => {
-        if (param.defaultValue) {
-          param.defaultValue.playground?.forEach((item) => {
-            code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-            code += ';\n';
-          });
-        }
-      });
+
+      yield* setPlaygroundCode(self.variables, 'variables');
+      yield* setPlaygroundCode(self.returns, 'returns');
+      yield* setPlaygroundCode(self.params, 'params');
     }
 
     code += `${indent(state?.tabSize || 0)}}`;
@@ -2177,7 +2151,7 @@ ${indent(state.tabSize)} */\n`;
           if (item.toNaturalTS) {
             partialCode = item.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
           } else if (item.toEmbeddedTS) {
-            partialCode = item.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+            partialCode = runSync(item.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 })));
           }
           if (partialCode.trim()) {
             code += partialCode;
@@ -2194,7 +2168,7 @@ ${indent(state.tabSize)} */\n`;
     return code;
   }
 
-  getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any): string {
+  *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
     code = code.replaceAll('\n', ' ');
     if (assignment instanceof Assignment && !assignment.right) return code;
 
@@ -2202,7 +2176,7 @@ ${indent(state.tabSize)} */\n`;
     if (rightNode instanceof CallInterface) {
       const { _interface } = rightNode.getModuleInterface();
       return _interface
-        ? `${rightNode.tsCalleeKey}(${(_interface as Interface).params.map(() => 'null').join(',')})`
+        ? `${rightNode.tsCalleeKey}(${(_interface as unknown as Interface).params.map(() => 'null').join(',')})`
         : null;
     }
 
@@ -2216,12 +2190,12 @@ ${indent(state.tabSize)} */\n`;
     // ForEachStatement 内部变量需要替换处理，如 item、index
     const forEachStatement = assignment.getAncestor('ForEachStatement') as ForEachStatement;
     if (forEachStatement) {
-      code = this.handleForEachCode(code, forEachStatement);
+      code = yield* this.handleForEachCode(code, forEachStatement);
     }
     // Match 需要针对分支缩小类型范围
     const matchCase = assignment.getAncestor('MatchCase') as MatchCase;
     if (matchCase) {
-      code = this.handleMatchCaseCode(code, matchCase);
+      code = yield* this.handleMatchCaseCode(code, matchCase);
     }
     return code;
   }
@@ -2245,37 +2219,39 @@ ${indent(state.tabSize)} */\n`;
     });
   }
 
-  handleForEachCode(code: string, forEachStatement: ForEachStatement): string {
+  *handleForEachCode(code: string, forEachStatement: ForEachStatement): Generator<any, string, any> {
     const { item, index, each } = forEachStatement;
     if (code.includes(item.name)) {
-      const eachTSCode = each ? each.toEmbeddedTS() : '__IDENTIFIER__';
+      const eachTSCode = each ? yield* each.toEmbeddedTS() : '__IDENTIFIER__';
       code = this.handleReplaceCode(
         code,
         item.name,
         eachTSCode === '__IDENTIFIER__' ? eachTSCode : `${eachTSCode}.__get(0)`,
       );
     }
-    if (code.includes(index.name)) code = this.handleReplaceCode(code, index.name, 'new nasl.core.Long(0)');
+    if (code.includes(index.name)) {
+      code = this.handleReplaceCode(code, index.name, 'new nasl.core.Long(0)');
+    }
 
     const parentForEachStatement = forEachStatement.getAncestor('ForEachStatement') as ForEachStatement;
     if (parentForEachStatement) {
-      this.handleForEachCode(code, parentForEachStatement);
+      code = yield* this.handleForEachCode(code, parentForEachStatement);
     }
     return code;
   }
 
-  handleMatchCaseCode(code: string, matchCase: MatchCase): string {
+  *handleMatchCaseCode(code: string, matchCase: MatchCase): Generator<any, string, any> {
     const match = matchCase.getAncestor('Match') as Match;
-    const expressionTsCode = match.expression.toEmbeddedTS();
+    const expressionTsCode = yield* match.expression.toEmbeddedTS();
     if (code.includes(expressionTsCode)) {
       let typeCode = '';
-      matchCase.patterns.forEach((pattern, index) => {
+      yield* wrapForEach(matchCase.patterns, function* wrapForEach(pattern, index) {
         if (pattern instanceof TypeAnnotation) {
           if (index === 0) {
-            typeCode += pattern.toEmbeddedTS();
+            typeCode += yield* pattern.toEmbeddedTS();
           } else {
             typeCode += '|';
-            typeCode += pattern.toEmbeddedTS();
+            typeCode += yield* pattern.toEmbeddedTS();
           }
         }
       });
@@ -2285,7 +2261,7 @@ ${indent(state.tabSize)} */\n`;
     }
     const parentMatchCase = match.getAncestor('MatchCase') as MatchCase;
     if (parentMatchCase) {
-      code = this.handleMatchCaseCode(code, parentMatchCase);
+      code = yield* this.handleMatchCaseCode(code, parentMatchCase);
     }
     return code;
   }
@@ -2373,7 +2349,10 @@ ${indent(state.tabSize)} */\n`;
     let _path = '';
     if (this.module) {
       _path = `/${this.module.parentKey}/${this.module.name}`;
-    } else if (this.connector) {
+    }
+    // 由于 getAncestor逻辑变更导致现在在module 上也可以获取 connector ，导致之前的 else if 逻辑失效
+    // 现断层处理
+    if (this.connector) {
       // 自定义连接器 编辑态文件对应parentKey 为 connectors，
       // 稳定态文件对应parentKey 为 dependencies
       // 自定义连接器有分组的概念因此，需要做文件夹处理
@@ -2391,12 +2370,11 @@ ${indent(state.tabSize)} */\n`;
     return `/embedded/${this.app.name}${_path}/logics/${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) {
       console.log(err, `有问题翻译失败:${this.getTsNamespace()}.${this.name}`);
       code += '';
@@ -2480,15 +2458,12 @@ ${indent(state.tabSize)} */\n`;
       const connector: Connector | null = el?.getAncestor?.('Connector') as Connector;
       if (['CallAuthInterface', 'CallInterface'].includes(el?.concept) && connector) {
         const { calleeName } = el as CallInterface;
-        const targetInterface = (connector.interfaces as InterfaceFromExample[]).find(
-          (i) => i.inter.name === calleeName,
-        ) as InterfaceFromExample;
+        const targetInterface = connector.interfaces.find((i) => i.name === calleeName) as Interface;
         if (targetInterface) {
           const refs = await (this.app as any)?.naslServer?._isHaveRef(targetInterface);
           // 如果只有两个引用，则必然为自身以及当前logic引用，需要删除此接口
           if (refs?.length <= 2) {
-            console.log('走到这里了么');
-            targetInterface.deleteInterfaceFromExample();
+            targetInterface.deleteInterface();
           }
         }
       }