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

package/src/concepts/CallLogic__.ts

@@ -1,9 +1,13 @@
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
 import * as JSON5 from 'json5';
 import {
+  TSPPosition,
   TranslatorState,
   shiftState,
   withSourceMap,
   createCompilerState,
+  withSourceMapGenerator,
+  TranslatorGenerator,
   transfromUnionTypeAnnotation,
 } from '../translator';
 import Logic from './Logic__';
@@ -15,7 +19,6 @@ import { config } from '../config';
 import Identifier from './Identifier__';
 import type { ViewElement, ElementToVueOptions } from './ViewElement__';
 import type { MemberExpression } from './MemberExpression__';
-import type { TSPPosition } from '../translator';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -753,8 +756,8 @@ export class CallLogic extends LogicItem {
       code += '$global.';
     }
     const { completeArguments } = this;
-
     if (this.concept === 'CallLogic' && this.getAncestor('BindAttribute')?.name === 'data-source') {
+      let code = '';
       if (this.calleeNamespace) {
         const currentElement = this.getAncestor('ViewElement') as ViewElement;
         code += `__${currentElement.name}_dataSourceLoad`;
@@ -1173,10 +1176,10 @@ export class CallLogic extends LogicItem {
     return Boolean(this.handleError || this.useValidation);
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-
     const {
       handleError,
       calleeKey,
@@ -1190,73 +1193,78 @@ export class CallLogic extends LogicItem {
       useIife,
       useValidation,
       arguments: logicArgs,
-    } = this;
-
+    } = self;
     /** 设置函数范型参数 */
-    const setTypeArguments = () => {
+    const setTypeArguments = function* setTypeArguments() {
       if (Array.isArray(typeArguments) && typeArguments.length) {
         // 如果有内容
         code += `<`;
-        typeArguments.forEach((arg, i, arr) => {
-          code += arg.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
-          if (i !== arr.length - 1) {
-            code += ', ';
-          }
-        });
+        yield *
+          wrapForEach(typeArguments, function* warpForEachGenerator(arg, i, arr) {
+            code += yield* arg.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+            if (i !== arr.length - 1) {
+              code += ', ';
+            }
+          });
         code += `>`;
       }
     };
     /** 设置输入参数 */
-    const setInputParam = () => {
+    const setInputParam = function* setTypeArguments() {
       const paramRequired = ['showMessage', 'consoleLog', 'jsonDeserialize', 'jsonSerialize'].includes(calleeName);
+      if (['expression'].includes(parentKey) && self.getAncestor('BindAttribute')?.name === 'data-source' && (state as any)?.noNeedParams) {
+        return;
+      }
       if (
         (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) ||
         tsCalleeNamespace.startsWith('nasl.')
       ) {
         code += '(';
-        logicArgs.forEach((arg, index) => {
-          // 页面逻辑先都非必填
-          code += arg.toEmbeddedTS(shiftState(state, code), paramRequired);
-          if (index !== logicArgs.length - 1) code += ', ';
-        });
+        yield *
+          wrapForEach(logicArgs, function* warpForEachGenerator(arg, index) {
+            // 页面逻辑先都非必填
+            code += yield* arg.toEmbeddedTS(shiftState(state, code), paramRequired);
+            if (index !== logicArgs.length - 1) code += ', ';
+          });
         code += ')';
       } else if (completeArguments.length) {
         if (
           ['expression'].includes(parentKey) &&
-          this.getAncestor('BindAttribute')?.name === 'data-source' &&
+          self.getAncestor('BindAttribute')?.name === 'data-source' &&
           (state as any)?.noNeedParams
         ) {
           return;
         }
         code += '(';
-        completeArguments.forEach((arg, index) => {
-          // 取到是不是必填放入参数中
-          code += arg.toEmbeddedTS(shiftState(state, code), arg?.paramRequired);
-          if (index !== logicArgs.length - 1) code += ', ';
-        });
+        yield *
+          wrapForEach(completeArguments, function* warpForEachGenerator(arg, index) {
+            // 取到是不是必填放入参数中
+            code += yield* arg.toEmbeddedTS(shiftState(state, code), arg?.paramRequired);
+            if (index !== logicArgs.length - 1) code += ', ';
+          });
         code += ')';
       } else {
         if (
           ['expression'].includes(parentKey) &&
-          this.getAncestor('BindAttribute')?.name === 'data-source' &&
+          self.getAncestor('BindAttribute')?.name === 'data-source' &&
           (state as any)?.noNeedParams
         ) {
           return;
         }
         if (completeArguments.length) {
           code += '(';
-          completeArguments.forEach((arg, index) => {
-            // 取到是不是必填放入参数中
-            code += arg.toEmbeddedTS(shiftState(state, code), arg?.paramRequired);
-            if (index !== logicArgs.length - 1) code += ', ';
-          });
+          yield *
+            wrapForEach(completeArguments, function* warpForEachGenerator(arg, index) {
+              // 取到是不是必填放入参数中
+              code += yield* arg.toEmbeddedTS(shiftState(state, code), arg?.paramRequired);
+              if (index !== logicArgs.length - 1) code += ', ';
+            });
           code += ')';
         } else {
           code += '()';
         }
       }
     };
-
     /** 设置表达式末尾分号 */
     const setEndSemi = () => {
       const { concept: parentConcept } = parentNode ?? {};
@@ -1278,44 +1286,35 @@ export class CallLogic extends LogicItem {
         code += ';';
       }
     };
-
     if (useIife) {
       code += '(() =>{\nconst wrapper = ';
-
       if (handleError) {
         code += 'nasl.util.autoHandleError(';
       }
-
       if (useValidation) {
         code += 'nasl.util.callLogicWithChecker(';
       }
-
       code += calleeKey;
-      setTypeArguments();
-
+      yield* setTypeArguments();
       if (useValidation) {
         code += ', (';
         code += completeArguments.map((item) => item.keyword).join(', ');
         code += ') => {\n';
-        code += validation.toEmbeddedTS(shiftState(state, code));
+        code += yield* validation.toEmbeddedTS(shiftState(state, code));
         code += ';\n})';
       }
-
       if (handleError) {
         code += ')';
       }
-
       code += ';\nreturn wrapper';
-      setInputParam();
+      yield* setInputParam();
       code += ';\n})()';
     } else {
       code += calleeKey;
-      setTypeArguments();
-      setInputParam();
+      yield* setTypeArguments();
+      yield* setInputParam();
     }
-
     setEndSemi();
-
     return code;
   }
 

package/src/concepts/CallQueryComponent__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach, returnOrigin } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import QueryJoinExpression from './QueryJoinExpression__';
 import Entity from './Entity__';
 import Structure from './Structure__';
@@ -999,7 +1009,7 @@ export class CallQueryComponent extends LogicItem {
     };
   }
 
-  toEmbeddedTSOfSubPart<T extends { toEmbeddedTS: (state?: TranslatorState) => string }>(
+  *toEmbeddedTSOfSubPart<T extends { toEmbeddedTS: (state?: TranslatorState) => TranslatorGenerator }>(
     key: string,
     list: Array<T>,
     options: {
@@ -1012,9 +1022,9 @@ export class CallQueryComponent extends LogicItem {
     if (list.length === 0) return code;
 
     code += `${indent((state?.tabSize || 0) + 1)}.${key}(() => `;
-    list.forEach((item, index) => {
+    yield* wrapForEach(list, function* wrapForEach(item, index ) {
       if (index > 0) code += `,\n${indent((state?.tabSize || 0) + 2)}() => `;
-      code += item?.toEmbeddedTS?.(shiftState(state, code, { tabSize: 0 }));
+      code += yield* item?.toEmbeddedTS?.(shiftState(state, code, { tabSize: 0 })) ?? returnOrigin('');
     });
     if (list.length > 1) {
       if (multipleErrorType) code += `,\n${indent((state?.tabSize || 0) + 2)}() => ${multipleErrorType}`;
@@ -1050,113 +1060,105 @@ export class CallQueryComponent extends LogicItem {
     return this.ideVersion === '2.22';
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    if (!this.typeAnnotation)
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    if (!self.typeAnnotation)
       return `(function () {
                 return;
             })()`;
     let code = `(function(): `;
-    if (this.isAutoInfer()) {
-      code += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, code))} {\n`;
+    if (self.isAutoInfer()) {
+      code += `${yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code))} {\n`;
     } else {
       code += `{ list: nasl.collection.List<`;
-      code += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, code))}>, total: nasl.core.Long } {\n`;
+      code += `${yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code))}>, total: nasl.core.Long } {\n`;
     }
     // 2.11版本后 分组使用别名
-    if (this.isAutoInfer()) {
+    if (self.isAutoInfer()) {
       // 分组别名（列别名）
-      this.groupBy.forEach((item, index, array) => {
+      yield* wrapForEach(self.groupBy, function* warpForEachGenerator(item, index, array) {
         code += indent(state.tabSize + 1);
         const groupElement = item.groupElement as QueryFieldExpression;
         if (groupElement.asName) code += `const __${groupElement.asName} = `;
         if (groupElement.propertyName) {
-          code += groupElement.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+          code += yield* groupElement.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
           code += ';\n';
         } else code += `__EMPTY_GROUP_BY_NAME__;\n`;
-
         if (index === array.length - 1) code += '\n';
       });
     }
     // 聚合属性别名
-    this.select.selectAggregateElements.forEach((item, index, array) => {
+    yield* wrapForEach(self.select.selectAggregateElements, function* warpForEachGenerator(item, index, array) {
       code += indent((state?.tabSize || 0) + 1);
       const { asName, aggregateName, aggregateParam } = item;
       if (asName) code += `const __${asName} = `;
       if (aggregateName) {
         code += `nasl.langUtil.${aggregateName}(`;
-        code += aggregateParam.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+        code += yield* aggregateParam.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
         code += ');\n';
       } else code += `__EMPTY_AGGREGATE_NAME__;\n`;
-
       if (index === array.length - 1) code += '\n';
     });
-
-    if (this.from) code += this.from.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+    if (self.from)
+      code += yield* self.from.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
     else code += `${indent((state?.tabSize || 0) + 1)}nasl.langUtil.FROM()\n`;
-
     // where 子句
-    code = this.toEmbeddedTSOfSubPart('WHERE', this.where ? [this.where] : [], {
+    code = yield* self.toEmbeddedTSOfSubPart('WHERE', self.where ? [self.where] : [], {
       code,
       state,
       multipleErrorType: '__WHERE_MULTIPLE_CONDITION__',
     });
-
-    if (this.select.selectAggregateElements.length) {
+    if (self.select.selectAggregateElements.length) {
       // 聚合属性
-      code = this.toEmbeddedTSOfSubPart('SELECT', this.select.selectAggregateElements, {
+      code = yield* self.toEmbeddedTSOfSubPart('SELECT', self.select.selectAggregateElements, {
         code,
         state,
       });
     } else {
       // select实体字段
-      code = this.toEmbeddedTSOfSubPart('SELECT', this.select.selectFieldElements, {
+      code = yield* self.toEmbeddedTSOfSubPart('SELECT', self.select.selectFieldElements, {
         code,
         state,
       });
     }
-
     // 分组属性（Group by）
-    code = this.toEmbeddedTSOfSubPart('GROUP_BY', this.groupBy, {
+    code = yield* self.toEmbeddedTSOfSubPart('GROUP_BY', self.groupBy, {
       code,
       state,
     });
-
     // 聚合属性过滤（Having）
-    code = this.toEmbeddedTSOfSubPart('HAVING', this.having ? [this.having] : [], {
+    code = yield* self.toEmbeddedTSOfSubPart('HAVING', self.having ? [self.having] : [], {
       code,
       state,
       multipleErrorType: '__HAVING_MULTIPLE_CONDITION__',
     });
-
     // 排序规则
-    code = this.toEmbeddedTSOfSubPart('ORDER_BY', this.orderBy, {
+    code = yield* self.toEmbeddedTSOfSubPart('ORDER_BY', self.orderBy, {
       code,
       state,
     });
-
     // 分页参数
-    code = this.toEmbeddedTSOfSubPart('LIMIT', this.limit ? [this.limit] : [], {
+    code = yield* self.toEmbeddedTSOfSubPart('LIMIT', self.limit ? [self.limit] : [], {
       code,
       state,
     });
-
     code += '\n';
     code += `${indent((state?.tabSize || 0) + 1)}return;\n`;
     code += `${indent(state?.tabSize || 0)}})()`;
     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 += ';';
     }

package/src/concepts/Comment__.ts

@@ -1,4 +1,13 @@
-import { TranslatorState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -78,8 +87,9 @@ export class Comment extends LogicItem {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
     code += `\n${indent(state?.tabSize || 0)}
         /**

package/src/concepts/ConfigProperty__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, withSourceMap, createCompilerState, indent } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import type { EmbeddedTSFileGenerator } from '../utils';
+import {
+  TranslatorState,
+  withSourceMap,
+  createCompilerState,
+  indent,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import ConfigGroup from './ConfigGroup__';
 import Namespace from './Namespace__';
 import View from './View__';
@@ -377,21 +387,21 @@ export class ConfigProperty extends BaseNode {
     return `/embedded/${this.app.name}${_path}/configuration/custom/${name}.ts`;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let modifier;
-    if (this.isPrivate) {
+    if (self.isPrivate) {
       modifier = 'private';
     } else {
       modifier = '';
     }
-    let code = `class Custom${this.name} {
-            ${modifier} static FrontEnd${this.name}: nasl.core.String
-            static BackEnd${this.name}: nasl.core.String
+    let code = `class Custom${self.name} {
+            ${modifier} static FrontEnd${self.name}: nasl.core.String
+            static BackEnd${self.name}: nasl.core.String
         };`;
-
-    if (this.parentNode.name === 'custom') {
-      this.values.forEach((value) => {
+    if (self.parentNode.name === 'custom') {
+      yield* wrapForEach(self.values, function* warpForEachGenerator(value) {
         code += indent((state?.tabSize || 0) + 1);
         if (!value.value) {
           code += `const __${value.env}ConfigValueEmpty: any = null;\n`;
@@ -401,12 +411,12 @@ export class ConfigProperty extends BaseNode {
     return code;
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getNamespace()} {\n export `;
 
     const state = createCompilerState(code, { tabSize: 0 });
     try {
-      code += this.toEmbeddedTS(state);
+      code += yield* this.toEmbeddedTS(state);
     } catch (err) {
       code += '';
       console.log(err);

package/src/concepts/Connection__.ts

@@ -1,6 +1,16 @@
+import type { EmbeddedTSFileGenerator } from '../utils';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
 import type { Connector } from './Connector__';
-import { TranslatorState, shiftState, withSourceMap, createCompilerState, indent } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  createCompilerState,
+  indent,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -395,12 +405,12 @@ export class Connection extends BaseNode {
     return 'app.connections';
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getTsNamespace()} {\n`;
 
     const state = createCompilerState(code, { tabSize: 1 });
     try {
-      code += this.toEmbeddedTS(state);
+      code += yield* this.toEmbeddedTS(state);
     } catch (err) {
       console.log(err, '有问题翻译失败');
       code += '';
@@ -414,10 +424,16 @@ export class Connection extends BaseNode {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, prependCode?: string, noName?: boolean, prefix?: boolean): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(
+    state = createCompilerState(),
+    prependCode?: string,
+    noName?: boolean,
+    prefix?: boolean,
+  ): TranslatorGenerator {
+    const self = this;
     let code = '';
-    code += `export function ${this.tsName}<T extends (...args: any[]) => any>(`;
+    code += `export function ${self.tsName}<T extends (...args: any[]) => any>(`;
     code += 'cb: T';
     code += `): ReturnType<T> {\n`;
     code += '\n';

package/src/concepts/Connector__.ts

@@ -228,7 +228,7 @@ export class Connector extends Module {
    */
   constructor(source?: Partial<Connector>) {
     source = Object.assign({}, Connector.getDefaultOptions(), source);
-    super(source as any);
+    super(source);
     super.subConstructor(source);
   }
 

package/src/concepts/Constant__.ts

@@ -1,4 +1,13 @@
-import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -299,29 +308,30 @@ export class Constant extends BaseNode {
     return this.name;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    let code = this.name;
-    if (this.typeAnnotation) {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = self.name;
+    if (self.typeAnnotation) {
       code += ': ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      code += yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code));
     }
     if (
       this.defaultValue?.expression &&
-      !['__IDENTIFIER__', '__IDENTIFIER__()'].includes(this.defaultValue?.toEmbeddedTS())
+      !['__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;
   }
 
-  @withSourceMap()
-  toEmbeddedTSInProcess(state?: TranslatorState): string {
+  @withSourceMapGenerator
+  *toEmbeddedTSInProcess(state = createCompilerState()): TranslatorGenerator {
     let code = this.name;
     if (this.typeAnnotation) {
       code += `: `;
@@ -332,15 +342,15 @@ export class Constant extends BaseNode {
           ['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(this.typeAnnotation.typeKey)
         )
       ) {
-        code += `${this.defaultValue.toEmbeddedTS(shiftState(state, code))}`;
+        code += `${yield* this.defaultValue.toEmbeddedTS(shiftState(state, code))}`;
       } else {
         if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(this.typeAnnotation?.typeKey)) {
-          code += this.defaultValue.toEmbeddedTS(shiftState(state, code), true);
+          code += yield* this.defaultValue.toEmbeddedTS(shiftState(state, code), true);
         }
         code += 'undefined';
       }
       code += ' as ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      code += yield* this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
     }
     return code;
   }

package/src/concepts/DataSource__.ts

@@ -1,4 +1,12 @@
-import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
+import type { EmbeddedTSFileGenerator } from '../utils';
+import {
+  TranslatorState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import datasourceService from '../service/datasource';
 
 //================================================================================
@@ -438,21 +446,22 @@ export class DataSource extends BaseNode {
     return `/embedded/${this.rootNode?.name ?? this.parentNode.name}/datasources/${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.error(err);