@lcap/nasl 3.6.0-alpha.1 → 3.6.0-alpha.2

package/src/concepts/CallEvent__.ts

@@ -0,0 +1,351 @@
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  createCompilerState,
+  withSourceMapGenerator,
+  TranslatorGenerator,
+} from '../translator';
+import type Event from './Event__';
+import type Param from './Param__';
+import { BusinessComponent } from './BusinessComponent__';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+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 LogicItem from './LogicItem__';
+import type Argument from './Argument__';
+
+/**
+ * 触发事件
+ */
+@concept('触发事件')
+export class CallEvent extends LogicItem {
+  /** 类名 */
+  static readonly ConceptName: string = 'CallEvent';
+
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'CallEvent';
+
+  /**
+   * 触发事件标题
+   */
+  @property()
+  label: string = '触发事件';
+
+  /**
+   * calleeNamespace
+   */
+  @property()
+  calleeNamespace!: string;
+
+  /**
+   * calleeName
+   */
+  @property()
+  calleeName!: string;
+
+  /**
+   * 参数
+   */
+  @property({
+    objectRef: 'Argument',
+    isArray: true,
+    defaultValue: [],
+  })
+  arguments: Array<Argument> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<CallEvent>) {
+    source = Object.assign({}, CallEvent.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): CallEvent {
+    return super.from(source, parentNode, parentKey) as CallEvent;
+  }
+
+  /**
+   * 设置calleeName
+   */
+  setCalleeName(calleeName: string) {
+    const object = {
+      calleeName,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 插入实际参数
+   * @internal
+   * @param argumentOptions 实际参数参数
+   */
+  _insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
+
+  /**
+   * 插入实际参数
+   * @internal
+   * @param argument 已有的实际参数实例
+   */
+  _insertArgumentAt(argument: Argument, index: number): Argument;
+
+  _insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
+    const argumentOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'arguments' };
+    const Argument = getConceptConstructor('Argument');
+    let argument: Argument;
+    if (asserts.isArgument(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      argument = options;
+      Object.assign(argument, relationOptions);
+    } else {
+      argument = Argument.from(
+        {
+          ...argumentOptions,
+          ...options,
+        },
+        this,
+        'arguments',
+      );
+    }
+    this.arguments.splice(index, 0, argument);
+    return argument;
+  }
+
+  /**
+   * 插入实际参数
+   * @param argumentOptions 实际参数参数
+   */
+  insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
+
+  /**
+   * 插入实际参数
+   * @param argument 已有的实际参数实例
+   */
+  insertArgumentAt(argument: Argument, index: number): Argument;
+
+  insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
+    const node = this._insertArgumentAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'arguments',
+    });
+    return node;
+  }
+
+  /**
+   * 添加实际参数
+   * @internal
+   * @param argumentOptions 实际参数参数
+   */
+  _addArgument(argumentOptions: Partial<Argument>): Argument;
+
+  /**
+   * 添加实际参数
+   * @internal
+   * @param argument 已有的实际参数实例
+   */
+  _addArgument(argument: Argument): Argument;
+
+  _addArgument(options?: Partial<Argument> | Argument) {
+    const index = this.arguments.length;
+    return this._insertArgumentAt(options as any, index);
+  }
+
+  /**
+   * 添加实际参数
+   * @param argumentOptions 实际参数参数
+   */
+  addArgument(argumentOptions: Partial<Argument>): Argument;
+
+  /**
+   * 添加实际参数
+   * @param argument 已有的实际参数实例
+   */
+  addArgument(argument: Argument): Argument;
+
+  addArgument(options?: Partial<Argument> | Argument) {
+    const node = this._addArgument(options as any);
+    const index = this.arguments.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'arguments',
+    });
+    return node;
+  }
+
+  /**
+   * 删除实际参数
+   * @param argument 已有的实际参数实例
+   */
+  removeArgument(argument: Argument): void;
+
+  removeArgument(options: Argument) {
+    let argument: Argument = options;
+    return argument.delete();
+  }
+
+  __removeLogicItem(logicItem: LogicItem) {
+    const parentKey = logicItem.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: logicItem,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      const n = logicItem.__v_raw || logicItem;
+      if (Array.isArray((t as any)[parentKey])) {
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
+      }
+    }
+    return params;
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+  get businessComponent() {
+    return this.getAncestor('BusinessComponent') as BusinessComponent;
+  }
+
+  // 设置触发的事件
+  setCallee(event: Event) {
+    const Argument = getConceptConstructor('Argument');
+    const Identifier = getConceptConstructor('Identifier');
+    const calleeName = event.name;
+    const params = event?.params?.map((param) => {
+      const relationOptions = { parentNode: this, parentKey: 'arguments' };
+      const argument = Argument.from(
+        {
+          keyword: param.name,
+          expression: param.isFunction ? new Identifier() : param.defaultExpression,
+        },
+        this,
+      );
+      Object.assign(argument, relationOptions);
+      return argument;
+    });
+    this.update({
+      calleeName,
+      arguments: params,
+      folded: false,
+    });
+  }
+
+  // 被调用的事件
+  getCallNode(): Event | undefined {
+    return this.businessComponent?.events?.find((event: Event) => event.name === this.calleeName);
+  }
+
+  // 实参列表
+  get completeArguments() {
+    const callArguments = (this.arguments ?? []).slice();
+    // 没有参数时可以跳过查询原逻辑标签
+    const node = callArguments.length > 0 ? this.getCallNode() : undefined;
+    const logicParams = node?.params ?? [];
+
+    callArguments.forEach((arg, index) => {
+      const param = logicParams[index] || ({} as Param);
+      arg.paramRequired = Boolean(!param?.defaultValue?.expression);
+      arg.paramTypeAnnotation = undefined;
+      arg.paramDefaultValue = undefined;
+      // 强制更新当前的 keyword
+      arg.keyword = param?.name && param.name.length > 0 ? param.name : arg.keyword;
+      // 取到是不是必填放入参数中
+      if (param && !arg.expression) {
+        // 非必填时 才会有默认值
+        arg.paramTypeAnnotation = param.typeAnnotation;
+        arg.paramDefaultValue = param.defaultValue;
+      }
+    });
+
+    return callArguments;
+  }
+
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    const { calleeName, completeArguments, arguments: eventArgs } = self;
+    let code = `(this as ${this.businessComponent.name}).${calleeName ?? '__IDENTIFIER__'}(`;
+    if (completeArguments?.length) {
+      yield* wrapForEach(completeArguments, function* warpForEachGenerator(arg, index) {
+        // 取到是不是必填放入参数中
+        code += yield* arg.toEmbeddedTS(shiftState(state, code), arg?.paramRequired);
+        if (index !== eventArgs.length - 1) code += ', ';
+      });
+    }
+    code += ')';
+    code += '\n';
+    return code;
+  }
+
+  toJS(state?: TranslatorState): string {
+    const { completeArguments = [] } = this;
+    let code = '';
+    code += `this.$emit('${this.calleeName}', {\n`;
+    if (Array.isArray(completeArguments) && completeArguments.length) {
+      const eventNode = this.getCallNode();
+      const eventParams = eventNode?.params;
+      completeArguments.forEach((arg, index) => {
+        let argStr = arg?.toJS(shiftState(state, code));
+        const paramDefaultValue = eventParams?.[index]?.defaultValue?.toJS?.();
+        if (paramDefaultValue) {
+          argStr = `${argStr} !== undefined ? ${argStr} : ${paramDefaultValue}`;
+        }
+        code += `${arg.keyword}: ${argStr}`;
+        if (index !== completeArguments?.length - 1) {
+          code += ', ';
+        }
+      });
+    }
+    code += '\n})';
+    return code;
+  }
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default CallEvent;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/CallFunction__.ts

@@ -16,7 +16,6 @@ import type Function from './Function__';
 import { ElementToVueOptions } from './ViewElement__';
 import type Identifier from './Identifier__';
 import { getBuildInFunction } from '../server/getFunctions';
-import type AnonymousFunction from './AnonymousFunction__';
 import type MemberExpression from './MemberExpression__';
 import asyncFuncMap from '../common/asyncFuncMap';
 
@@ -527,10 +526,18 @@ export class CallFunction extends LogicItem {
 
     code += ')';
     const tyAnno = (this as any).typeAnnotation || this.__TypeAnnotation;
+    let { sortedTypeKey, typeKind, typeName, typeNamespace } = tyAnno || {};
+    if (typeNamespace?.endsWith('.metadataTypes')) {
+      const referenceNode = this.app.findNodeByCompleteName(typeNamespace + '.' + typeName) || {};
+      const typeAn = referenceNode.typeAnnotation || {};
+      sortedTypeKey = `${typeAn.typeNamespace}.${typeAn.typeName}`;
+      typeKind = typeAn.typeKind;
+      typeName = typeAn.typeName;
+    }
     const needGenInitFromSchema =
-      tyAnno && (!['primitive', 'union'].includes(tyAnno.typeKind) || tyAnno.typeName === 'DateTime');
+      tyAnno && (!['primitive', 'union'].includes(typeKind) || typeName === 'DateTime');
     if (needGenInitFromSchema) {
-      code = `this.$genInitFromSchema('${tyAnno?.sortedTypeKey}', ${code})`;
+      code = `this.$genInitFromSchema('${sortedTypeKey}', ${code})`;
     }
     return code;
   }
@@ -713,16 +720,6 @@ export class CallFunction extends LogicItem {
     return code;
   }
 
-  checkParamNameOfAnonymousFunction() {
-    const fns = this.arguments
-      .map((arg) => arg.expression)
-      .filter((exp) => asserts.isAnonymousFunction(exp)) as unknown as AnonymousFunction[];
-
-    fns.forEach((fn) => {
-      fn.checkParamName();
-    });
-  }
-
   getQuickInfoOffset(range: Range, getCode: GetCode) {
     return getCallExpressionQuickInfo(range, getCode);
   }

package/src/concepts/CallLogic__.ts

@@ -591,7 +591,7 @@ export class CallLogic extends LogicItem {
   _setCallee(logic: Logic) {
     const BaseNode = getBaseNode();
     this.calleeNamespace = logic.getNamespace();
-    if (asserts.isView(logic.parentNode)) {
+    if (asserts.isView(logic.parentNode) || asserts.isBusinessComponent(logic.parentNode)) {
       this.calleeNamespace = '';
     }
     this.calleeName = logic.name;
@@ -615,7 +615,7 @@ export class CallLogic extends LogicItem {
 
   setCallee(logic: Logic) {
     let calleeNamespace = logic?.getNamespace() || '';
-    if (asserts.isView(logic.parentNode)) {
+    if (asserts.isView(logic.parentNode) || asserts.isBusinessComponent(logic.parentNode)) {
       calleeNamespace = '';
     }
     const calleeName = logic.name;
@@ -773,23 +773,23 @@ export class CallLogic extends LogicItem {
           code += calleeName;
         }
         return code;
-      } else if (bindAttr?.name === 'text') {
-        if (calleeName === 'jsonSerialize') {
-          if (
-            this.arguments[0]?.expression?.__TypeAnnotation?.typeName === 'String' &&
-            this.arguments[0]?.expression?.__TypeAnnotation?.typeNamespace === 'nasl.core'
-          ) {
-            code += options?.finalCode === false ? 'JSON 序列化' : 'JSON.stringify';
-          } else {
-            code += options?.finalCode === false ? 'JSON 序列化' : `$utils['JsonSerialize']`;
-          }
-          setArguments();
-          return code;
-        } else if (calleeName === 'jsonDeserialize') {
-          code += options?.finalCode === false ? 'JSON 反序列化' : 'JSON.parse';
-          setArguments();
-          return code;
+      }
+      if (calleeName === 'jsonSerialize') {
+        if (
+          this.arguments[0]?.expression?.__TypeAnnotation?.typeName === 'String' &&
+          this.arguments[0]?.expression?.__TypeAnnotation?.typeNamespace === 'nasl.core'
+        ) {
+          code += options?.finalCode === false ? 'JSON 序列化' : 'JSON.stringify';
+        } else {
+          code += options?.finalCode === false ? 'JSON 序列化' : `$utils['JsonSerialize']`;
         }
+        setArguments();
+        return code;
+      }
+      if (calleeName === 'jsonDeserialize') {
+        code += options?.finalCode === false ? 'JSON 反序列化' : 'JSON.parse';
+        setArguments();
+        return code;
       }
     }
 
@@ -815,12 +815,11 @@ export class CallLogic extends LogicItem {
 
       if (bindAttr?.name === 'data-source') {
         return this.calleeName;
-      } else if (bindAttr?.name === 'text') {
-        if (calleeName === 'jsonSerialize') {
-          return 'JSON 序列化';
-        } else if (calleeName === 'jsonDeserialize') {
-          return 'JSON 反序列化';
-        }
+      }
+      if (calleeName === 'jsonSerialize') {
+        return 'JSON 序列化';
+      } if (calleeName === 'jsonDeserialize') {
+        return 'JSON 反序列化';
       }
     }
 
@@ -907,9 +906,8 @@ export class CallLogic extends LogicItem {
       const args = logic?.params || [];
       const keywordEntitiesIndex = findConceptKeyWordIndexFromNamespace(this.calleeNamespace, 'entities');
 
-      code += `this.$logics['${
-        this.calleeNamespace ? `${this.calleeNamespace}.${this.calleeName}` : this.calleeName
-      }']`;
+      code += `this.$logics['${this.calleeNamespace ? `${this.calleeNamespace}.${this.calleeName}` : this.calleeName
+        }']`;
       code += `({
                 config: {
                     download: false,
@@ -1193,11 +1191,17 @@ export class CallLogic extends LogicItem {
       };
     }
     const typeAnnotation = (this as any).typeAnnotation || this.__TypeAnnotation;
-    const needGenInitFromSchema =
-      typeAnnotation &&
-      (!['primitive', 'union'].includes(typeAnnotation.typeKind) || typeAnnotation.typeName === 'DateTime');
+    let { sortedTypeKey, typeKind, typeName, typeNamespace } = typeAnnotation || {};
+    if (typeNamespace?.endsWith('.metadataTypes')) {
+      const referenceNode = this.app.findNodeByCompleteName(typeNamespace + '.' + typeName) || {};
+      const typeAn = referenceNode.typeAnnotation || {};
+      sortedTypeKey = `${typeAn.typeNamespace}.${typeAn.typeName}`;
+      typeKind = typeAn.typeKind;
+      typeName = typeAn.typeName;
+    }
+    const needGenInitFromSchema = typeAnnotation && (!['primitive', 'union'].includes(typeKind) || typeName === 'DateTime');
     if (needGenInitFromSchema) {
-      code = `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', ${code})`;
+      code = `this.$genInitFromSchema('${sortedTypeKey}', ${code})`;
     }
     code += ')';
     return code;
@@ -1217,6 +1221,10 @@ export class CallLogic extends LogicItem {
     return Boolean(this.handleError || this.useValidation);
   }
 
+  get businessComponent() {
+    return this.getAncestor('BusinessComponent');
+  }
+
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
@@ -1351,6 +1359,11 @@ export class CallLogic extends LogicItem {
       yield* setInputParam();
       code += ';\n})()';
     } else {
+      // 属于业务组件
+      const belongBusinessComponent = !!this.businessComponent;
+      if (belongBusinessComponent && !self.calleeNamespace) {
+        code += `(this as ${this.businessComponent.name}).`;
+      }
       code += calleeKey;
       yield* setTypeArguments();
       yield* setInputParam();
@@ -1508,7 +1521,7 @@ export class CallLogic extends LogicItem {
             state: Array.isArray(t) ? 2 : 1,
           };
         });
-      } catch (err) {}
+      } catch (err) { }
     }
     return node;
   }

package/src/concepts/Constant__.ts

@@ -347,15 +347,13 @@ export class Constant extends BaseNode {
     }
     if (this.typeAnnotation) {
       code += `: `;
-      if (
-        this.defaultValue?.expression &&
-        !(this.typeAnnotation && ['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(typeKey))
-      ) {
-        code += `${yield* this.defaultValue.toEmbeddedTS(shiftState(state, code))}`;
-      } else {
-        if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(typeKey)) {
+      if (this.defaultValue?.expression) {
+        if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(this.typeAnnotation.typeKey)) {
           code += yield* this.defaultValue.toEmbeddedTS(shiftState(state, code), true);
+        } else {
+          code += `${yield* this.defaultValue.toEmbeddedTS(shiftState(state, code))}`;
         }
+      } else {
         code += 'undefined';
       }
       code += ' as ';

package/src/concepts/Destination__.ts

@@ -358,7 +358,8 @@ export class Destination extends LogicItem {
     if (this.viewName) {
       viewArr.push(this.viewName);
     }
-    // 第一个是端名，需要去掉
+    // 端名和端类型名都需要去掉
+    viewArr.shift();
     viewArr.shift();
     return viewArr;
   }
@@ -367,7 +368,7 @@ export class Destination extends LogicItem {
     let code = '';
     const viewArr = this.genViewArr();
     if (Array.isArray(viewArr) && viewArr.length) {
-      code += `let url = '${this.viewNode.frontend.prefixPath ? this.viewNode.frontend.prefixPath : ''}/${viewArr.join(
+      code += `let url = '${this.viewNode?.frontend?.prefixPath ? this.viewNode.frontend.prefixPath : ''}/${viewArr.join(
         '/',
       )}';\n`;
       const { completeArguments } = this;
@@ -690,20 +691,21 @@ export class Destination extends LogicItem {
         }
       });
     }
+    console.log(viewNameAttr);
     if (this.viewNode) {
-      return `${this.viewNode.frontend.prefixPath}/${viewNameAttr.join('/')}`;
+      return `${this.viewNode?.frontend?.prefixPath}/${viewNameAttr.join('/')}`;
     }
     return `/${viewNameAttr.join('/')}`;
   }
 
   @withSourceMapGenerator
-  *toEmbeddedTSInProcess(state = createCompilerState(), prependCode: string): TranslatorGenerator {
+  *toEmbeddedTSInProcess(state = createCompilerState(), prevCode: string): TranslatorGenerator {
     const self = this;
     // const tab = indent((state?.tabSize || 0));
     if (self.tsCalleeNamespace && self.tsName) {
       const destinationName = self.parentNode.name.replace('-', '_');
       let code = `${destinationName}: function() {\n`;
-      code += prependCode;
+      code += prevCode;
       code += '\n';
       if (self.tsCalleeNamespace && self.viewName) {
         code += `${self.tsCalleeNamespace}.${self.viewName}.$destination({`;

package/src/concepts/End__.ts

@@ -99,6 +99,7 @@ export class End extends LogicItem {
         // 旧逻辑默认走这里，
         // 期望后期可以直接走完整的case， default 直接抛出异常好更明确定位错误
         logic =
+          self.getAncestor('BusinessLogic') ||
           self.parentNode.getAncestor('Logic') ||
           self.parentNode.getAncestor('AuthLogic') ||
           self.parentNode.getAncestor('AuthLogicForCallInterface') ||