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

package/src/concepts/App__.ts

@@ -1,4 +1,8 @@
 import { queryNodeByPath } from '../service/storage/jsoner';
+import {
+  withSourceMap,
+  createCompilerState,
+} from '../translator';
 import { getNaslNodeByNodeCallee, getNodeByNodeCallee } from '../automate/engine/utils';
 import type ConfigProperty from './ConfigProperty__';
 import type TypeAnnotation from './TypeAnnotation__';
@@ -4428,16 +4432,20 @@ export class App extends BaseNode {
   }
 
   getExtensionsCallbackLogics() {
-    let resultLogics: string[] = [];
+    const resultLogics: Set<string> = new Set();
     this.frontendTypes.forEach((frontendType) => {
       frontendType?.frontends?.forEach((frontend) => {
-        resultLogics = [...resultLogics, ...frontend.getExtensionsCallbackLogics()];
+        frontend.getExtensionsCallbackLogics().forEach((logic) => {
+          resultLogics.add(logic);
+        })
       });
       frontendType?.businessComponents?.forEach((businessComponent) => {
-        resultLogics = [...resultLogics, ...(businessComponent?.getViewCallLogics?.() || [])];
+        (businessComponent?.getViewCallLogics?.() || []).forEach((logic) => {
+          resultLogics.add(logic);
+        })
       });
     });
-    return Array.from(new Set(resultLogics));
+    return Array.from(resultLogics);
   }
 
   getJavaLogicUniqueName(name = 'javalogic1') {
@@ -5389,6 +5397,98 @@ export class App extends BaseNode {
   //   });
   // }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    let code = '';
+
+    this.dependencies?.forEach((dep) => {
+      code += dep.toNaturalTS(state) + '\n\n';
+    });
+
+    this.interfaceDependencies?.forEach((dep) => {
+      code += dep.toNaturalTS(state) + '\n\n';
+    });
+
+    this.dataSources?.forEach((dataSource) => {
+      code += dataSource.toNaturalTS(state) + '\n';
+    });
+    this.structures?.forEach((structure) => {
+      code += structure.toNaturalTS(state) + '\n';
+    });
+    this.enums?.forEach((enumeration) => {
+      code += enumeration.toNaturalTS(state) + '\n';
+    });
+    this.metadataTypes?.forEach((metadataType) => {
+      code += metadataType.toNaturalTS(state) + '\n';
+    });
+    if (this.metadataTypes.length)
+      code += '\n';
+    this.logics?.forEach((logic) => {
+      code += logic.toNaturalTS(state) + '\n\n';
+    });
+    this.overriddenLogics?.forEach((logic) => {
+      code += logic.toNaturalTS(state) + '\n\n';
+    });
+    this.interfaces?.forEach((inter) => {
+      code += inter.toNaturalTS(state) + '\n';
+    });
+    this.roles?.forEach((role) => {
+      code += role.toNaturalTS(state) + '\n';
+    });
+    this.frontendTypes?.forEach((frontendType, index) => {
+      code += frontendType.toNaturalTS(state);
+      if (index !== this.frontendTypes.length - 1)
+        code += '\n';
+    });
+
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = '';
+
+    this.dependencies?.forEach((dep) => {
+      code += dep.toTextualNASL(state) + '\n';
+    });
+
+    this.interfaceDependencies?.forEach((dep) => {
+      code += dep.toTextualNASL(state) + '\n';
+    });
+
+    this.dataSources?.forEach((dataSource) => {
+      code += dataSource.toTextualNASL(state) + '\n';
+    });
+    this.structures?.forEach((structure) => {
+      code += structure.toTextualNASL(state) + '\n';
+    });
+    this.enums?.forEach((enumeration) => {
+      code += enumeration.toTextualNASL(state) + '\n';
+    });
+    this.metadataTypes?.forEach((metadataType) => {
+      code += metadataType.toTextualNASL(state) + '\n';
+    });
+    this.logics?.forEach((logic) => {
+      code += logic.toTextualNASL(state) + '\n\n';
+    });
+    this.overriddenLogics?.forEach((logic) => {
+      code += logic.toTextualNASL(state) + '\n\n';
+    });
+    this.interfaces?.forEach((inter) => {
+      code += inter.toTextualNASL(state) + '\n';
+    });
+    this.roles?.forEach((role) => {
+      code += role.toTextualNASL(state) + '\n';
+    });
+    this.frontendTypes?.forEach((frontendType, index) => {
+      code += frontendType.toTextualNASL(state);
+      if (index !== this.frontendTypes.length - 1)
+        code += '\n';
+    });
+
+    return code;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Argument__.ts

@@ -220,7 +220,7 @@ export class Argument extends LogicItem {
       // if ((this.expression as StringLiteral).name === 'ListDistinctByTargetDefaultExpression') {
       //   code += runSync((this.expression as NewList).toEmbeddedIgnoreTS(shiftState(state, code)));
       // } else {
-      code += (this.expression as StringLiteral).toNaturalTS(shiftState(state, code), isRequired);
+      code += (this.expression as StringLiteral).toNaturalTS(shiftState(state, code, { inline: true }), isRequired);
       // }
     } else {
       code += isRequired ? '__IDENTIFIER__' : 'undefined';
@@ -235,13 +235,13 @@ export class Argument extends LogicItem {
   toTextualNASL(state = createCompilerState(), isRequired: boolean = true, isHaveKeyWord?: boolean): string {
     let code = this.spread ? '...' : '';
     if (isHaveKeyWord) {
-      code += `${this.tsKeyword}:`;
+      code += `${this.tsKeyword} = `;
     }
     if (this.expression) {
       // if ((this.expression as StringLiteral).name === 'ListDistinctByTargetDefaultExpression') {
       //   code += runSync((this.expression as NewList).toEmbeddedIgnoreTS(shiftState(state, code)));
       // } else {
-      code += this.expression.toTextualNASL(shiftState(state, code));
+      code += this.expression.toTextualNASL(shiftState(state, code, { inline: true }));
       // }
     } else {
       code += isRequired ? '__IDENTIFIER__' : 'undefined';

package/src/concepts/BatchAssignment__.ts

@@ -526,7 +526,7 @@ export class BatchAssignment extends LogicItem {
   }
 
   // 自动连线算法---addRightIndex : 指右边选择变量后对该selectmember进行自动连线。
-  async batchAutoConnection(addRightIndex?: number) {
+  batchAutoConnection(addRightIndex?: number) {
     const leftLineSet = new Set();
     const lineArr: Array<AssignmentLine> = [];
     const AssignmentLine = getConceptConstructor('AssignmentLine');
@@ -560,7 +560,7 @@ export class BatchAssignment extends LogicItem {
         this.rights.forEach((selectMember, rightFirstIndex) => {
           const { members, expression } = selectMember;
           if (leftLineSet.has(leftSecondIndex)) return;
-          if (addRightIndex !== -1 && addRightIndex !== rightFirstIndex) return;
+          if (![-1, null, undefined].includes(addRightIndex) && addRightIndex !== rightFirstIndex) return;
           // 右侧父节点也不允许自动连线
           const rightLineSet = new Set();
           for (let i = 0; i < members.length - 1; i++) {

package/src/concepts/BindAttribute__.ts

@@ -909,10 +909,9 @@ export class BindAttribute extends BaseNode {
             } else {
               code = value.replace(/['"`\\]/g, (m) => {
                 let escape = '\\\\';
-                escape = '\\\\';
-                /// #if process.env.BUILD_TARGET === 'node'
-                escape = '\\';
-                /// #endif
+                if (options?.isGeneratorExport) {
+                  escape = '\\';
+                }
                 if (m === '\\') {
                   return `${escape}${escape}`;
                 }

package/src/concepts/BindDirective__.ts

@@ -486,10 +486,9 @@ export class BindDirective extends BaseNode {
     if (this.type === 'string') {
       value = value.replace(/['"`\\]/g, (m) => {
         let escape = '\\\\';
-        escape = '\\\\';
-        /// #if process.env.BUILD_TARGET === 'node'
-        escape = '\\';
-        /// #endif
+        if (options?.isGeneratorExport) {
+          escape = '\\';
+        }
         if (m === '\\') {
           return `${escape}${escape}`;
         }

package/src/concepts/BusinessComponent__.ts

@@ -4,7 +4,7 @@ import {
   returnOrigin,
 } from '../utils/time-slicing';
 import type { EmbeddedTSFileGenerator } from '../utils';
-import { shiftState, indent, createCompilerState, withSourceMapGenerator, TranslatorGenerator } from '../translator';
+import { shiftState, indent, createCompilerState, withSourceMapGenerator, TranslatorGenerator, withSourceMap, createDecoratorCode } from '../translator';
 import type Assignment from './Assignment__';
 import type BatchAssignment from './BatchAssignment__';
 import type CallFunction from './CallFunction__';
@@ -2475,6 +2475,59 @@ export class BusinessComponent extends BaseNode {
     });
     return callbackLogics;
   }
+
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    let code = `export namespace ${this.name} {\n`;
+    // this.businessComponents.forEach((component) => {
+    //   this.frontends.forEach((frontend) => {
+    //     code += frontend.toNaturalTS(state);
+    //     code += '\n';
+    //   });
+    // });
+    code += '}';
+
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = '';
+    
+    code += createDecoratorCode(state, this, ['title', 'description']);
+
+    code += `viewComponent ${this.name}`;
+    
+    code += `(\n`;
+    this.params.forEach((param, index) => {
+      code += param.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+      code += ',\n';
+    });
+    this.events.forEach((event, index) => {
+      code += event.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+      code += ',\n';
+    });
+    code += ') {\n';
+
+    this.variables.forEach((variable) => {
+      code += `${indent(state.tabSize + 1)}let `;
+      code += variable.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1, inline: true }));
+      code += ';\n';
+    });
+    if (this.variables.length) code += '\n';
+
+    this.logics.forEach((logic) => {
+      code += logic.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+      code += '\n';
+    });
+    if (this.logics.length) code += '\n';
+    
+    code += this.elements[0].toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+
+    code += `\n${indent(state.tabSize)}}`;
+
+    return code;
+  }
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/BusinessLogic__.ts

@@ -4,7 +4,7 @@ import {
   returnOrigin,
 } from '../utils/time-slicing';
 import { waitOqlQueryComponentChildrenFinish } from '../common';
-import { shiftState, indent, createCompilerState, withSourceMapGenerator, TranslatorGenerator } from '../translator';
+import { shiftState, indent, createCompilerState, withSourceMapGenerator, TranslatorGenerator, withSourceMap } from '../translator';
 import { Variable } from './Variable__';
 import { Return } from './Return__';
 import { Assignment } from './Assignment__';
@@ -477,6 +477,15 @@ export class BusinessLogic extends Logic {
     return code;
   }
 
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = '';
+    if (this.isPublic)
+      code += 'public ';
+    code += super.toTextualNASL(state).trimStart();
+    return code;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/CallEvent__.ts

@@ -5,6 +5,8 @@ import {
   createCompilerState,
   withSourceMapGenerator,
   TranslatorGenerator,
+  indent,
+  withSourceMap,
 } from '../translator';
 import type Event from './Event__';
 import type Param from './Param__';
@@ -305,6 +307,70 @@ export class CallEvent extends LogicItem {
     code += '\n})';
     return code;
   }
+
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    let code = '';
+    code = 'on' + utils.firstUpperCase(this.calleeName);
+    if (this.arguments.length <= 3) {
+      code += '(';
+      this.arguments.forEach((arg, index) => {
+        if (!arg) {
+          code += '__IDENTIFIER__';
+        } else {
+          code += arg.toNaturalTS(shiftState(state, code, { inline: true }));
+        }
+        if (index !== this.arguments.length - 1) code += ', ';
+      });
+      // if (this?.typeArguments?.[0]?.typeKind === 'reference') {
+      //   if (this.arguments?.length > 0) code += ', ';
+      //   code += `{ typeNamespace: '${this.typeArguments[0].typeNamespace}' }`;
+      // }
+      code += `)`;
+    } else {
+      code += '(\n';
+      this.arguments.forEach((arg, index) => {
+        if (!arg) {
+          code += '__IDENTIFIER__';
+        } else {
+          code += indent(state.tabSize + 1) + arg.toNaturalTS(shiftState(state, code, { inline: true, tabSize: state.tabSize + 1 }));
+        }
+        if (index !== this.arguments.length - 1) {
+          code += ',\n';
+        } else {
+          code += '\n';
+        }
+      });
+      code += `${indent(state.tabSize)})`;
+    }
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = '';
+    code = 'on' + utils.firstUpperCase(this.calleeName);
+    if (this.arguments.length <= 3) {
+      code += '(';
+      this.arguments.forEach((arg, index) => {
+        code += arg.toTextualNASL(shiftState(state, code, { inline: true }));
+        if (index !== this.arguments.length - 1) code += ', ';
+      });
+      code += `)`;
+    } else {
+      code += '(\n';
+      this.arguments.forEach((arg, index) => {
+        code += arg.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+        if (index !== this.arguments.length - 1) {
+          code += ',\n';
+        } else {
+          code += '\n';
+        }
+      });
+      code += `${indent(state.tabSize)})`;
+    }
+    return code;
+  }
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/CallInterface__.ts

@@ -7,6 +7,8 @@ import {
   withSourceMapGenerator,
   withGenerator,
   TranslatorGenerator,
+  textualNamespace,
+  indent,
 } from '../translator';
 import type Interface from './Interface__';
 import { ElementToVueOptions } from './ViewElement__';
@@ -476,19 +478,29 @@ export class CallInterface extends LogicItem {
 
     let code = `${tsCalleeKey}(`;
 
-    if (completeArguments?.length) {
-      code += '{ ';
-      completeArguments?.forEach((arg, index) => {
+      code += '{\n';
+      this.completeArguments?.forEach((arg, index) => {
         if (!arg) {
-          code += '__IDENTIFIER__: undefined';
+          code += '__IDENTIFIER__: undefined,\n';
         } else {
-          code += arg.toNaturalTS(shiftState(state, code), arg.paramRequired, true);
+          code += arg.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }), arg.paramRequired, true) + ',\n';
         }
-        if (index !== this.arguments?.length - 1) code += ', ';
       });
-      code += ' }';
-    }
-    code += ')';
+      code += `${indent(state.tabSize)}})`;
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = `${textualNamespace(this.tsCalleeKey)}(\n`;
+    this.completeArguments.forEach((arg, index) => {
+      if (!arg) {
+        code += '__IDENTIFIER__ = null,\n';
+      } else {
+        code += arg.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }), arg.paramRequired, true) + ',\n';
+      }
+    });
+    code += `${indent(state.tabSize)})`;
     return code;
   }
 

package/src/concepts/CallLogic__.ts

@@ -14,6 +14,7 @@ import {
 import type Logic from './Logic__';
 import type Param from './Param__';
 import type View from './View__';
+import type BusinessComponent from './BusinessComponent__';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 import { findConceptKeyWordIndexFromNamespace } from '../utils';
 import {
@@ -668,7 +669,7 @@ export class CallLogic extends LogicItem {
         for (let i = 0; i < currentIndex; i++) {
           currentParamList.push(`,current${i === 0 ? '' : i}`);
         }
-        code += `(params)=>__${currentElement.name}_handleDataSourceLoad(params${currentParamList.join('')})`;
+        code += `$global.useDatabaseCallback()(__${currentElement.name}_handleDataSourceLoad${currentParamList.join('')})`
         return code;
       }
       if (calleeName === 'jsonSerialize') {
@@ -1576,8 +1577,62 @@ export class CallLogic extends LogicItem {
     return code;
   }
 
+  get likeComponent(): View | BusinessComponent {
+    return this.view || (this?.getAncestor('BusinessComponent') as BusinessComponent);
+  }
+
   // 通过内容过去节点
   getCallNode(): Logic | undefined {
+    let node;
+    // 如果是页面/业务组件 局部逻辑
+    if (!this.calleeNamespace && this.calleeName && this.likeComponent) {
+      node = this.likeComponent.logics.find((l) => l.name === this.calleeName);
+    } else if (this.calleeNamespace?.startsWith('nasl.')) {
+      // 如果是页面组件
+      node = getNaslNodeByNodeCallee(this.calleeNamespace, this.calleeName);
+    } else if (this.calleeNamespace?.startsWith('elements.')) {
+      // 查找组件的逻辑，用于展示默认值
+      const elementsLogic = (this.app as any)?.naslServer?.elementsLogic || {};
+      let elementName: string = this.calleeNamespace.split('.')[1];
+      // eslint-disable-next-line prefer-destructuring
+      elementName = elementName.split('_')[0];
+      elementName = elementName[0].toUpperCase() + elementName.slice(1);
+      const logics = elementsLogic[`U${elementName}`] || elementsLogic[`Van${elementName}`] || [];
+      node = logics.find((l: any) => l.name === this.calleeName);
+    } else {
+      // 如果是其余app下自定义逻辑
+      try {
+        node = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: any, tempPoint: any) => {
+          // 处理 NASL 中未定义的假的节点
+          if (key === tempPoint.name) {
+            return {
+              tempPoint,
+              state: 1,
+            };
+          }
+          const t = tempPoint[key];
+          return {
+            tempPoint: t,
+            state: Array.isArray(t) ? 2 : 1,
+          };
+        });
+      } catch (err) {}
+    }
+    return node;
+  }
+
+  getCallNodeUsingCache(frontNdCache : Map<string, Logic>, serverNdCache : Map<string, Logic>, processNdCache : Map<string, Logic>): ['front' | 'server' | 'process', Logic | undefined] {
+    const cwKey = this.calleewholeKey;
+    if (serverNdCache.get(cwKey)) {
+      return ['server', serverNdCache.get(cwKey)];
+    }
+    if (processNdCache.get(cwKey)) {
+      return ['process', processNdCache.get(cwKey)];
+    }
+    if (frontNdCache.get(cwKey)) {
+      return ['front', frontNdCache.get(cwKey)];
+    }
+
     let node;
     // 如果是页面局部逻辑
     if (!this.calleeNamespace && this.calleeName && this.view) {
@@ -1597,7 +1652,7 @@ export class CallLogic extends LogicItem {
     } else {
       // 如果是其余app下自定义逻辑
       try {
-        node = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: any, tempPoint: any) => {
+        node = getNodeByNodeCallee(this.app, cwKey, (key: any, tempPoint: any) => {
           // 处理 NASL 中未定义的假的节点
           if (key === tempPoint.name) {
             return {
@@ -1613,7 +1668,8 @@ export class CallLogic extends LogicItem {
         });
       } catch (err) {}
     }
-    return node;
+    frontNdCache.set(cwKey, node);
+    return ['front', node];
   }
 
   /** 获取类型标注时的偏移量 */

package/src/concepts/Entity__.ts

@@ -35,6 +35,7 @@ import * as asserts from './utils/asserts';
 import EntityProperty from './EntityProperty__';
 import EntityIndex from './EntityIndex__';
 import Annotatable from './Annotatable__';
+import Logic from './Logic__';
 
 /**
  * 实体
@@ -818,7 +819,7 @@ export class Entity extends Annotatable {
      * 如果修改这里,可能会影响到dataSource的重命名,  在naslserver中,可能要一起修改
      */
     code += `\n${indent((state?.tabSize || 0) + 1)}static logics = {\n`;
-    yield* wrapForEach(ns.logics, function* warpForEachGenerator(logic) {
+    yield* wrapForEach(ns.logics, function* warpForEachGenerator(logic : Logic) {
       code += indent((state?.tabSize || 0) + 1);
       code += yield* logic.toEmbeddedTS(shiftState(state, code), 'inObject');
     });
@@ -909,6 +910,11 @@ export class Entity extends Annotatable {
     return this.ns.logics;
   }
 
+  get contentUniqueKey() {
+    return `${this.getNamespace()}.${this.name} {${this.properties.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation?.sortedTypeKey : '未知'}`)
+      .join(', ')}}`;
+  }
+
   *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getNamespace()} {\n`;
     code += '    @nasl.annotation.Entity()\n';

package/src/concepts/Event__.ts

@@ -14,6 +14,7 @@ import {
   withSourceMapGenerator,
   withGenerator,
   TranslatorGenerator,
+  createDecoratorCode,
 } from '../translator';
 import ViewComponentDeclaration from './ViewComponentDeclaration__';
 import Module from './Module__';
@@ -356,6 +357,37 @@ export class Event extends BaseNode {
       field: 'name',
     });
   }
+
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState(), dontType?: boolean): string {
+    let code = '';
+    // code += createDecoratorCode(state, this, ['group', 'title', 'description']);
+
+    code += 'on' + utils.firstUpperCase(this.name) + ': (';
+    this.params.forEach((param, index) => {
+      code += param.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1, inline: true }));
+      if (index !== this.params.length - 1) code += ', ';
+    });
+    code += ') => void';
+
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState(), dontType?: boolean): string {
+    let code = '';
+    code += createDecoratorCode(state, this, ['group', 'title', 'description']);
+
+    code += 'on' + utils.firstUpperCase(this.name) + ': (';
+    this.params.forEach((param, index) => {
+      code += param.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1, inline: true }));
+      if (index !== this.params.length - 1) code += ', ';
+    });
+    code += ') => null';
+    
+    return code;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/FrontendType__.ts

@@ -1,5 +1,5 @@
 import type { EmbeddedTSFileGenerator } from '../utils';
-import { createCompilerState, withSourceMapGenerator, TranslatorGenerator } from '../translator';
+import { withSourceMap, createCompilerState, withSourceMapGenerator, TranslatorGenerator, indent, shiftState } from '../translator';
 import Namespace from './Namespace__';
 import { AssetsInfo } from './App__';
 
@@ -811,6 +811,39 @@ export class FrontendType extends BaseNode {
     return custom;
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    let code = `export namespace app.frontendTypes.${this.name} {\n`;
+    this.businessComponents.forEach((component) => {
+    });
+    this.frontends.forEach((frontend, index) => {
+      code += frontend.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+      if (index !== this.frontends.length) code += '\n';
+    });
+    code += `${indent(state.tabSize)}}`;
+
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = `frontend ${this.kind} {\n`;
+    this.businessComponents.forEach((component) => {
+
+    });
+    code += `${indent(state.tabSize)}}`;
+
+    if (this.frontends.length)
+      code += `\n\n${indent(state.tabSize)}`;
+
+    this.frontends.forEach((frontend, index) => {
+      code += frontend.toTextualNASL(state) + '\n';
+      if (index !== this.frontends.length) code += '\n';
+    });
+
+    return code;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓