@lcap/nasl 3.4.0-beta.6 → 3.5.0-alpha.1

package/src/concepts/Match__.ts

@@ -9,38 +9,40 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import TypeAnnotation, { isUnion } from './TypeAnnotation__';
-import BooleanLiteral from './BooleanLiteral__';
-import MemberExpression from './MemberExpression__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type BooleanLiteral from './BooleanLiteral__';
+import type ViewElement from './ViewElement__';
+import type BaseNode from '../common/BaseNode';
 import { formatEnums } from '../server/getMemberIdentifier';
 import Identifier from './Identifier__';
-import ViewElement from './ViewElement__';
+import Enum from './Enum__';
+import EnumItem from './EnumItem__';
+import { languageList } from '../utils/i18nInfo';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
-import BaseNode from '../common/BaseNode';
 import LogicItem from './LogicItem__';
-import MatchCase from './MatchCase__';
+import type MatchCase from './MatchCase__';
 
 /**
  * 匹配
  */
-@className
 @concept('匹配')
-// @ts-ignore
 export class Match extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'Match';
+  static readonly ConceptName: string = 'Match';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -55,7 +57,6 @@ export class Match extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  // @ts-ignore
   expression!: LogicItem;
 
   /**
@@ -104,8 +105,9 @@ export class Match extends LogicItem {
   _insertMatchCaseAt(options: Partial<MatchCase> | MatchCase, index: number) {
     const matchCaseOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'cases' };
+    const MatchCase = getConceptConstructor('MatchCase');
     let matchCase: MatchCase;
-    if (options instanceof MatchCase) {
+    if (asserts.isMatchCase(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       matchCase = options;
       Object.assign(matchCase, relationOptions);
@@ -281,10 +283,10 @@ export class Match extends LogicItem {
           const { patterns } = caseItem || {};
           if (Array.isArray(patterns)) {
             patterns.forEach((pattern) => {
-              if (pattern instanceof TypeAnnotation) {
+              if (asserts.isTypeAnnotation(pattern)) {
                 const patternTypeKey = pattern.typeKey;
                 map[patternTypeKey] = true;
-              } else if (pattern instanceof MemberExpression || pattern instanceof BooleanLiteral) {
+              } else if (asserts.isMemberExpression(pattern) || asserts.isBooleanLiteral(pattern)) {
                 const patternValue = pattern.getValue();
                 map[patternValue] = true;
               }
@@ -304,6 +306,8 @@ export class Match extends LogicItem {
   async getEnumerableItems(typeAnnotation?: TypeAnnotation) {
     const { expression } = this;
     let currTypeAnnotation = typeAnnotation;
+    const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+    const BooleanLiteral = getConceptConstructor('BooleanLiteral');
     if (!currTypeAnnotation) {
       currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
     }
@@ -311,7 +315,7 @@ export class Match extends LogicItem {
     if (typeKind === 'union' && Array.isArray(typeArguments)) {
       return typeArguments.map((typeArg) => {
         let typeArgJson: any = typeArg;
-        if (typeArg instanceof TypeAnnotation) {
+        if (asserts.isTypeAnnotation(typeArg)) {
           typeArgJson = typeArg.toJSON();
         }
         return new TypeAnnotation(typeArgJson);
@@ -322,6 +326,25 @@ export class Match extends LogicItem {
       if (typeNamespace) {
         nameArr.unshift(typeNamespace);
       }
+      // 特殊逻辑处理国际化枚举先，后续会删掉
+      if (typeNamespace === 'app.enums' && typeName === '_naslI18nEnum') {
+        const enumItems = languageList.map((language) => {
+          return new EnumItem({
+            label: language.title,
+            value: language.id,
+          });
+        });
+        const newEnum = new Enum({
+          name: '_naslI18nEnum',
+          enumItems: enumItems,
+        });
+        Enum.from(newEnum, this.app, 'enums');
+        const enums = formatEnums([newEnum]);
+        const { children } = enums?.[0] || {};
+        if (Array.isArray(children)) {
+          return children.map((child) => child?.expression);
+        }
+      }
       const typeNode = this.app.findNodeByCompleteName(nameArr.join('.')) || {};
       if (typeNode.concept === 'Enum') {
         const enums = formatEnums([typeNode]);
@@ -464,6 +487,7 @@ export class Match extends LogicItem {
 
   // jflow缓存模式下的传过来参数
   async autoGenCasesAST({ oldAst, cacheType }: any) {
+    const LogicItem = getConceptConstructor('LogicItem');
     let obj;
     try {
       obj = JSON.parse(oldAst);
@@ -476,6 +500,7 @@ export class Match extends LogicItem {
   async changeGenCases() {
     const { expression } = this;
     const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+    const MatchCase = getConceptConstructor('MatchCase');
     let cases: MatchCase[] = [];
     let isMatchedTypeEnumable = false;
     if (currTypeAnnotation) {
@@ -715,7 +740,7 @@ export class Match extends LogicItem {
     if (self.expression) {
       code += indent(state?.tabSize || 0);
       // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
-      if (self.expression instanceof Identifier || self.expression instanceof MemberExpression) {
+      if (asserts.isIdentifier(self.expression) || asserts.isMemberExpression(self.expression)) {
         code += parentCode = yield* self.expression.toEmbeddedTS(shiftState(state, code));
       } else {
         parentCode = '__matchExpression';
@@ -765,14 +790,14 @@ export class Match extends LogicItem {
     if (this.parentNode?.concept === 'Logic') {
       code += '\n';
     }
-    code += indent(state.tabSize);
+    code += indent(state?.tabSize || 0);
     code += '(function match(_value) { \n';
     let parentCode: string;
     if (this.expression) {
-      code += indent(state.tabSize + 1);
+      code += indent((state?.tabSize || 0) + 1);
       // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
-      if (this.expression instanceof Identifier || this.expression instanceof MemberExpression) {
-        parentCode = this.expression.toNaturalTS(shiftState(state, code, { inline: true }));
+      if (asserts.isIdentifier(this.expression) || asserts.isMemberExpression(this.expression)) {
+        parentCode = this.expression?.toNaturalTS(shiftState(state, code, { inline: true }));
       } else {
         parentCode = '_value';
       }
@@ -781,9 +806,9 @@ export class Match extends LogicItem {
     // 最后一项是else
     this.cases.forEach((item, index) => {
       // 如果是最后一项
-      code += item.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }), index, parentCode);
+      code += item.toNaturalTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }), index, parentCode);
     });
-    code += indent(state.tabSize);
+    code += indent(state?.tabSize || 0);
     code += `})(${this.expression?.toNaturalTS(shiftState(state, code, { inline: true }))})`;
 
     if (

package/src/concepts/MemberExpression__.ts

@@ -10,10 +10,11 @@ import {
 } from '../translator';
 import { Enum, TypeAnnotation } from '..';
 import { ElementToVueOptions } from './ViewElement__';
-import Identifier from './Identifier__';
+import type Identifier from './Identifier__';
 import BindAttribute, { attrConvertCamelCase } from './BindAttribute__';
-import Assignment from './Assignment__';
-import BatchAssignment from './BatchAssignment__';
+import type Assignment from './Assignment__';
+import type BatchAssignment from './BatchAssignment__';
+import DefaultValue from './DefaultValue__';
 
 const Identifier_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
@@ -22,6 +23,7 @@ const atrrParamsMap: Record<string, string> = {
   size: 'pageSize',
   sort: 'sorting.field',
   order: 'sorting.order',
+  filterText: 'filterText',
 };
 
 //================================================================================
@@ -29,25 +31,24 @@ const atrrParamsMap: Record<string, string> = {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
-import BaseNode from '../common/BaseNode';
 import LogicItem from './LogicItem__';
 
 /**
  * 成员表达式
  */
-@className
 @concept('成员表达式')
-// @ts-ignore
 export class MemberExpression extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'MemberExpression';
+  static readonly ConceptName: string = 'MemberExpression';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -62,7 +63,6 @@ export class MemberExpression extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  // @ts-ignore
   object!: LogicItem;
 
   /**
@@ -71,7 +71,6 @@ export class MemberExpression extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  // @ts-ignore
   property!: LogicItem;
 
   /**
@@ -191,7 +190,7 @@ export class MemberExpression extends LogicItem {
       return `Object.keys(${this.object?.toJS()}).length`;
     }
     if (
-      this.object instanceof Identifier &&
+      asserts.isIdentifier(this.object) &&
       this.object?.namespace?.startsWith('elements.') &&
       this.object?.namespace?.endsWith('.property')
     ) {
@@ -206,7 +205,7 @@ export class MemberExpression extends LogicItem {
       }
       let propertyName = '';
       let subProperty = '';
-      if (this.property instanceof Identifier && this.property?.namespace) {
+      if (asserts.isIdentifier(this.property) && this.property?.namespace) {
         const namespace = this.property?.namespace ?? '';
         const namespaceList = namespace?.includes('.') ? namespace?.split('.') : [namespace];
         propertyName = namespaceList[0];
@@ -214,7 +213,7 @@ export class MemberExpression extends LogicItem {
       }
       return `__${elementName}_${attrConvertCamelCase(propertyName)}${subProperty}`;
     } else if (
-      this.object instanceof MemberExpression &&
+      asserts.isMemberExpression(this.object) &&
       this.object?.object?.name === 'elements' &&
       this.object?.property?.name === '$ce'
     ) {
@@ -258,9 +257,9 @@ export class MemberExpression extends LogicItem {
     if (paramsMap[this.property.name]) {
       this.property.name = paramsMap[this.property.name];
     }
-    if (this.object instanceof Identifier && property === '$ce' && object === 'elements') return;
+    if (asserts.isIdentifier(this.object) && property === '$ce' && object === 'elements') return;
     if (
-      this.object instanceof MemberExpression &&
+      asserts.isMemberExpression(this.object) &&
       this.object?.object?.name === 'elements' &&
       this.object?.property?.name === '$ce'
     ) {
@@ -270,24 +269,24 @@ export class MemberExpression extends LogicItem {
     return Identifier_RE.test(property) ? `${object}.${property}` : `${object}['${property}']`;
   }
 
-  toJS(): string {
+  toJS(state?: TranslatorState): string {
     //  如果是枚举取值
     if (
       this.object?.concept === 'Identifier' &&
       (this.object as Identifier)?.isEnum() &&
       this.property?.concept === 'Identifier'
     ) {
-      return `"${this.property?.name}"`;
+      return this.isDefaultValueExpression() ? this.property?.name : `"${this.property?.name}"`;
     }
     if (
       this.object?.__TypeAnnotation?.sortedTypeKey?.startsWith('nasl.collection.Map') &&
       this.property?.name === 'length'
     ) {
-      return `Object.keys(${this.object?.toJS()}).length`;
+      return `Object.keys(${this.object?.toJS(state)}).length`;
     }
     if (
-      this.object instanceof Identifier &&
-      this.property instanceof Identifier &&
+      asserts.isIdentifier(this.object) &&
+      asserts.isIdentifier(this.property) &&
       this.object?.namespace?.startsWith('elements.') &&
       this.object?.namespace?.endsWith('.property')
     ) {
@@ -302,7 +301,7 @@ export class MemberExpression extends LogicItem {
       }
       let propertyName = '';
       let subProperty = '';
-      if (this.property instanceof Identifier && this.property?.namespace) {
+      if (asserts.isIdentifier(this.property) && this.property?.namespace) {
         const namespace = this.property?.namespace ?? '';
         const namespaceList = namespace?.includes('.') ? namespace?.split('.') : [namespace];
         propertyName = namespaceList[0];
@@ -310,14 +309,14 @@ export class MemberExpression extends LogicItem {
       }
       return `this['__${elementName}_${attrConvertCamelCase(propertyName)}']${subProperty}`;
     } else if (
-      this.object instanceof MemberExpression &&
+      asserts.isMemberExpression(this.object) &&
       this.object?.object?.name === 'elements' &&
       this.object?.property?.name === '$ce'
     ) {
       return this.transfromAtrrLogic();
     }
-    const object: string = this.object?.toJS();
-    const property = this.property?.toJS();
+    const object: string = this.object?.toJS(state);
+    const property = this.property?.toJS(state);
     // 在赋值语句的左侧，不能有 &&
     const assignment: Assignment = this.getAncestor('Assignment') as Assignment;
     const batchAssignment: BatchAssignment = this.getAncestor('BatchAssignment') as BatchAssignment;
@@ -380,6 +379,10 @@ export class MemberExpression extends LogicItem {
     return (this.object as Identifier)?.isEnum?.();
   }
 
+  isDefaultValueExpression() {
+    return this.parentNode instanceof DefaultValue;
+  }
+
   // 方便快速取值,遍历获取value
   getValue() {
     let current: any = this;
@@ -479,7 +482,7 @@ export class MemberExpression extends LogicItem {
       code = newCode;
     }
     if (
-      self.object instanceof Identifier &&
+      asserts.isIdentifier(self.object) &&
       self.object?.namespace?.startsWith('elements.') &&
       self.object?.namespace?.endsWith('.property')
     ) {
@@ -487,7 +490,7 @@ export class MemberExpression extends LogicItem {
       if (self.object?.namespace?.startsWith('elements.$ce')) {
         const elementName = self.getAncestor('ViewElement')?.name;
         newCode += `__elements_completionProperty.${elementName}`;
-        if (self.property instanceof Identifier && self.property?.namespace) {
+        if (asserts.isIdentifier(self.property) && self.property?.namespace) {
           const namespace = self.property?.namespace ?? '';
           const namespaceList = namespace?.includes('.') ? namespace?.split('.') : [namespace];
           yield* wrapForEach(namespaceList, function* warpForEachGenerator(item) {
@@ -496,7 +499,7 @@ export class MemberExpression extends LogicItem {
         }
       } else {
         newCode += `__elements_completionProperty.${self.object?.name}`;
-        if (self.property instanceof Identifier && self.property?.namespace) {
+        if (asserts.isIdentifier(self.property) && self.property?.namespace) {
           const namespace = self.property?.namespace ?? '';
           const namespaceList = namespace?.includes('.') ? namespace?.split('.') : [namespace];
           yield* wrapForEach(namespaceList, function* warpForEachGenerator(item) {
@@ -507,7 +510,7 @@ export class MemberExpression extends LogicItem {
       return newCode;
     }
     if (
-      self.object instanceof MemberExpression &&
+      asserts.isMemberExpression(self.object) &&
       self.object?.object?.name === 'elements' &&
       self.object?.property?.name === '$ce'
     ) {

package/src/concepts/MetadataType__.ts

@@ -10,36 +10,36 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import Namespace from './Namespace__';
+import type Namespace from './Namespace__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import TypeAnnotation from './TypeAnnotation__';
-import ValidationRule from './ValidationRule__';
-import LogicItem from './LogicItem__';
-import Module from './Module__';
-import App from './App__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type ValidationRule from './ValidationRule__';
+import type LogicItem from './LogicItem__';
+import type Module from './Module__';
+import type App from './App__';
 
 /**
  * 元数据类型
  */
-@className
 @concept('元数据类型')
-// @ts-ignore
 export class MetadataType extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'MetadataType';
+  static readonly ConceptName: string = 'MetadataType';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -52,7 +52,6 @@ export class MetadataType extends BaseNode {
    * 名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
@@ -65,7 +64,6 @@ export class MetadataType extends BaseNode {
    * 描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
@@ -74,16 +72,8 @@ export class MetadataType extends BaseNode {
   @property({
     objectRef: 'TypeAnnotation',
   })
-  // @ts-ignore
   typeAnnotation!: TypeAnnotation;
 
-  /**
-   * 是否必填
-   */
-  @property()
-  // @ts-ignore
-  required!: boolean;
-
   /**
    * 验证规则
    */
@@ -147,17 +137,6 @@ export class MetadataType extends BaseNode {
     }
     return params;
   }
-  /**
-   * 设置是否必填
-   */
-  setRequired(required: boolean) {
-    const object = {
-      required,
-    };
-    this.update({
-      ...object,
-    });
-  }
 
   getValidationRuleExistingNames(excludedList: Array<ValidationRule> = []) {
     const excludedSet = new Set(excludedList);
@@ -191,6 +170,7 @@ export class MetadataType extends BaseNode {
   _insertValidationRuleInRulesAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
     const validationRuleOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'rules' };
+    const ValidationRule = getConceptConstructor('ValidationRule');
     let validationRule: ValidationRule;
     if (!options) {
       validationRule = ValidationRule.from(
@@ -210,7 +190,7 @@ export class MetadataType extends BaseNode {
         this,
         'rules',
       );
-    } else if (options instanceof ValidationRule) {
+    } else if (asserts.isValidationRule(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       validationRule = options;
       Object.assign(validationRule, relationOptions);
@@ -329,8 +309,9 @@ export class MetadataType extends BaseNode {
   _insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'playground' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (options instanceof LogicItem) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);

package/src/concepts/MicroApp__.ts

@@ -3,24 +3,24 @@
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 
 /**
  * 微应用
  */
-@className
 @concept('微应用')
-// @ts-ignore
 export class MicroApp extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'MicroApp';
+  static readonly ConceptName: string = 'MicroApp';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -33,49 +33,42 @@ export class MicroApp extends BaseNode {
    * 微前端框架
    */
   @property()
-  // @ts-ignore
   framework!: 'qiankun' | 'icestark';
 
   /**
    * 微应用名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 页面路径前缀
    */
   @property()
-  // @ts-ignore
   routePrefix!: string;
 
   /**
    * 接口和静态资源前缀
    */
   @property()
-  // @ts-ignore
   proxyPrefix!: string;
 
   /**
    * 登录页面地址
    */
   @property()
-  // @ts-ignore
   loginUrl!: string;
 
   /**
    * 无权限页面地址
    */
   @property()
-  // @ts-ignore
   noAuthUrl!: string;
 
   /**
    * 404页面地址
    */
   @property()
-  // @ts-ignore
   notFoundUrl!: string;
 
   /**