@lcap/nasl 3.6.0-beta.1 → 3.7.0-beta.1

package/src/concepts/ViewElement__.ts

@@ -313,6 +313,13 @@ import BindStyle from './BindStyle__';
 export class ViewElement extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'ViewElement';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -1746,7 +1753,7 @@ export class ViewElement extends BaseNode {
       yield* wrapForEach(self.children, function* warpForEachGenerator(element) {
         code += yield* element.toEmbeddedTSRefTree(
           shiftState({ ...state, tabSize: state.tabSize + 2 }, code),
-          {elementsPathMap},
+          { elementsPathMap },
           levelIndex,
         );
       });
@@ -2007,12 +2014,7 @@ export class ViewElement extends BaseNode {
         // 属性
         const validAttrs = self.bindAttrs.filter((attr) => {
           // 特殊的一些属性不过滤
-          if ([
-            'destination',
-            'externalDestination',
-            'rules',
-            'url',
-          ].includes(attr.name)) {
+          if (['destination', 'externalDestination', 'rules', 'url'].includes(attr.name)) {
             return true;
           }
 

package/src/concepts/View__.ts

@@ -27,6 +27,8 @@ import type CallInterface from './CallInterface__';
 import type CallLogic from './CallLogic__';
 import type DefaultValue from './DefaultValue__';
 import type Interface from './Interface__'; // 临时记录删除的页面元素计数的最大值
+import type LogicItem from './LogicItem__';
+import type CallFunction from './CallFunction__';
 
 import App from './App__';
 import Module from './Module__';
@@ -63,6 +65,13 @@ import BindEvent from './BindEvent__';
 export class View extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'View';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -1498,16 +1507,19 @@ export class View extends BaseNode {
   getViewElementByName(name: string) {
     let res: ViewElement | null = null;
 
-    for (let i = 0; i < (this.elements || []).length; i+=1) {
+    for (let i = 0; i < (this.elements || []).length; i += 1) {
       const element = this.elements[i];
       // eslint-disable-next-line @typescript-eslint/no-loop-func
-      utils.traverse(({ node }) => {
-        if (node.concept === 'ViewElement' && node.name === name) {
-          res = node;
-        }
-      }, {
-        node: element,
-      });
+      utils.traverse(
+        ({ node }) => {
+          if (node.concept === 'ViewElement' && node.name === name) {
+            res = node;
+          }
+        },
+        {
+          node: element,
+        },
+      );
 
       if (res) {
         break;
@@ -1967,15 +1979,32 @@ export class View extends BaseNode {
       code += '];\n';
     }
     // 需要类型推导的局部变量/返回值需要调整申明顺序
-    const advanceMap: Map<Variable, Assignment | BatchAssignment> = new Map();
+    const advanceMap: Map<Variable, Assignment | BatchAssignment | CallFunction> = new Map();
     yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
+      if (el && (
+        // 批量赋值
+        asserts.isBatchAssignment(el)
+        // 赋值
+        || (asserts.isAssignment(el) && el.left?.name)
+        // 内置函数对集合类型的推导
+        || (
+          asserts.isCallFunction(el) && el.derivablecollection?.name
+        )
+      )) {
         // 子页面内部逻辑过滤
         if (el.view !== self) return;
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
+        if (asserts.isAssignment(el) || asserts.isCallFunction(el)) {
+          let expression: LogicItem;
+          if (asserts.isAssignment(el)) {
+            // 需要被推导的赋值左侧
+            expression = el.left;
+          } else if (asserts.isCallFunction(el)) {
+            // 需要被推导的集合
+            expression = el.derivablecollection;
+          }
+          const advanceVar = self.variables?.find((variable) => {
+            return !variable.typeAnnotation && expression?.name === variable.name;
+          });
           if (advanceVar && !advanceMap.get(advanceVar)) {
             advanceMap.set(advanceVar, el);
           }
@@ -2028,10 +2057,30 @@ export class View extends BaseNode {
         return;
       }
       code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
+      if (asserts.isCallFunction(assignment)) {
+        yield* wrapForEach([
+          {
+            key: 'key',
+            node: assignment.keyOfCollection
+          },
+          {
+            key: 'item',
+            node: assignment.itemOfCollection
+          }
+        ], function* warpForEachGenerator({ key, node: itemNode }) {
+          if (itemNode) {
+            code += `const __${key}_${variable?.name} = `;
+            const itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
+            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            code += ';\n';
+          }
+        });
+      }
       code += `${indent((state?.tabSize || 0) + 1)}let `;
       code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
-      code += ' = ';
       if (asserts.isBatchAssignment(assignment)) {
+        code += ' = ';
         yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
           const leftCode =
             leftIndex.length === 1
@@ -2048,22 +2097,32 @@ export class View extends BaseNode {
             code += yield* self.getRightCode(rightCode, assignment, rightNode);
           }
         });
+      } else if (asserts.isCallFunction(assignment)) {
+        const nodeName = variable?.name;
+        const keyNode = assignment.keyOfCollection;
+        const itemNode = assignment.itemOfCollection;
+        if (assignment.isDerivableMap && keyNode && itemNode) {
+          code += `: nasl.collection.Map<typeof __key_${nodeName}, typeof __item_${nodeName}>`;
+        } else if (assignment.isDerivableList && itemNode) {
+          code += `: nasl.collection.List<typeof __item_${nodeName}>`;
+        }
       } else {
+        code += ' = ';
         let rightCode = '';
         // 因为右侧枚举要赋值就得new 一下；
         if (
-          assignment.right &&
-          asserts.isIdentifier(assignment.right) &&
-          assignment.right.namespace &&
-          assignment.right.namespace.endsWith('enums')
+          (assignment as Assignment).right &&
+          asserts.isIdentifier((assignment as Assignment).right) &&
+          ((assignment as Assignment).right as any).namespace &&
+          ((assignment as Assignment).right as any).namespace.endsWith('enums')
         ) {
           rightCode += 'new ';
         }
         rightCode +=
-          assignment.right && assignment.right.toEmbeddedTS
-            ? yield* assignment.right.toEmbeddedTS(shiftState(state, code, { inline: true }))
+          (assignment as Assignment).right && (assignment as Assignment).right.toEmbeddedTS
+          ? yield* (assignment as Assignment).right.toEmbeddedTS(shiftState(state, code, { inline: true }))
             : '__RIGHT__';
-        code += yield* self.getRightCode(rightCode, assignment, assignment.right);
+        code += yield* self.getRightCode(rightCode, assignment, (assignment as Assignment).right);
       }
       code += ';\n';
     });
@@ -2084,9 +2143,9 @@ export class View extends BaseNode {
 
     // 深度遍历拿到element path
     if (Array.isArray(self.elements)) {
-      self.elements.forEach(item => {
+      self.elements.forEach((item) => {
         item.toEmbeddedTSRefPath(elementsPathMap);
-      })
+      });
     }
 
     if (Array.isArray(self.elements)) {
@@ -2593,8 +2652,15 @@ ${indent(state.tabSize)}export function ${this.tsName}_view`;
     }
   }
 
-  *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
+  *getRightCode(code: string, assignment: Assignment | BatchAssignment | CallFunction, rightNode: any) {
     code = code.replaceAll('\n', ' ');
+    // 赋值语句的右侧或者集合内置函数的参数
+    if (
+      (asserts.isAssignment(assignment) && !assignment.right)
+      || (asserts.isCallFunction(assignment) && ((assignment.isDerivableList && !assignment.itemOfCollection) || (assignment.isDerivableMap && !(assignment.keyOfCollection && assignment.itemOfCollection))))
+    ) {
+      return code;
+    }
     const { logic } = assignment;
     const logicRtn = logic?.returns[0];
     // 调用接口，参数替换成 null

package/src/concepts/WhileStatement__.ts

@@ -30,6 +30,13 @@ import LogicItem from './LogicItem__';
 export class WhileStatement extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'WhileStatement';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/basics/stdlib/nasl.process.ts

@@ -177,12 +177,10 @@ export function initialize() {
           typeAnnotation: TypeAnnotation.createPrimitive('String'),
         }),
       ],
-    }),
+    })
   );
 
-  processTypeList.push(
-    ...reference2TypeAnnotationList(processStructures, 'nasl.process'),
-  );
+  processTypeList.push(...reference2TypeAnnotationList(processStructures, 'nasl.process'));
 
   const logics = [
     new Logic({
@@ -382,6 +380,22 @@ export function initialize() {
         }),
       ],
     }),
+    new Logic({
+      name: 'getTaskInstanceV2',
+      description: '获取任务详情，支持历史任务',
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createTypeParam('T'),
+        }),
+      ],
+    }),
     new Logic({
       name: 'getTaskInstanceList',
       description: '获取流程任务列表',
@@ -467,6 +481,91 @@ export function initialize() {
         }),
       ],
     }),
+    new Logic({
+      name: 'getTaskInstanceListV2',
+      description: '获取流程任务列表，包含历史任务',
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new Param({
+          name: 'user',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new Param({
+          name: 'finished',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+        }),
+        new Param({
+          name: 'processId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new Param({
+          name: 'processIdIn',
+          typeAnnotation: TypeAnnotation.createGeneric('List', {
+            typeArguments: [TypeAnnotation.createTypeParam('String')],
+          }),
+        }),
+        new Param({
+          name: 'processDefName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new Param({
+          name: 'taskDefName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new Param({
+          name: 'createTimeBefore',
+          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+        }),
+        new Param({
+          name: 'createTimeAfter',
+          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+        }),
+        new Param({
+          name: 'completeTimeBefore',
+          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+        }),
+        new Param({
+          name: 'completeTimeAfter',
+          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+        }),
+        new Param({
+          name: 'page',
+          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        }),
+        new Param({
+          name: 'size',
+          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        }),
+        new Param({
+          name: 'sort',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new Param({
+          name: 'order',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createTypeAnonymousStructure([
+            new StructureProperty({
+              name: 'list',
+              typeAnnotation: TypeAnnotation.createGeneric('List', {
+                typeArguments: [TypeAnnotation.createTypeParam('T')],
+              }),
+            }),
+            new StructureProperty({
+              name: 'total',
+              typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+            }),
+          ]),
+        }),
+      ],
+    }),
     new Logic({
       name: 'claimTaskInstance',
       description: '认领流程任务',
@@ -628,7 +727,6 @@ export function initialize() {
           title: '名称',
           description: '名称',
           group: '运行属性',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
           useComponent: new UseComponent({ type: 's-edit-user' }),
         }),
         new Attribute({
@@ -636,14 +734,12 @@ export function initialize() {
           title: '任务标题',
           description: '任务标题',
           group: '任务箱属性',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
         }),
         new Attribute({
           name: 'destination',
           title: '跳转页面',
           description: '跳转页面',
           group: '任务箱属性',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
         }),
       ],
     }),

package/src/concepts/basics/stdlib/nasl.util.ts

@@ -325,7 +325,7 @@ export function initialize() {
       ],
     }),
     new Function({
-      name: 'StringToEnumValue',
+      name: 'ToEnumItem',
       description: '在指定enum中找到与参数str相同的枚举值并返回。',
       typeParams: [
         new TypeParam({

package/src/concepts/index__.ts

@@ -24,11 +24,25 @@ export * from './BindAttribute__';
 export * from './BindDirective__';
 export * from './BindEvent__';
 export * from './BindStyle__';
-export * from './ViewComponent__';
+export * from './ThemeVariable__';
+export * from './BaseSetter__';
+export * from './InputSetter__';
+export * from './SwitchSetter__';
+export * from './SetterOption__';
+export * from './EnumSelectSetter__';
+export * from './CapsulesSetter__';
+export * from './NumberInputSetter__';
+export * from './IconSetter__';
+export * from './ImageSetter__';
+export * from './PropertySelectSetter__';
+export * from './ViewComponentDeclaration__';
 export * from './BusinessComponent__';
 export * from './Attribute__';
 export * from './Event__';
-export * from './Slot__';
+export * from './PropDeclaration__';
+export * from './EventDeclaration__';
+export * from './SlotDeclaration__';
+export * from './LogicDeclaration__';
 export * from './Theme__';
 export * from './Logic__';
 export * from './AuthLogic__';
@@ -126,6 +140,7 @@ export * from './SelectMembers__';
 export * from './AssignmentLine__';
 export * from './FrontendLibrary__';
 export * from './ViewBlock__';
+export * from './ViewBlockWithImage__';
 export * from './AuthInterface__';
 export * from './CallAuthInterface__';
 export * from './TriggerEvent__';