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

package/src/concepts/Frontend__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import type { EmbeddedTSFileGenerator } from '../utils';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { AssetsInfo } from './App__';
 import Namespace from './Namespace__';
 import { languageList } from '../utils/i18nInfo';
@@ -1296,21 +1306,22 @@ export class Frontend extends BaseNode {
     return `/embedded/${this.rootNode?.name || this.parentNode.name}/frontends/${name}.ts`;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    let code = `export namespace ${this.name} {\n`;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = `export namespace ${self.name} {\n`;
     code += 'const name = ';
-    code += `"${this.name}";\n`;
+    code += `"${self.name}";\n`;
     code += '}\n';
     return code;
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getNamespace()} {\n`;
 
     const state = createCompilerState(code, { tabSize: 1 });
     try {
-      code += this.toEmbeddedTS(state);
+      code += yield* this.toEmbeddedTS(state);
     } catch (err) {
       code += '';
       console.log(err);

package/src/concepts/Function__.ts

@@ -1,5 +1,15 @@
+import { wrapForEachToGenerator as wrapForEach, returnOrigin } from '../utils/time-slicing';
 import Namespace from './Namespace__';
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import asyncFuncMap from '../common/asyncFuncMap';
 
@@ -1109,32 +1119,29 @@ export class Function extends BaseNode {
     throw new Error('无法获取命名空间，请设置 parentNode！');
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-    if (this.returnExpression) {
+    if (self.returnExpression) {
       code += `(`;
-      this.params.forEach((param, index) => {
-        code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        if (index !== this.params.length - 1) code += ', ';
+      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 += `)`;
-      if (this.returns.length) {
+      if (self.returns.length) {
         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 += ` => (`;
-
-      if (this.returnExpression) {
-        code +=
-          this.returnExpression.toEmbeddedTS &&
-          this.returnExpression.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+      if (self.returnExpression?.toEmbeddedTS) {
+        code += yield* self.returnExpression.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
       }
       code += `${indent(state.tabSize)})`;
     } else {
       code += '__IDENTIFIER__';
     }
-
     return code;
   }
 
@@ -1199,15 +1206,17 @@ export class Function extends BaseNode {
     return code;
   }
 
-  toEmbeddedTSDefinition(state?: TranslatorState): string {
+  @withGenerator
+  *toEmbeddedTSDefinition(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '(';
-    this.params.forEach((param, index) => {
-      code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
-      if (index !== this.params.length - 1) code += ', ';
+    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 += `) => (`;
-    if (this.returns.length) {
-      code += this.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+    if (self.returns.length) {
+      code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
     } else {
       code += 'any';
     }

package/src/concepts/Identifier__.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 { BindAttribute, CallLogic, TypeAnnotation } from '..';
 import { ElementToVueOptions } from './ViewElement__';
 import { findConceptKeyWordByNamespace } from '../utils';
@@ -73,10 +81,10 @@ export class Identifier extends LogicItem {
   globalDataMap: {
     [name: string]: boolean;
   } = {
-    $route: true,
-    $global: true,
-    $refs: true,
-  };
+      $route: true,
+      $global: true,
+      $refs: true,
+    };
 
   isEnum() {
     return findConceptKeyWordByNamespace(this.namespace) === 'enums';
@@ -85,13 +93,6 @@ export class Identifier extends LogicItem {
   toVue(options?: ElementToVueOptions): string {
     let { name } = this;
     const { namespace } = this;
-    if (
-      this?.parentNode?.parentKey === 'bindAttrs' &&
-      ['decimalLength', 'decimal-length'].includes(this?.parentNode?.name) &&
-      name === 'undefined'
-    ) {
-      name = undefined;
-    }
     if (namespace) {
       if (
         this.namespace.endsWith('nasl.browser') ||
@@ -207,27 +208,26 @@ export class Identifier extends LogicItem {
     return this.name || '-';
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState(), options?: any): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), options?: any): TranslatorGenerator {
+    const self = this;
     // new实体，连线修改实体字段，无法同步到new实体的字段上，因为解构赋值后的property查找不回去，所以改成obj.
     if (options?.isNewcomposite) {
       return `__obj.${this.name}`;
     }
     // 只有data-source可以是函数 ，也可能是属性
-    if (this.parentNode instanceof BindAttribute && this.parentNode.name === 'data-source') {
-      const { view } = this;
+    if (self.parentNode instanceof BindAttribute && self.parentNode.name === 'data-source') {
+      const { view } = self;
       const viewLogics = view.logics;
-      const findLogic = viewLogics.find((item) => item.name === this.name);
+      const findLogic = viewLogics.find((item) => item.name === self.name);
       if (findLogic) {
-        return this.name;
+        return self.name;
       }
     }
-
     // 全局变量在不是页面的地方放置，就会报错
-    if (this.namespace?.startsWith('app.frontends') && this.namespace?.endsWith('variables') && !this.frontend) {
+    if (self.namespace?.startsWith('app.frontends') && self.namespace?.endsWith('variables') && !self.frontend) {
       return '__FRONTENDVARIABLES__';
     }
-
     // 如果是nasl.util.Enum 的子集里的 Identifier > MemberExpression > Argument > callfunction
     // nasl.util.Enum 的 右侧是转成字符串的
     // 如果是identifier 而且枚举
@@ -239,28 +239,26 @@ export class Identifier extends LogicItem {
     //         return str.includes('.enums.') ? str : str + '.toString()';
     //     }
     // }
-
     // having 下选择的变量不生成 namespace 前缀
-    if (this.namespace === 'inner' && this.getAncestor('CallQueryComponent')) {
-      return `__${this.name}` || '__IDENTIFIER__';
+    if (self.namespace === 'inner' && self.getAncestor('CallQueryComponent')) {
+      return `__${self.name}` || '__IDENTIFIER__';
     }
-    const logicAncestor = this.getAncestor('CallLogic') as CallLogic;
-
+    const logicAncestor = self.getAncestor('CallLogic') as CallLogic;
     if (
       logicAncestor &&
       logicAncestor.calleeName === 'getCustomConfig' &&
       logicAncestor.calleeNamespace === 'nasl.configuration'
     ) {
-      if (this.view) {
-        return this.namespace
-          ? `${this.namespace}.Custom${this.name}.FrontEnd${this.name}`
-          : this.name || '__IDENTIFIER__';
+      if (self.view) {
+        return self.namespace
+          ? `${self.namespace}.Custom${self.name}.FrontEnd${self.name}`
+          : self.name || '__IDENTIFIER__';
       }
-      return this.namespace
-        ? `${this.namespace}.Custom${this.name}.BackEnd${this.name}`
-        : this.name || '__IDENTIFIER__';
+      return self.namespace
+        ? `${self.namespace}.Custom${self.name}.BackEnd${self.name}`
+        : self.name || '__IDENTIFIER__';
     }
-    return this.namespace ? `${this.namespace}.${this.name}` : this.name || '__IDENTIFIER__';
+    return self.namespace ? `${self.namespace}.${self.name}` : self.name || '__IDENTIFIER__';
   }
 
   // 方便快速取值

package/src/concepts/IfStatement__.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 自动生成，请不手动修改！
@@ -438,35 +448,33 @@ export class IfStatement extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
     code += 'if (nasl.core.ensureBoolean(';
-    code += this.test
-      ? this.test.toEmbeddedTS(
+    code += self.test
+      ? yield* self.test.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: 0,
           }),
         )
       : '__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,
           }),
         )};\n`;
       });
     }
-
     code += `${indent(state?.tabSize || 0)}}`;
-    if (Array.isArray(this.alternate)) {
+    if (Array.isArray(self.alternate)) {
       code += ' else {\n';
-      this.alternate.forEach((logicItem) => {
-        code += `${logicItem.toEmbeddedTS(
+      yield* wrapForEach(self.alternate, function* warpForEachGenerator(logicItem) {
+        code += `${yield* logicItem.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: (state?.tabSize || 0) + 1,
           }),

package/src/concepts/ImportedInterface__.ts

@@ -0,0 +1,61 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, className } from '../decorators';
+
+import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
+import BaseNode from '../common/BaseNode';
+import AbstractInterface from './AbstractInterface__';
+
+/**
+ * 由JSON生成接口
+ */
+@className
+@concept('由JSON生成接口')
+// @ts-ignore
+export abstract class ImportedInterface extends AbstractInterface {
+  /** 类名 */
+  static readonly ConceptName = 'ImportedInterface';
+
+  /** 继承链 */
+  static readonly inheritanceChain = ['AbstractInterface', 'BaseNode'];
+
+  /**
+   * exampleMap
+   */
+  @property()
+  // @ts-ignore
+  exampleMap!: Map<'responseBody' | 'requestBody', string>;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<ImportedInterface>) {
+    source = Object.assign({}, ImportedInterface.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): ImportedInterface {
+    return super.from(source, parentNode, parentKey) as ImportedInterface;
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default ImportedInterface;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/InterfaceParam__.ts

@@ -1,5 +1,14 @@
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
 import { dataTypesMap } from './basics/types';
-import { TranslatorState, shiftState, withSourceMap } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+  createCompilerState,
+} from '../translator';
 import StructureProperty from './StructureProperty__';
 import Structure from './Structure__';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
@@ -24,7 +33,6 @@ import View from './View__';
 import Frontend from './Frontend__';
 import ProcessElement from './ProcessElement__';
 import Process from './Process__';
-import InterfaceFromExample from './InterfaceFromExample__';
 
 /**
  * 接口参数
@@ -140,12 +148,6 @@ export class InterfaceParam extends BaseNode {
   get process() {
     return this.getAncestor('Process') as Process;
   }
-  /**
-   * 祖先 InterfaceFromExample
-   */
-  get interfaceFromExample() {
-    return this.getAncestor('InterfaceFromExample') as InterfaceFromExample;
-  }
 
   /**
    * @param source 需要合并的部分参数
@@ -376,25 +378,26 @@ export class InterfaceParam extends BaseNode {
     return !!this.module;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, isOptionalParameter?: boolean): string {
-    let code = this.tsName;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), isOptionalParameter?: boolean): TranslatorGenerator {
+    const self = this;
+    let code = self.tsName;
     if (isOptionalParameter) {
       code += '?';
     }
-    if (this.typeAnnotation) {
+    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())
+      !['__IDENTIFIER__', '__IDENTIFIER__()'].includes(yield* this.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);
+        code += yield* this.defaultValue.toEmbeddedTS(shiftState(state, code), true);
       } else {
         code += ` = `;
-        code += this.defaultValue.toEmbeddedTS(shiftState(state, code));
+        code += yield* this.defaultValue.toEmbeddedTS(shiftState(state, code));
       }
     }
     return code;

package/src/concepts/Interface__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import type { EmbeddedTSFileGenerator } from '../utils';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import Namespace from './Namespace__';
 import TypeAnnotation from './TypeAnnotation__';
 import Structure from './Structure__';
@@ -19,13 +29,12 @@ import Return from './Return__';
 import BindAttribute from './BindAttribute__';
 import Module from './Module__';
 import Connector from './Connector__';
-import InterfaceFromExample from './InterfaceFromExample__';
 import App from './App__';
 import View from './View__';
 import Frontend from './Frontend__';
 import ProcessElement from './ProcessElement__';
 import Process from './Process__';
-import AbstractInterface from './AbstractInterface__';
+import ImportedInterface from './ImportedInterface__';
 
 /**
  * 接口
@@ -33,19 +42,19 @@ import AbstractInterface from './AbstractInterface__';
 @className
 @concept('接口')
 // @ts-ignore
-export class Interface extends AbstractInterface {
+export class Interface extends ImportedInterface {
   /** 类名 */
   static readonly ConceptName = 'Interface';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['AbstractInterface', 'BaseNode'];
+  static readonly inheritanceChain = ['ImportedInterface', 'AbstractInterface', 'BaseNode'];
 
   /**
    * 产品概念
    */
   @property('concept')
   // @ts-ignore
-  readonly concept!: 'Interface' | 'AuthInterface';
+  readonly concept!: 'Interface';
 
   /**
    * 接口名称
@@ -153,12 +162,6 @@ export class Interface extends AbstractInterface {
   get process() {
     return this.getAncestor('Process') as Process;
   }
-  /**
-   * 祖先 InterfaceFromExample
-   */
-  get interfaceFromExample() {
-    return this.getAncestor('InterfaceFromExample') as InterfaceFromExample;
-  }
 
   /**
    * @param source 需要合并的部分参数
@@ -851,12 +854,12 @@ export class Interface extends AbstractInterface {
     });
   }
 
-  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);
@@ -887,10 +890,8 @@ export class Interface extends AbstractInterface {
     // 稳定态文件对应parentKey 为 dependencies
     // 连接器相关的接口，本身没有 module 属性故，需要额外处理
 
-    // 2023/11/08 由于新引入了一种 InterfaceFromExample 类型，故这里 parentNode 不在是
-    // Connector，为了保证使用旧逻辑，这里选择直接获取祖先节点。
-    if (this.connector) {
-      return `/embedded/${this.app.name}/${this.connector.parentKey}/${this.connector.name}/interfaces/${name}.ts`;
+    if (this.parentNode.concept === 'Connector') {
+      return `/embedded/${this.app.name}/${this.parentNode.parentKey}/${this.parentNode.name}/interfaces/${name}.ts`;
       ``;
     }
     const _path = this.module ? `/${this.module.parentKey}/${this.module.name}` : '';
@@ -983,81 +984,76 @@ export class Interface extends AbstractInterface {
     return this.name;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     // 是否含有 Module 相关的祖先节点，相关均不会翻译出 let logic =xxx;
     const hasModuleLikeAncestor = !!(this.module || this.connector);
-
     let code = '';
-    const getCheckerCode = () => {
-      if (this.validation) {
+    const getCheckerCode = function* getCheckerCode() {
+      if (self.validation) {
         code += '\n(';
-        code += this.validation.toEmbeddedTS(shiftState(state, code));
+        code += yield * self.validation.toEmbeddedTS(shiftState(state, code));
         code += ');\n';
       }
     };
-
-    code += `export function ${this.tsName}(`;
-    this.params.forEach((param, index) => {
+    code += `export function ${self.tsName}(`;
+    yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
       if (index === 0) {
         code += '{';
       }
       code += param.tsName;
-      if (index !== this.params.length - 1) {
+      if (index !== self.params.length - 1) {
         code += ', ';
       } else {
         code += '}:';
       }
     });
-    this.params.forEach((param, index) => {
+    yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
       if (index === 0) {
         code += '{';
       }
-      code += param.toEmbeddedTS(shiftState(state, code), !(param as InterfaceParam).required);
-      if (index !== this.params.length - 1) {
+      code += yield* param.toEmbeddedTS(shiftState(state, code), !(param as InterfaceParam).required);
+      if (index !== self.params.length - 1) {
         code += ', ';
       } else {
         code += '}';
       }
     });
     code += `):`;
-
-    if (this.returns && this.returns.length > 0) {
-      this.returns.forEach((ret) => {
-        code += ret.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+    if (self.returns && self.returns.length > 0) {
+      yield* wrapForEach(self.returns, function* warpForEachGenerator(ret) {
+        code += yield* ret.typeAnnotation.toEmbeddedTS(shiftState(state, code));
       });
-
       code += '{\n';
-      getCheckerCode();
+      yield* getCheckerCode();
       code += hasModuleLikeAncestor
         ? ''
-        : `let logic =${(this.parentNode as Namespace).getTsNamespace()}.logics.${this.originLogicName};\n`;
+        : `let logic =${(self.parentNode as Namespace).getTsNamespace()}.logics.${self.originLogicName};\n`;
       code += 'let ';
-      code += this.returns[0].toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* self.returns[0].toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += ';\n';
       code += `return `;
-      code += this.returns[0].tsName || '__return;';
+      code += self.returns[0].tsName || '__return;';
       code += '\n }';
     } else {
       code += 'void {\n';
-      getCheckerCode();
+      yield* getCheckerCode();
       code += hasModuleLikeAncestor
         ? ''
-        : `let logic =${(this.parentNode as Namespace).getTsNamespace()}.logics.${this.originLogicName};\n`;
+        : `let logic =${(self.parentNode as Namespace).getTsNamespace()}.logics.${self.originLogicName};\n`;
       code += '};';
     }
     code += '\n';
     return code;
   }
 
-  getNamespace() {
+  getNamespace(): string {
     // 针对 Connector 下的 Interface 需要做额外的兼容处理
     // 本来 Connector 对应的 Namespace 是 connector，走默认逻辑就成
     // 但是后端在翻译 Connector 下的 Interface 时选择的前缀为 extensions 故这里
-    // 2023/11/08 由于新引入了一种 InterfaceFromExample 类型，故这里 parentNode 不在是
-    // Connector，为了保证使用旧逻辑，这里选择直接获取祖先节点。
-    if (this.connector) {
-      return `extensions.${this.connector.name}.interfaces`;
+    if (this.parentNode?.concept === 'Connector') {
+      return `extensions.${this.parentNode.name}.interfaces`;
     }
     if (this.parentNode && (this.parentNode as Namespace).getNamespace) {
       const parentNamespace = (this.parentNode as Namespace).getNamespace();
@@ -1075,10 +1071,8 @@ export class Interface extends AbstractInterface {
     // 针对 Connector 下的 Interface 需要做额外的兼容处理
     // 本来 Connector 对应的 Namespace 是 connector，走默认逻辑就成
     // 但是后端在翻译 Connector 下的 Interface 时选择的前缀为 extensions 故这里需要强行改成 extensions
-    // 2023/11/08 由于新引入了一种 InterfaceFromExample 类型，故这里 parentNode 不在是
-    // Connector，为了保证使用旧逻辑，这里选择直接获取祖先节点。
-    if (this.connector) {
-      return `extensions.${this.connector.tsName}.interfaces`;
+    if (this.parentNode?.concept === 'Connector') {
+      return `extensions.${this.parentNode.tsName}.interfaces`;
     }
     if (this.parentNode && (this.parentNode as Namespace).getTsNamespace) {
       const parentNamespace = (this.parentNode as Namespace).getTsNamespace();