@lcap/nasl 3.3.0-beta.0 → 3.4.0-alpha.1

package/src/concepts/MatchCase__.ts

@@ -1,38 +1,34 @@
 // @ts-nocheck
-import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import { v4 as uuidv4 } from 'uuid';
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
 import Match from './Match__';
 import MemberExpression from './MemberExpression__';
 import BooleanLiteral from './BooleanLiteral__';
 import { ElementToVueOptions } from './ViewElement__';
 
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
 import TypeAnnotation from './TypeAnnotation__';
 
 /**
  * 匹配分支
  */
-@className
 @concept('匹配分支')
-// @ts-ignore
 export class MatchCase extends LogicItem {
-  /** 类名 */
-  static readonly ConceptName = 'MatchCase';
-
   /**
    * 产品概念
    */
-  // @ts-ignore
-  readonly concept!: 'MatchCase';
+  @property()
+  concept: 'MatchCase' = 'MatchCase';
 
   /**
    * 条件表达式
@@ -56,11 +52,16 @@ export class MatchCase extends LogicItem {
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<MatchCase>) {
-    source = Object.assign({}, MatchCase.getDefaultOptions(), source);
+    // @ts-ignore
+    source = { ...MatchCase.getDefaultOptions(), ...source };
     super(source);
     super.subConstructor(source);
   }
 
+  getClassName() {
+    return 'MatchCase';
+  }
+
   static from(source: any, parentNode?: any, parentKey?: string): MatchCase {
     return super.from(source, parentNode, parentKey) as MatchCase;
   }
@@ -93,6 +94,7 @@ export class MatchCase extends LogicItem {
     const excludedSet = new Set(excludedList);
     return ((this.patterns as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
+
   getLogicItemUniqueName(name = 'logicItem1') {
     return utils.unique(name, this.getLogicItemExistingNames(), undefined, false);
   }
@@ -129,7 +131,7 @@ export class MatchCase extends LogicItem {
           name: this.getLogicItemUniqueName(),
         },
         this,
-        'patterns',
+        'patterns'
       );
     } else if (typeof options === 'string') {
       logicItem = LogicItem.from(
@@ -138,7 +140,7 @@ export class MatchCase extends LogicItem {
           name: options,
         },
         this,
-        'patterns',
+        'patterns'
       );
     } else if (options instanceof LogicItem) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -151,7 +153,7 @@ export class MatchCase extends LogicItem {
           ...options,
         },
         this,
-        'patterns',
+        'patterns'
       );
     }
     this.patterns.splice(index, 0, logicItem);
@@ -271,7 +273,7 @@ export class MatchCase extends LogicItem {
           ...options,
         },
         this,
-        'body',
+        'body'
       );
     }
     this.body.splice(index, 0, logicItem);
@@ -344,10 +346,9 @@ export class MatchCase extends LogicItem {
 
   getTypeAnnotationExistingNames(excludedList: Array<TypeAnnotation> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.patterns as TypeAnnotation[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item.name);
+    return ((this.patterns as TypeAnnotation[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
+
   getTypeAnnotationUniqueName(name = 'typeAnnotation1') {
     return utils.unique(name, this.getTypeAnnotationExistingNames(), undefined, false);
   }
@@ -384,7 +385,7 @@ export class MatchCase extends LogicItem {
           name: this.getTypeAnnotationUniqueName(),
         },
         this,
-        'patterns',
+        'patterns'
       );
     } else if (typeof options === 'string') {
       typeAnnotation = TypeAnnotation.from(
@@ -393,7 +394,7 @@ export class MatchCase extends LogicItem {
           name: options,
         },
         this,
-        'patterns',
+        'patterns'
       );
     } else if (options instanceof TypeAnnotation) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -406,7 +407,7 @@ export class MatchCase extends LogicItem {
           ...options,
         },
         this,
-        'patterns',
+        'patterns'
       );
     }
     this.patterns.splice(index, 0, typeAnnotation);
@@ -514,7 +515,7 @@ export class MatchCase extends LogicItem {
     if (typeof options === 'string') {
       logicItem = (this.patterns as LogicItem[]).find((item) => item.name === options);
       if (!logicItem) {
-        throw new Error('找不到逻辑项 ' + options);
+        throw new Error(`找不到逻辑项 ${options}`);
       }
     } else {
       logicItem = options;
@@ -529,12 +530,12 @@ export class MatchCase extends LogicItem {
   removeItemInBody(logicItem: LogicItem): void;
 
   removeItemInBody(options: LogicItem) {
-    let logicItem: LogicItem = options;
+    const logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
   __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
+    const { parentKey } = logicItem;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -573,7 +574,7 @@ export class MatchCase extends LogicItem {
     if (typeof options === 'string') {
       typeAnnotation = (this.patterns as TypeAnnotation[]).find((item) => item.name === options);
       if (!typeAnnotation) {
-        throw new Error('找不到类型标注 ' + options);
+        throw new Error(`找不到类型标注 ${options}`);
       }
     } else {
       typeAnnotation = options;
@@ -582,7 +583,7 @@ export class MatchCase extends LogicItem {
   }
 
   __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
-    const parentKey = typeAnnotation.parentKey;
+    const { parentKey } = typeAnnotation;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -604,10 +605,10 @@ export class MatchCase extends LogicItem {
     return params;
   }
 
-  //================================================================================
+  //= ===============================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
-  //================================================================================
+  //= ===============================================================================
 
   // 是否处于禁用状态
   get isDisabled() {
@@ -778,7 +779,7 @@ export class MatchCase extends LogicItem {
               code += pattern.toEmbeddedTS(
                 shiftState(state, code, {
                   tabSize: state?.tabSize || 0,
-                }),
+                })
               );
             }
           });
@@ -796,7 +797,7 @@ export class MatchCase extends LogicItem {
             code += `${logicItem.toEmbeddedTS(
               shiftState(state, code, {
                 tabSize: state?.tabSize || 0,
-              }),
+              })
             )}\n`;
           });
         }
@@ -813,7 +814,7 @@ export class MatchCase extends LogicItem {
             code += `${logicItem.toEmbeddedTS(
               shiftState(state, code, {
                 tabSize: state?.tabSize || 0,
-              }),
+              })
             )}\n`;
           });
         }
@@ -829,7 +830,7 @@ export class MatchCase extends LogicItem {
           code += `${logicItem.toEmbeddedTS(
             shiftState(state, code, {
               tabSize: state?.tabSize || 0,
-            }),
+            })
           )}\n`;
         });
       }
@@ -838,15 +839,104 @@ export class MatchCase extends LogicItem {
 
     return code;
   }
-  //================================================================================
+
+
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState(), index?: number, parentCode?: string): string {
+    let code = '\n';
+
+    const parentNode = (this.parentNode as Match);
+    const length = parentNode?.cases?.length;
+
+    if (length > 1) {
+      if (index !== length - 1) {
+        code += indent(state.tabSize);
+        code += index === 0 ? '' : 'else ';
+        code += 'if (';
+        if (Array.isArray(this.patterns) && this.patterns.length) {
+          this.patterns.forEach((pattern, index) => {
+            // nasl.code.isUnionType<typeof ccc, List<Integer> | List<Boolean>>
+            if (pattern instanceof TypeAnnotation) {
+              if (index === 0) {
+                code += `nasl.core.isUnionType<typeof `;
+                code += `${parentCode},`;
+                code += pattern.toNaturalTS(shiftState(state, code, { inline: true }));
+              } else {
+                code += '|';
+                code += pattern.toNaturalTS(shiftState(state, code, { inline: true }));
+              }
+              if (index === this.patterns.length - 1) {
+                code += '>';
+                code += `(${parentCode})`;
+              }
+            } else {
+              if (index !== 0) {
+                code += ' || ';
+              }
+              code += parentCode;
+              code += ' === ';
+              code += pattern.toNaturalTS(shiftState(state, code, { inline: true }));
+            }
+          });
+        } else {
+          code += '__IDENTIFIER__';
+        }
+        code += ') {\n';
+
+        if (Array.isArray(this.body)) {
+          this.body.forEach((logicItem, bodyIndex) => {
+            if (bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+              code += indent(state.tabSize);
+              code += `return `;
+            }
+            code
+              += `${logicItem.toNaturalTS(shiftState(state, code, {
+                tabSize: state.tabSize + 1,
+              }))}\n`;
+          });
+        }
+        code += `${indent(state.tabSize)  }}`;
+      } else {
+        code += indent(state.tabSize);
+        code += 'else {\n';
+        this.body.forEach((logicItem, bodyIndex) => {
+          if (bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+            code += indent(state.tabSize);
+            code += `return `;
+          }
+          code += `${logicItem.toNaturalTS(shiftState(state, code, {
+            tabSize: state.tabSize + 1,
+          }))}\n`;
+        });
+        code += `${indent(state.tabSize)  }}\n`;
+      }
+    } else {
+      this.body.forEach((logicItem, bodyIndex) => {
+        if (bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+          code += indent(state.tabSize);
+          code += `return `;
+        }
+        code
+          += `${logicItem.toNaturalTS(shiftState(state, code, {
+            tabSize: state.tabSize,
+          }))}\n`;
+      });
+      code += '\n';
+    }
+
+    return code;
+  }
+
+  //= ===============================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //================================================================================
+  //= ===============================================================================
 }
 
+classMap.MatchCase = MatchCase;
 export default MatchCase;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================
 // @ts-check

package/src/concepts/Match__.ts

@@ -1,46 +1,41 @@
-import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import { v4 as uuidv4 } from 'uuid';
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
 import TypeAnnotation, { isUnion } from './TypeAnnotation__';
 import BooleanLiteral from './BooleanLiteral__';
 import MemberExpression from './MemberExpression__';
 import { formatEnums } from '../server/getMemberIdentifier';
 import Identifier from './Identifier__';
-import ViewElement from './ViewElement__';
+import ViewElement, { ElementToVueOptions } from './ViewElement__';
 
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
 import MatchCase from './MatchCase__';
 
 /**
  * 匹配
  */
-@className
 @concept('匹配')
-// @ts-ignore
 export class Match extends LogicItem {
-  /** 类名 */
-  static readonly ConceptName = 'Match';
-
   /**
    * 产品概念
    */
-  // @ts-ignore
-  readonly concept!: 'Match';
+  @property()
+  concept: 'Match' = 'Match';
 
   /**
    * 逻辑项
    */
   @property('LogicItem')
-  // @ts-ignore
-  expression!: LogicItem;
+  expression: LogicItem = undefined;
 
   /**
    * 是否表达式形态
@@ -58,11 +53,16 @@ export class Match extends LogicItem {
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<Match>) {
-    source = Object.assign({}, Match.getDefaultOptions(), source);
+    // @ts-ignore
+    source = { ...Match.getDefaultOptions(), ...source };
     super(source);
     super.subConstructor(source);
   }
 
+  getClassName() {
+    return 'Match';
+  }
+
   static from(source: any, parentNode?: any, parentKey?: string): Match {
     return super.from(source, parentNode, parentKey) as Match;
   }
@@ -96,7 +96,7 @@ export class Match extends LogicItem {
           ...options,
         },
         this,
-        'cases',
+        'cases'
       );
     }
     this.cases.splice(index, 0, matchCase);
@@ -184,7 +184,7 @@ export class Match extends LogicItem {
     if (typeof options === 'string') {
       expression = this.expression;
       if (!expression) {
-        throw new Error('找不到逻辑项 ' + options);
+        throw new Error(`找不到逻辑项 ${options}`);
       }
     } else {
       expression = options;
@@ -199,12 +199,12 @@ export class Match extends LogicItem {
   removeMatchCaseInCases(matchCase: MatchCase): void;
 
   removeMatchCaseInCases(options: MatchCase) {
-    let matchCase: MatchCase = options;
+    const matchCase: MatchCase = options;
     return matchCase.delete();
   }
 
   __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
+    const { parentKey } = logicItem;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -226,10 +226,10 @@ export class Match extends LogicItem {
     return params;
   }
 
-  //================================================================================
+  //= ===============================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
-  //================================================================================
+  //= ===============================================================================
   enumerableItems: Array<LogicItem | TypeAnnotation>;
 
   get isEnumerable() {
@@ -460,7 +460,7 @@ export class Match extends LogicItem {
             new MatchCase({
               patterns: [enumerableItem],
               isMatchedTypeEnumable,
-            }),
+            })
         );
       }
     }
@@ -675,7 +675,7 @@ export class Match extends LogicItem {
   }
 
   @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState): string {
+  toEmbeddedTS(state = createCompilerState()): string {
     let code = '';
 
     if (this.parentNode.concept === 'Logic') {
@@ -732,15 +732,60 @@ export class Match extends LogicItem {
     return code;
   }
 
-  //================================================================================
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    let code = '';
+
+    if (this.parentNode?.concept === 'Logic') {
+      code += '\n';
+    }
+    code += indent(state.tabSize);
+    code += '(function match(_value) { \n';
+    let parentCode: string;
+    if (this.expression) {
+      code += indent(state.tabSize + 1);
+      // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
+      if ((this.expression instanceof Identifier) || (this.expression instanceof MemberExpression)) {
+        parentCode = this.expression.toNaturalTS(shiftState(state, code, { inline: true }));
+      } else {
+        parentCode = '_value';
+      }
+    }
+
+    // 最后一项是else
+    this.cases.forEach((item, index) => {
+      // 如果是最后一项
+      code += item.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }), index, parentCode);
+    });
+    code += indent(state.tabSize);
+    code += `})(${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;
+  }
+
+  //= ===============================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //================================================================================
+  //= ===============================================================================
 }
 
+classMap.Match = Match;
 export default Match;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================
 // @ts-check