@lcap/nasl 3.5.0-beta.3 → 3.5.0-beta.5

package/src/concepts/BusinessComponent__.ts

@@ -1035,10 +1035,6 @@ export class BusinessComponent extends BaseNode {
     return node;
   }
 
-  getLogicExistingNames(excludedList: Array<BusinessLogic> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.logics as BusinessLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
-  }
   getLogicUniqueName(name = 'logic1') {
     return utils.unique(name, this.getLogicExistingNames(), undefined, false);
   }
@@ -1675,6 +1671,28 @@ export class BusinessComponent extends BaseNode {
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
+  getLogicExistingNames(excludedList: Array<Logic> = []) {
+    const excludedSet = new Set(excludedList);
+    const varList: any[] = [];
+    if (Array.isArray(this.params)) {
+      varList.push(...this.params);
+    }
+    if (Array.isArray(this.variables)) {
+      varList.push(...this.variables);
+    }
+    if (Array.isArray(this.logics)) {
+      varList.push(...this.logics);
+    }
+    if (Array.isArray(this.bindEvents)) {
+      this.bindEvents.forEach((bindEvent) => {
+        if (Array.isArray(bindEvent.logics)) {
+          varList.push(...bindEvent.logics);
+        }
+      });
+    }
+    return varList.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
   static getDefaultOptions() {
     return {
       title: '业务组件',
@@ -1813,6 +1831,23 @@ export class BusinessComponent extends BaseNode {
     });
   }
 
+  collectExistingBusinessComponent() {
+    const excludedSet = new Set();
+    // 先把自身加进去
+    excludedSet.add(this);
+    this.elements.forEach((element) => {
+      const set = element.collectExistingBusinessComponent();
+      if (set.size) {
+        set.forEach(value => {
+          if (!excludedSet.has(value)) {
+            excludedSet.add(value);
+          }
+        });
+      }
+    });
+    return excludedSet;
+  }
+
   // 获取当前业务组件的所有组件的名字
   getViewElementExistingNames(excludedList: Array<ViewElement> = []) {
     if (!this.existingViewElement.size) {
@@ -1875,14 +1910,17 @@ export class BusinessComponent extends BaseNode {
     }
   }
 
-  mergeBlock({ code, nodePath, position, cb }: { code: string; nodePath: string; position: string; cb?: Function }) {
+  mergeBlock({ code, nodePath, position, slotTarget, cb }: { code: string; nodePath: string; position: string; slotTarget?: string; cb?: Function }) {
     const ViewElement = getConceptConstructor('ViewElement');
     const Logic = getConceptConstructor('Logic');
     const ParamWithGroup = getConceptConstructor('ParamWithGroup');
     const Variable = getConceptConstructor('Variable');
     const BindEvent = getConceptConstructor('BindEvent');
     const Structure = getConceptConstructor('Structure');
-    const template = utils.sliceTagContent(code, 'template');
+    let template = utils.sliceTagContent(code, 'template');
+    if (slotTarget) {
+      template = `<template #${slotTarget}>${template}</template>`;
+    }
     let targetNode = (this.getAncestor('App') as App)?.findNodeByPath(nodePath);
     let parentNode = position === 'append' ? targetNode : targetNode.parentNode;
     const definitionStr = utils.sliceTagContent(code, 'definition') || '{}';
@@ -2242,100 +2280,12 @@ export class BusinessComponent extends BaseNode {
     // 获取虚拟logic的参数和内容
     // 用作展示和tots查找引用
     self.getElementLogicRoot();
-    let code = `export class ${self.tsName} extends nasl.ui.VueComponent {\n`;
-    // 需要类型推导的局部变量/返回值需要调整申明顺序
-    code += `constructor(
-      options?: {
-        [propname: string]: any,
-        bindAttr?: {
-          __NASLIF?: nasl.core.Boolean,
-    `;
-    if (Array.isArray(self.params)) {
-      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
-        code += `${param.name}?: `;
-        code += yield* param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
-        code += ',\n';
-      });
-    }
-    code += `
-        },
-        slotDefault?: () => Array<any>,
-      }) {
-        super();\n`;
-
-    // 绑定事件
-    if (Array.isArray(self.bindEvents)) {
-      yield* wrapForEach(self.bindEvents, function* warpForEachGenerator(event) {
-        code += yield* event.toEmbeddedTS(
-          shiftState(state, code, {
-            tabSize: state?.tabSize || 0,
-          }),
-          true,
-        );
-        code += '\n';
-      });
-    }
-    code += `\n}`;
-    // 自定义事件的定义
-    if (Array.isArray(self.events) && self.events.length) {
-      code += indent((state?.tabSize || 0) + 1);
-      yield* wrapForEach(self.events, function* warpForEachGenerator(event) {
-        code += yield* event.toEmbeddedTS(
-          shiftState(state, code, {
-            tabSize: (state?.tabSize || 0) + 2,
-          }),
-        );
-        code += '\n';
-      });
-      code += indent((state?.tabSize || 0) + 1);
-    }
-    // 逻辑
-    if (Array.isArray(self.logics) && self.logics.length) {
-      code += indent((state?.tabSize || 0) + 1);
-      yield* wrapForEach(self.logics, function* warpForEachGenerator(logic) {
-        code += yield* logic.toEmbeddedTS(
-          shiftState(state, code, {
-            tabSize: (state?.tabSize || 0) + 2,
-          }),
-          'noExport',
-        );
-        code += '\n';
-      });
-      code += indent((state?.tabSize || 0) + 1);
-    }
-    // render函数
-    code += `\n${indent((state?.tabSize || 0) + 1)}`;
-    code += `__render(`;
-    code += `){\n`;
-    code += indent(state?.tabSize || 0);
-    // elements 元素
-    if (Array.isArray(self.elements)) {
-      // 生成嵌套式的内容
-      yield* wrapForEach(self.elements, function* warpForEachGenerator(element) {
-        code += yield* element.toEmbeddedTS(
-          shiftState(state, code, {
-            tabSize: (state?.tabSize || 0) + 3,
-          }),
-        );
-        code += '\n';
-      });
-    }
-    code += `\n${indent((state?.tabSize || 0) + 1)}}\n`;
-    if (Array.isArray(self.params)) {
-      code += `${indent((state?.tabSize || 0) + 1)}$destination(options: {`;
-      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
-        code += `${param.name}?: `;
-        code += yield* param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
-        code += ', ';
-      });
-      // 锚点
-      code += `_anchor?: nasl.core.String`;
-      code += '}){}\n';
-    }
-    code += `${indent(state?.tabSize || 0)}}\n`;
 
+    /**
+     * 这部分需要先执行
+     **/
     // elements类型声明定义
-    code += `interface __elements {\n`;
+    let code = `interface __elements {\n`;
     // 生成所有的name和类型定义
     yield* wrapForEach(self.elements, function* warpForEachGenerator(element) {
       code += yield* element.toEmbeddedTSDefinition(
@@ -2407,7 +2357,7 @@ export class BusinessComponent extends BaseNode {
     const IDENTIFIERMAP = new Set<Variable>();
     if (Array.isArray(self.params)) {
       yield* wrapForEach(self.params, function* warpForEachGenerator(param) {
-        code += `let ${indent((state?.tabSize || 0) + 1)}`;
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
         code += yield* param.toEmbeddedTS(shiftState(state, code, { inline: true }));
         code += ';\n';
       });
@@ -2419,7 +2369,7 @@ export class BusinessComponent extends BaseNode {
           IDENTIFIERMAP.add(variable);
         }
         if (!advanceMap.get(variable)) {
-          code += `let ${indent((state?.tabSize || 0) + 1)}`;
+          code += `${indent((state?.tabSize || 0) + 1)}let `;
           code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
           code += ';\n';
         }
@@ -2486,6 +2436,7 @@ export class BusinessComponent extends BaseNode {
     code += '\n';
     code += `${indent((state?.tabSize || 0) + 2)}return\n`;
 
+
     function* setPlaygroundCode(arr: Variable[] | ParamWithGroup[], name: string) {
       if (arr.length) {
         code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是 ${name} 的默认值草稿------ */\n`;
@@ -2501,6 +2452,99 @@ export class BusinessComponent extends BaseNode {
     yield* setPlaygroundCode(self.variables, 'variables');
     yield* setPlaygroundCode(self.params, 'params');
 
+    code += `${indent(state?.tabSize || 0)}}\n`;
+
+    code += `export class ${self.tsName} extends nasl.ui.VueComponent {\n`;
+
+    // 需要类型推导的局部变量/返回值需要调整申明顺序
+    code += `constructor(
+      options?: {
+        [propname: string]: any,
+        bindAttr?: {
+          __NASLIF?: nasl.core.Boolean,
+    `;
+    if (Array.isArray(self.params)) {
+      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
+        code += `${param.name}?: `;
+        code += yield* param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+        code += ',\n';
+      });
+    }
+    code += `
+        },
+        slotDefault?: () => Array<any>,
+      }) {
+        super();\n`;
+
+    // 绑定事件
+    if (Array.isArray(self.bindEvents)) {
+      yield* wrapForEach(self.bindEvents, function* warpForEachGenerator(event) {
+        code += yield* event.toEmbeddedTS(
+          shiftState(state, code, {
+            tabSize: state?.tabSize || 0,
+          }),
+          true,
+        );
+        code += '\n';
+      });
+    }
+    code += `\n}`;
+    // 自定义事件的定义
+    if (Array.isArray(self.events) && self.events.length) {
+      code += indent((state?.tabSize || 0) + 1);
+      yield* wrapForEach(self.events, function* warpForEachGenerator(event) {
+        code += yield* event.toEmbeddedTS(
+          shiftState(state, code, {
+            tabSize: (state?.tabSize || 0) + 2,
+          }),
+        );
+        code += '\n';
+      });
+      code += indent((state?.tabSize || 0) + 1);
+    }
+    // 逻辑
+    if (Array.isArray(self.logics) && self.logics.length) {
+      code += indent((state?.tabSize || 0) + 1);
+      yield* wrapForEach(self.logics, function* warpForEachGenerator(logic) {
+        code += yield* logic.toEmbeddedTS(
+          shiftState(state, code, {
+            tabSize: (state?.tabSize || 0) + 2,
+          }),
+          'noExport',
+        );
+        code += '\n';
+      });
+      code += indent((state?.tabSize || 0) + 1);
+    }
+    // render函数
+    code += `\n${indent((state?.tabSize || 0) + 1)}`;
+    code += `__render(`;
+    code += `){\n`;
+    code += indent(state?.tabSize || 0);
+    // elements 元素
+    if (Array.isArray(self.elements)) {
+      // 生成嵌套式的内容
+      yield* wrapForEach(self.elements, function* warpForEachGenerator(element) {
+        code += yield* element.toEmbeddedTS(
+          shiftState(state, code, {
+            tabSize: (state?.tabSize || 0) + 3,
+          }),
+        );
+        code += '\n';
+      });
+    }
+    code += `\n${indent((state?.tabSize || 0) + 1)}}\n`;
+    if (Array.isArray(self.params)) {
+      code += `${indent((state?.tabSize || 0) + 1)}$destination(options: {`;
+      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
+        code += `${param.name}?: `;
+        code += yield* param.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+        code += ', ';
+      });
+      // 锚点
+      code += `_anchor?: nasl.core.String`;
+      code += '}){}\n';
+    }
     code += `${indent((state?.tabSize || 0) + 1)}}\n`;
     return code;
   }

package/src/concepts/CallConnector__.ts

@@ -279,6 +279,11 @@ export class CallConnector extends CallLogic {
     }
     return code;
   }
+
+  @withSourceMap()
+  toNaturalTS(state?: TranslatorState): string {
+      return '';
+  }
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/CallEvent__.ts

@@ -82,6 +82,18 @@ export class CallEvent extends LogicItem {
     return super.from(source, parentNode, parentKey) as CallEvent;
   }
 
+  /**
+   * 设置calleeName
+   */
+  setCalleeName(calleeName: string) {
+    const object = {
+      calleeName,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
   /**
    * 插入实际参数
    * @internal
@@ -291,7 +303,7 @@ export class CallEvent extends LogicItem {
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
     const { calleeName, completeArguments, arguments: eventArgs } = self;
-    let code = `this.${calleeName}(`;
+    let code = `(this as ${this.businessComponent.name}).${calleeName ?? '__IDENTIFIER__'}(`;
     if (completeArguments?.length) {
       yield* wrapForEach(completeArguments, function* warpForEachGenerator(arg, index) {
         // 取到是不是必填放入参数中
@@ -309,9 +321,14 @@ export class CallEvent extends LogicItem {
     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) => {
-        const argStr = arg?.toJS(shiftState(state, code));
-
+        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 += ', ';

package/src/concepts/CallFunction__.ts

@@ -563,12 +563,12 @@ export class CallFunction extends LogicItem {
   }
 
   setCallee(func: Function) {
-    const calleeNamespace = func.getNamespace();
-    const calleeName = func.name;
+    const calleeNamespace = func?.getNamespace?.();
+    const calleeName = func?.name;
     const Argument = getConceptConstructor('Argument');
     const TypeAnnotation = getConceptConstructor('TypeAnnotation');
     const BaseNode = getBaseNode();
-    const params = func.params.map((param) => {
+    const params = func?.params?.map?.((param) => {
       const relationOptions = { parentNode: this, parentKey: 'arguments' };
       const argument = Argument.from(
         {
@@ -696,7 +696,53 @@ export class CallFunction extends LogicItem {
     if (this.arguments.length <= 3) {
       code += '(';
       this.arguments.forEach((arg, index) => {
-        code += arg.toNaturalTS(shiftState(state, code, { tabSize: 0 }));
+        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 += arg.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+        }
+        if (index !== this.arguments.length - 1) {
+          code += ',\n';
+        } else if (this?.typeArguments?.[0]?.typeKind === 'reference') {
+          code += `,\n{ typeNamespace: '${this.typeArguments[0].typeNamespace}' }`;
+        } else {
+          code += '\n';
+        }
+      });
+      code += `${indent(state.tabSize)})`;
+    }
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = '';
+    code = this.calleeKey;
+    if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+      // 如果有内容
+      const typeAnnotation = this.typeArguments[0];
+      code += `<`;
+      code += `${typeAnnotation.toTextualNASL(shiftState(state, code, { tabSize: 0 }))}>`;
+    }
+    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 += ', ';
       });
       if (this?.typeArguments?.[0]?.typeKind === 'reference') {
@@ -707,7 +753,7 @@ export class CallFunction extends LogicItem {
     } else {
       code += '(\n';
       this.arguments.forEach((arg, index) => {
-        code += arg.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+        code += arg.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
         if (index !== this.arguments.length - 1) {
           code += ',\n';
         } else if (this?.typeArguments?.[0]?.typeKind === 'reference') {
@@ -723,10 +769,10 @@ export class CallFunction extends LogicItem {
 
   checkParamNameOfAnonymousFunction() {
     const fns = this.arguments
-      .map((arg) => arg.expression)
-      .filter((exp) => asserts.isAnonymousFunction(exp)) as unknown as AnonymousFunction[];
+      ?.map((arg) => arg.expression)
+      ?.filter((exp) => asserts.isAnonymousFunction(exp)) as unknown as AnonymousFunction[];
 
-    fns.forEach((fn) => {
+    fns?.forEach?.((fn) => {
       fn.checkParamName();
     });
   }

package/src/concepts/CallInterface__.ts

@@ -295,10 +295,10 @@ export class CallInterface extends LogicItem {
                   shouldDeleteStructures.push(stru);
                 }
               });
-              shouldDeleteStructures.forEach((s: Structure) => s.delete());
+              shouldDeleteStructures?.forEach?.((s: Structure) => s.delete());
             } else {
-              const shouldDeleteStructures = oldItf.getRefStructures(parentModule.structures);
-              shouldDeleteStructures.forEach((s: Structure) => s.delete());
+              const shouldDeleteStructures = oldItf.getRefStructures(parentModule?.structures);
+              shouldDeleteStructures?.forEach?.((s: Structure) => s.delete());
             }
             oldItf.delete();
             oldItf.afterDelete();
@@ -497,31 +497,35 @@ export class CallInterface extends LogicItem {
     let code = `${tsCalleeKey}(`;
 
     if (completeArguments?.length) {
-      code += '{';
+      code += '{ ';
       completeArguments?.forEach((arg, index) => {
-        code += arg?.toNaturalTS(shiftState(state, code), arg.paramRequired, true);
+        if (!arg) {
+          code += '__IDENTIFIER__: undefined';
+        } else {
+          code += arg.toNaturalTS(shiftState(state, code), arg.paramRequired, true);
+        }
         if (index !== this.arguments?.length - 1) code += ', ';
       });
-      code += '}';
+      code += ' }';
     }
     code += ')';
-    if (
-      parentNode.concept !== 'Argument' &&
-      parentKey !== 'test' &&
-      parentKey !== 'patterns' &&
-      parentKey !== 'returnExpression' &&
-      parentNode.concept !== 'Assignment' &&
-      parentNode.concept !== 'ForEachStatement' &&
-      parentNode.concept !== 'SelectMembers' &&
-      parentNode.concept !== 'UnaryExpression' &&
-      parentNode.concept !== 'BinaryExpression' &&
-      parentNode.concept !== 'MemberExpression' &&
-      parentNode.concept !== 'StringInterpolation' &&
-      !['NewMap', 'NewList'].includes(parentNode.concept)
-    ) {
-      code += ';';
-    }
-    code += '\n';
+    // if (
+    //   parentNode.concept !== 'Argument' &&
+    //   parentKey !== 'test' &&
+    //   parentKey !== 'patterns' &&
+    //   parentKey !== 'returnExpression' &&
+    //   parentNode.concept !== 'Assignment' &&
+    //   parentNode.concept !== 'ForEachStatement' &&
+    //   parentNode.concept !== 'SelectMembers' &&
+    //   parentNode.concept !== 'UnaryExpression' &&
+    //   parentNode.concept !== 'BinaryExpression' &&
+    //   parentNode.concept !== 'MemberExpression' &&
+    //   parentNode.concept !== 'StringInterpolation' &&
+    //   !['NewMap', 'NewList'].includes(parentNode.concept)
+    // ) {
+    //   code += ';';
+    // }
+    // code += '\n';
     return code;
   }
 
@@ -720,10 +724,13 @@ export class CallInterface extends LogicItem {
     }
     if (this.arguments?.length) {
       this.arguments.forEach((arg) => {
+        if (!arg)
+          return;
+
         const idx = logicParam.findIndex((params) => arg.keyword === params.name);
         const param = logicParam[idx];
 
-        arg.paramRequired = Boolean(!param?.defaultValue?.expression);
+        arg.paramRequired = param?.required;
         arg.paramTypeAnnotation = undefined;
         arg.paramDefaultValue = undefined;
         // 取到是不是必填放入参数中