@lcap/nasl 3.8.2-beta.2 → 3.8.2-beta.4

package/src/concepts/Logic__.ts

@@ -18,6 +18,7 @@ import {
   withGenerator,
   TranslatorGenerator,
   createDescriptionComment,
+  createDecoratorCode,
 } from '../translator';
 import type App from './App__';
 import type Namespace from './Namespace__';
@@ -2323,13 +2324,16 @@ export class Logic extends Annotatable {
   toTextualNASL(state = createCompilerState(), prefix?: string, logicName?: string, currentNode?: BaseNode): string {
     // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
     let code = '';
+
+    code += createDecoratorCode(state, this, ['title', 'description', 'triggerType', 'cron', 'transactional', 'overridable']);
+    if (state.declaration) code += 'declare ';
     // 有参数长度
     code += `logic ${this.name}`;
 
     if (this.typeParams?.length) {
       code += '<';
       this.typeParams.forEach((typeParam, typeParamIndex) => {
-        code += typeParam.toNaturalTS(shiftState(state, code, { inline: true }));
+        code += typeParam.toTextualNASL(shiftState(state, code, { inline: true }));
         if (typeParamIndex !== this.typeParams.length - 1) code += ', ';
       });
       code += '>';
@@ -2352,30 +2356,35 @@ export class Logic extends Annotatable {
       });
     }
 
-    code += ' {\n';
-
-    this.variables.forEach((variable) => {
-      code += `${indent(state.tabSize + 1)}let `;
-      code += variable.toTextualNASL(shiftState(state, code, { inline: true }));
-      code += ';\n';
-    });
-
-    this.body.forEach((item) => {
-      let partialCode = '';
-
-      // if (!state.focusedNodePath && item.concept === 'End') code += `${indent(state.tabSize + 1)}/* 当前位置 */\n`;
-      if (item.toTextualNASL) {
-        partialCode = item.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
-      } else if (item.toEmbeddedTS) {
-        partialCode = runSync(item.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 })));
-      }
-      partialCode = partialCode.trimEnd();
-      if (partialCode) {
-        code += partialCode;
-        code += '\n';
-      }
-    });
-    code += `${indent(state.tabSize)}}`;
+    if (state.declaration) {
+      code += ';';
+    } else {
+      code += ' {\n';
+  
+      this.variables.forEach((variable) => {
+        code += `${indent(state.tabSize + 1)}let `;
+        code += variable.toTextualNASL(shiftState(state, code, { inline: true }));
+        code += ';\n';
+      });
+      if (this.variables.length) code += '\n';
+  
+      this.body.forEach((item) => {
+        let partialCode = '';
+  
+        // if (!state.focusedNodePath && item.concept === 'End') code += `${indent(state.tabSize + 1)}/* 当前位置 */\n`;
+        if (item.toTextualNASL) {
+          partialCode = item.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+        } else if (item.toEmbeddedTS) {
+          partialCode = runSync(item.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 })));
+        }
+        partialCode = partialCode.trimEnd();
+        if (partialCode) {
+          code += partialCode;
+          code += '\n';
+        }
+      });
+      code += `${indent(state.tabSize)}}`;
+    }
     return code;
   }
 
@@ -2402,8 +2411,17 @@ export class Logic extends Annotatable {
     // 调用服务端逻辑，参数替换成 null
     if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace === 'app.logics') {
       const calleeName = rightNode?.calleeName;
-      const calleeLogic = this.app.logics.find((l) => l.name === calleeName);
-      return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
+      if (calleeName) {
+        /**
+         * 若calleeName非空，即便所调用的逻辑不存在，也仍然要忠实地翻译这个CallLogic表达式
+         * @link {https://projectmanage.netease-official.lcap.163yun.com/dashboard/BugDetail?id=2855540189054208}
+         *
+         * 对于CallInterface则不需要
+         */
+        const calleeLogic: Logic | undefined = this.app.logics.find((l) => l.name === calleeName);
+        return `app.logics.${calleeName}(${calleeLogic?.params.map(() => 'null').join(',') ?? ''})`;
+      }
+      return null;
     }
     // 调用依赖库逻辑可能会有子逻辑，子逻辑拼接可能有ts忽略先去掉
     if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace?.startsWith('extensions.')) {

package/src/concepts/MatchCase__.ts

@@ -937,8 +937,7 @@ export class MatchCase extends LogicItem {
     } else {
       code += '{\n';
       this.body.forEach((logicItem) => {
-        code += indent(state.tabSize + 1);
-        code += `${logicItem.toTextualNASL(shiftState(state, code, { inline: true }))}\n`;
+        code += `${logicItem.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1, inline: false }))}\n`;
       });
       code += `${indent(state.tabSize)}}\n`;
     }

package/src/concepts/Match__.ts

@@ -731,11 +731,9 @@ export class Match extends LogicItem {
     if (this.parentNode?.concept === 'Logic') {
       code += '\n';
     }
-    code += indent(state?.tabSize || 0);
-    code += '(function match(_value) { \n';
+    code += '(function match(_value) {\n';
     let parentCode: string;
     if (this.expression) {
-      code += indent((state?.tabSize || 0) + 1);
       // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
       if (asserts.isIdentifier(this.expression) || asserts.isMemberExpression(this.expression)) {
         parentCode = this.expression?.toNaturalTS(shiftState(state, code, { inline: true }));
@@ -748,30 +746,14 @@ export class Match extends LogicItem {
     this.cases.forEach((item, index) => {
       // 如果是最后一项
       code += item.toNaturalTS(
-        shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1, inline: true }),
+        shiftState(state, code, { tabSize: state.tabSize + 1 }),
         index,
         parentCode,
       );
     });
-    code += `${indent(state?.tabSize || 0)}})(${this.expression?.toNaturalTS(
+    code += `${indent(state.tabSize)}})(${this.expression?.toNaturalTS(
       shiftState(state, code, { inline: true }),
     )})`;
-
-    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 !== 'BinaryExpression' &&
-      this.parentNode?.concept !== 'StringInterpolation' &&
-      this.parentNode?.concept !== 'MemberExpression' &&
-      !['NewMap', 'NewList'].includes(this.parentNode?.concept) &&
-      this.parentKey !== 'returnExpression'
-    ) {
-      code += '\n';
-    }
     return code;
   }
 

package/src/concepts/MemberExpression__.ts

@@ -144,7 +144,7 @@ export class MemberExpression extends LogicItem {
       ) {
         const { prop } = ComponentCompletionPropertyMap[elementTag][this.property.name];
         if (!['data'].includes(this.property.name)) {
-          return `__${elementName}_params && __${elementName}_params.${this.property.name}`;
+          return `this && this.__${elementName}_params && this.__${elementName}_params.${this.property.name}`;
         }
 
         return `__${elementName}_${prop}`;

package/src/concepts/Module__.ts

@@ -1,10 +1,24 @@
 type PropertyType = 'structures' | 'enums' | 'entities' | 'interfaces' | 'processes' | 'views';
+import {
+  withSourceMap,
+  createCompilerState,
+  createDecoratorCode,
+  indent,
+  shiftState,
+} from '../translator';
 const moduleNameSpace = {
   dependencies: 'extensions',
   interfaceDependencies: 'apis',
   componentDependencies: 'components',
   connectorDependencies: 'connector',
 };
+const typeNameSpace: Record<Module['type'], string> = {
+  extension: 'extensions',
+  interface: 'apis',
+  component: 'components',
+  connector: 'connector',
+  customInterface: 'apis',
+};
 type ModuleKeyType = 'dependencies' | 'interfaceDependencies' | 'componentDependencies' | 'connectorDependencies';
 import type { AuthInterface } from './AuthInterface__';
 import type ConfigProperty from './ConfigProperty__';
@@ -3048,6 +3062,67 @@ export class Module extends BaseNode {
     });
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    let code = '';
+
+    code += `namespace ${typeNameSpace[this.type]}.${this.name} {\n`;
+
+    this.dataSources?.forEach((dataSource) => {
+      code += dataSource.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+    this.structures?.forEach((structure) => {
+      code += structure.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+    this.enums?.forEach((enumeration) => {
+      code += enumeration.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+    this.metadataTypes?.forEach((metadataType) => {
+      code += metadataType.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+    if (this.metadataTypes.length)
+      code += '\n';
+    this.logics?.forEach((logic) => {
+      code += logic.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1, declaration: true })) + '\n\n';
+    });
+    this.interfaces?.forEach((inter) => {
+      code += inter.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = '';
+    code += createDecoratorCode(state, this, ['type', 'version', 'title', 'description', 'provider', 'externalDependencyMap', 'compilerInfoMap']);
+
+    code += `module ${this.name} {\n`;
+
+    this.dataSources?.forEach((dataSource) => {
+      code += dataSource.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+    this.structures?.forEach((structure) => {
+      code += structure.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+    this.enums?.forEach((enumeration) => {
+      code += enumeration.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+    this.metadataTypes?.forEach((metadataType) => {
+      code += metadataType.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+    this.logics?.forEach((logic) => {
+      code += logic.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1, declaration: true })) + '\n\n';
+    });
+    this.interfaces?.forEach((inter) => {
+      code += inter.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+    });
+
+    code += `${indent(state.tabSize)}}`;
+
+    return code;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/NewComposite__.ts

@@ -758,7 +758,7 @@ export class NewComposite extends LogicItem {
     return this.assignmentLines.length;
   }
 
-  async newConnection(addRightIndex?: number) {
+  newConnection(addRightIndex?: number) {
     const leftLineSet = new Set();
     const lineArr: Array<AssignmentLine> = [];
     const AssignmentLine = getConceptConstructor('AssignmentLine');
@@ -782,7 +782,7 @@ export class NewComposite 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++) {
@@ -813,7 +813,7 @@ export class NewComposite extends LogicItem {
 
             if (leftName === rightName) {
               const rightTypeAnnotation = rightMember.__TypeAnnotation;
-              if (!isAnnotation && leftTypeAnnotation.typeKind !== rightTypeAnnotation.typeKind) return;
+              if (!isAnnotation && leftTypeAnnotation.typeName !== rightTypeAnnotation.typeName) return;
               const leftIndex = [0, leftSecondIndex];
               const rightIndex = [rightFirstIndex, rightSecondIndex];
               const Line: AssignmentLine = new AssignmentLine({ leftIndex, rightIndex });

package/src/concepts/NullLiteral__.ts

@@ -81,6 +81,13 @@ export class NullLiteral extends LogicItem {
 
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    // 特殊翻译，处理异常报错
+    // 匹配红框误报  http://projectmanage.netease-official.lcap.163yun.com/dashboard/BugDetail?id=2854094336746752
+    // 如果表达式，槽位直接放null ，会报any类型错误，所以这里加上as any， 就不会报错了
+    if (this?.parentNode?.concept === 'Match' && this?.parentKey === 'expression') {
+      return '(null) as any';
+    }
+
     return 'null';
   }
 

package/src/concepts/Paginate__.ts

@@ -138,20 +138,27 @@ export class Paginate extends LogicItem {
   //================================================================================
   @withSourceMap()
   toNaturalTS(state = createCompilerState()): string {
-    const self = this;
     let code = 'PAGINATE(';
-    const list = self.list ? self.list.toNaturalTS(shiftState(state, code)) : '__IDENTIFIER__';
-    code += list;
+    code += this.list ? this.list.toNaturalTS(shiftState(state, code)) : '__IDENTIFIER__';
     code += ', ';
-    const page = self.page ? self.page.toNaturalTS(shiftState(state, code)) : '__IDENTIFIER__';
-    code += page;
+    code += this.page ? this.page.toNaturalTS(shiftState(state, code)) : '__IDENTIFIER__';
     code += ', ';
-    const size = self.size ? self.size.toNaturalTS(shiftState(state, code)) : '__IDENTIFIER__';
-    code += size;
+    code += this.size ? this.size.toNaturalTS(shiftState(state, code)) : '__IDENTIFIER__';
     code += `)\n`;
     return code;
   }
 
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = '';
+    code += this.list ? this.list.toTextualNASL(shiftState(state, code)) : '__IDENTIFIER__';
+    code += ' paginate ';
+    code += this.page ? this.page.toTextualNASL(shiftState(state, code)) : '__IDENTIFIER__';
+    code += ', ';
+    code += this.size ? this.size.toTextualNASL(shiftState(state, code)) : '__IDENTIFIER__';
+    return code;
+  }
+
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;

package/src/concepts/QueryFromExpression__.ts

@@ -281,7 +281,7 @@ export class QueryFromExpression extends LogicItem {
 
     if (this.joinParts.length) {
       this.joinParts.forEach((joinPart) => {
-        code += '\n';
+        code += `\n${indent(state.tabSize)}`;
         code += joinPart.toNaturalSQL(state);
       });
     }
@@ -296,7 +296,7 @@ export class QueryFromExpression extends LogicItem {
 
     if (this.joinParts.length) {
       this.joinParts.forEach((joinPart) => {
-        code += '\n';
+        code += `\n${indent(state.tabSize)}`;
         code += joinPart.toTextualNASL(state);
       });
     }

package/src/concepts/StringLiteral__.ts

@@ -86,10 +86,9 @@ export class StringLiteral extends LogicItem {
         }
         code = `\`${this.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/TypeAnnotation__.ts

@@ -1232,6 +1232,7 @@ export class TypeAnnotation extends BaseNode {
     } else {
       str += this.typeName;
     }
+    str = str === 'Long' ? 'Integer' : str;
     return str;
   }
 

package/src/concepts/ViewElement__.ts

@@ -80,6 +80,8 @@ function genArgumentMemberExpression(arr: string[]) {
 }
 export interface ElementToVueOptions {
   filterAttr?:  Array<string>;
+  /** 生成器镜像的导出流程 */
+  isGeneratorExport?: boolean;
   isExport?: boolean;
   isRelease?: boolean;
   isRoot?: boolean;
@@ -287,7 +289,7 @@ function transAstNodeToNaslNode(astNode: any, namespace?: string): any {
 function transAstNodeToNaslTypeNode(astNode: any, namespace?: string): any {
   let node = null;
   // 单独特殊处理枚举因为他不是MemberExpression，而是Identifier_
-  if (astNode?.value?.startsWith('__enumTypeAnnotation_')) {
+  if (astNode?.value?.startsWith?.('__enumTypeAnnotation_')) {
     const valueArr = astNode.value.replace('__enumTypeAnnotation_', '')?.split('.');
     const name = valueArr.pop();
     const namespace = valueArr.join('.');
@@ -1634,7 +1636,7 @@ export class ViewElement extends Annotatable {
     let levelIndex = parentLevel || 0;
     code += `${self.name}: () => {\n`;
 
-    const getMultipleDefaultValue = (name: string) => {
+    const getPropInitialValue = (name: string) => {
       let v = 'new nasl.core.BooleanFalse()';
       const attr = self.bindAttrs?.find((attr) => attr.name === name);
       if (['static', 'string'].includes(attr?.type)) {
@@ -1775,26 +1777,27 @@ export class ViewElement extends Annotatable {
     if (hasDataSource && V && !T1) {
       const valueFieldAttr = self.bindAttrs?.find((attr) => attr.name === 'valueField');
       if (dataSourceSetted && ['static', 'string'].includes(valueFieldAttr?.type)) {
-        valueType = `typeof __item.${valueFieldAttr.value}`;
+        valueType = `nasl.util._formatEnum<typeof __item.${valueFieldAttr.value}>`;
       } else {
-        valueType = `typeof __staticItem`;
+        valueType = `nasl.util._formatEnum<typeof __staticItem>`;
       }
     }
     // 分页
     let pageableDefaultValue: string;
     if (hasDataSource && P && !T1) {
-      pageableDefaultValue = getMultipleDefaultValue('pageable');
+      pageableDefaultValue = getPropInitialValue('pageable');
       code += `let __pageable = ${pageableDefaultValue};\n`;
     }
     // 多选
     let multipleDefaultValue: string;
     if (hasDataSource && M && !T1) {
-      multipleDefaultValue = getMultipleDefaultValue('multiple');
+      const name = config?.allNodesAPI?.[self.tag]?.props?.find((prop) => ['M'].includes(prop.tsType))?.name;
+      multipleDefaultValue = getPropInitialValue(name || 'multiple');
       code += `let __multiple = ${multipleDefaultValue};\n`;
     }
     if (hasDataSource && V && !T1) {
       code += `// @ts-ignore
-      let __value: typeof __multiple extends nasl.core.BooleanTrue ? ${valueType}[] : ${valueType};\n`;
+      let __value: typeof __multiple extends nasl.core.BooleanTrue ? nasl.collection.List<${valueType}> : ${valueType};\n`;
       code += `// @ts-ignore
       let __V: ${valueType};\n`;
     }
@@ -2914,6 +2917,7 @@ export class ViewElement extends Annotatable {
                   return `:${name}="${value.replace(/"/g, "'")}"`;
                 }
               } catch (e) {
+                if (apiOfAttr && apiOfAttr.type && !apiOfAttr.type.includes('string')) return '';
                 if (apiOfAttr && apiOfAttr.tsType && !apiOfAttr.tsType.includes('nasl.core.String')) return '';
               }
               value = value

package/src/concepts/View__.ts

@@ -15,6 +15,7 @@ import {
   withSourceMapGenerator,
   withGenerator,
   TranslatorGenerator,
+  createDecoratorCode,
 } from '../translator';
 import translator from '../bak/translator';
 import { ElementToVueOptions } from './ViewElement__';
@@ -2559,11 +2560,11 @@ export class View extends Annotatable {
         code += variable.toNaturalTS(shiftState(state, code, { inline: true }));
         code += ';\n';
       });
+      if (this.variables.length) code += '\n';
 
       if (callback) {
         code += callback.call(this, state);
       } else {
-        code += '\n';
         code += this.elements[0].toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
       }
 
@@ -2573,6 +2574,60 @@ export class View extends Annotatable {
     return code;
   }
 
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState(), callback?: (this: View, state: TranslatorState) => string): string {
+    const viewName = state.rename ?? this.tsName;
+    let code = '';
+    code += createDecoratorCode(state, this, ['pageTemplateId', 'uuid', 'title', 'crumb', 'auth', 'authDescription', 'isIndex']);
+
+    if (state.declaration) {
+      code += `declare view ${viewName}`;
+      // 有参数长度
+      code += '(';
+      this.params.forEach((param, index) => {
+        code += param.toTextualNASL(shiftState(state, code, { tabSize: 0 }));
+        if (index !== this.params.length - 1) code += ', ';
+      });
+      code += ') {';
+      if (state.convertChildren && this.children?.length) {
+        this.children.forEach((child) => {
+          code += child.toTextualNASL(shiftState(state, code, { tabSize: state?.tabSize || 0 + 1 }), callback);
+          code += '\n';
+        });
+      }
+      code += '}';
+    } else {
+      code += `view ${viewName}`;
+
+      // 有参数长度
+      code += '(';
+      this.params.forEach((param, index) => {
+        code += param.toTextualNASL(shiftState(state, code, { inline: true }));
+        if (index !== this.params.length - 1) code += ', ';
+      });
+      code += ')';
+
+      code += ' {\n';
+
+      this.variables.forEach((variable) => {
+        code += `${indent(state.tabSize + 1)}let `;
+        code += variable.toTextualNASL(shiftState(state, code, { inline: true }));
+        code += ';\n';
+      });
+      if (this.variables.length) code += '\n';
+
+      if (callback) {
+        code += callback.call(this, state);
+      } else {
+        code += this.elements[0].toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+      }
+
+      code += `\n${indent(state.tabSize)}}\n`;
+    }
+
+    return code;
+  }
+
   *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getTsNamespace()} {\n`;
     const state = createCompilerState(code, {