@lcap/nasl 3.8.2-beta.8 → 3.8.2-beta.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lcap/nasl",
   "description": "NetEase Application Specific Language",
-  "version": "3.8.2-beta.8",
+  "version": "3.8.2-beta.9",
   "author": "Forrest <rainforest92@126.com>",
   "main": "./out",
   "license": "MIT",

package/sandbox/stdlib/nasl.processV2.ts

@@ -90,6 +90,9 @@ declare namespace nasl.processV2 {
   // 加签
   export function addSignTask(taskId: nasl.core.String, userForAddSign: nasl.core.String): void;
 
+  // 查询可加签用户列表
+  export function getUsersForAddSign(taskId: nasl.core.String): nasl.collection.List<LCAPUser>;
+
   //终止
   export function terminateProcess(procInstId: nasl.core.String): void;
 
@@ -102,6 +105,9 @@ declare namespace nasl.processV2 {
   //查询转派目标用户列表
   export function getUsersForReassign(taskId: nasl.core.String): nasl.collection.List<LCAPUser>;
 
+  //查询流程任务信息
+  export function getTaskInfo(taskId: nasl.core.String): TaskInst;
+
 
   /* ***********************************  数据结构定义 ******************************* */
   export class CurrNode {
@@ -209,6 +215,19 @@ declare namespace nasl.processV2 {
     nodeOperationComment: nasl.core.String;
   }
 
+  export class TaskInst {
+    processDefUniqueKey: nasl.core.String;
+    processDefinitionId: nasl.core.String;
+    processInstanceId: nasl.core.String;
+    taskDefName: nasl.core.String;
+    taskTitle: nasl.core.String;
+    taskId: nasl.core.String;
+    completeBy: nasl.core.String;
+    finished: nasl.core.Boolean;
+    createTime: nasl.core.String;
+    completeTime: nasl.core.String;
+  }
+
   // 流程变量类型定义
   export interface ProcessVariable {
     // 流程实例发起人

package/sandbox/stdlib/nasl.ui.ts

@@ -246,13 +246,13 @@ declare namespace nasl.ui {
     }
 
     export class KeyboardEvent {
-        // altKey: nasl.core.Boolean;
-        // code: nasl.core.String;
-        // ctrlKey: nasl.core.Boolean;
-        // isComposing: nasl.core.Boolean;
-        // key: nasl.core.String;
-        // metaKey: nasl.core.Boolean;
-        // repeat: nasl.core.Boolean;
-        // shiftKey: nasl.core.Boolean;
+        altKey: nasl.core.Boolean;
+        code: nasl.core.String;
+        ctrlKey: nasl.core.Boolean;
+        isComposing: nasl.core.Boolean;
+        key: nasl.core.String;
+        metaKey: nasl.core.Boolean;
+        repeat: nasl.core.Boolean;
+        shiftKey: nasl.core.Boolean;
     }
 }

package/src/common/BaseNode.ts

@@ -812,7 +812,7 @@ export class BaseNode extends EventEmitter {
     const Ctor = classMap.get(source?.concept) || this;
     if (Ctor && source instanceof Ctor) {
       if (utils.isDebugMode) {
-        console.warn('传入的对象已经是一个实例，请确认逻辑是否存在问题！');
+        // console.warn('传入的对象已经是一个实例，请确认逻辑是否存在问题！');
       }
       if (parentNode) {
         source.parentNode = parentNode;
@@ -1729,9 +1729,11 @@ export class BaseNode extends EventEmitter {
     const results: types.SyntaxNode[] = []; // 创建一个数组存储匹配的结果
 
     queue.push(this as unknown as types.SyntaxNode); // 将初始节点加入队列
+    let point = 0; // 创建一个指针，指向当前遍历的节点
 
-    while (queue.length > 0) {
-      const node = queue.shift(); // 从队列中取出一个节点
+    while (queue[point]) {
+      const node = queue[point]; // 从队列中取出一个节点
+      point++; // 指针后移
 
       if (node) {
         let result = false;

package/src/common/ComponentAPI.ts

@@ -103,4 +103,11 @@ export default interface ComponentAPI {
   aria?: Array<AriaAPI>;
 
   tsTypeParams?: string;
+  readablePropsMap?: { [name: string]: {
+    name: string;
+    title: string;
+    state: string;
+    prop: string;
+    icon?: string;
+  } };
 }

package/src/concepts/AuthLogicForCallInterface__.ts

@@ -542,22 +542,39 @@ export class AuthLogicForCallInterface extends AuthLogic {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },

package/src/concepts/BusinessComponent__.ts

@@ -15,7 +15,7 @@ import type Match from './Match__';
 import type Logic from './Logic__';
 import type Param from './Param__';
 import { ElementToVueOptions } from './ViewElement__';
-import { ComponentCompletionPropertyMap } from './View__';
+import { config } from '../config';
 import translator from '../bak/translator';
 
 type AttrObject = {
@@ -1903,7 +1903,8 @@ export class BusinessComponent extends BaseNode {
         if (item.tag === 'template' && item.haveScope()) {
           index += 1;
         }
-        if (ComponentCompletionPropertyMap[item.tag]) {
+        if (config?.allNodesAPI && config?.allNodesAPI[item.tag] &&
+          config?.allNodesAPI[item.tag].readablePropsMap) {
           componentList.push(item);
         }
         item.currentIndex = index;
@@ -2145,22 +2146,39 @@ export class BusinessComponent extends BaseNode {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },

package/src/concepts/BusinessLogic__.ts

@@ -351,22 +351,39 @@ export class BusinessLogic extends Logic {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },

package/src/concepts/CallInterface__.ts

@@ -716,8 +716,8 @@ export class CallInterface extends LogicItem {
         if (!arg) return;
         const idx = logicParam.findIndex((params) => arg.keyword === params.name);
         const param = logicParam[idx];
-
-        arg.paramRequired = param?.required;
+        const hasDefaultValue = Boolean(param?.defaultValue?.expression);
+        arg.paramRequired = hasDefaultValue ? false : param?.required;
         arg.paramTypeAnnotation = undefined;
         arg.paramDefaultValue = undefined;
         // 取到是不是必填放入参数中

package/src/concepts/CallLogic__.ts

@@ -1613,11 +1613,13 @@ export class CallLogic extends LogicItem {
     } else if (this.calleeNamespace?.startsWith('elements.')) {
       // 查找组件的逻辑，用于展示默认值
       const elementsLogic = (this.app as any)?.naslServer?.elementsLogic || {};
-      let elementName: string = this.calleeNamespace.split('.')[1];
-      // eslint-disable-next-line prefer-destructuring
-      elementName = elementName.split('_')[0];
-      elementName = elementName[0].toUpperCase() + elementName.slice(1);
-      const logics = elementsLogic[`U${elementName}`] || elementsLogic[`Van${elementName}`] || [];
+
+      let tag = this.getElementTagByLogic();
+      // tag转换为首字母大写，驼峰
+      tag = tag.replace(/^\S/, (s) => s.toUpperCase())
+              .replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
+
+      const logics = elementsLogic[`${tag}`] || [];
       node = logics.find((l: any) => l.name === this.calleeName);
     } else {
       // 如果是其余app下自定义逻辑
@@ -1641,6 +1643,25 @@ export class CallLogic extends LogicItem {
     return node;
   }
 
+  private getElementTagByLogic(): string {
+    const elementName: string = this.calleeNamespace.split('.')[1];
+    let tag = '';
+    this.likeComponent.elements.forEach((element) => {
+      utils.traverse(
+        ({ node }) => {
+          if (node.name === elementName) {
+            tag = node.tag;
+          }
+        },
+        {
+          node: element,
+        },
+      );
+    })
+
+    return tag;
+  }
+
   getCallNodeUsingCache(frontNdCache : Map<string, Logic>, serverNdCache : Map<string, Logic>, processNdCache : Map<string, Logic>): ['front' | 'server' | 'process', Logic | undefined] {
     const cwKey = this.calleewholeKey;
     if (serverNdCache.get(cwKey)) {
@@ -1663,11 +1684,11 @@ export class CallLogic extends LogicItem {
     } else if (this.calleeNamespace?.startsWith('elements.')) {
       // 查找组件的逻辑，用于展示默认值
       const elementsLogic = (this.app as any)?.naslServer?.elementsLogic || {};
-      let elementName: string = this.calleeNamespace.split('.')[1];
-      // eslint-disable-next-line prefer-destructuring
-      elementName = elementName.split('_')[0];
-      elementName = elementName[0].toUpperCase() + elementName.slice(1);
-      const logics = elementsLogic[`U${elementName}`] || elementsLogic[`Van${elementName}`] || [];
+      let tag = this.getElementTagByLogic();
+      // tag转换为首字母大写，驼峰
+      tag = tag.replace(/^\S/, (s) => s.toUpperCase())
+        .replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
+      const logics = elementsLogic[`${tag}`] || [];
       node = logics.find((l: any) => l.name === this.calleeName);
     } else {
       // 如果是其余app下自定义逻辑

package/src/concepts/Logic__.ts

@@ -2151,22 +2151,39 @@ export class Logic extends Annotatable {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },
@@ -2372,17 +2389,17 @@ export class Logic extends Annotatable {
       code += ';';
     } else {
       code += ' {\n';
-  
+
       this.variables.forEach((variable) => {
         code += `${indent(state.tabSize + 1)}let `;
         code += variable.toTextualNASL(shiftState(state, code, { inline: true }));
         code += ';\n';
       });
       if (this.variables.length) code += '\n';
-  
+
       this.body.forEach((item) => {
         let partialCode = '';
-  
+
         // if (!state.focusedNodePath && item.concept === 'End') code += `${indent(state.tabSize + 1)}/* 当前位置 */\n`;
         if (item.toTextualNASL) {
           partialCode = item.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
@@ -2886,7 +2903,7 @@ export class Logic extends Annotatable {
 
   getSubLogics() {
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
-      if (asserts.isSubLogic(node)) {
+      if (node?.concept === 'SubLogic') {
         return true;
       }
     });

package/src/concepts/MemberExpression__.ts

@@ -8,13 +8,14 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import { ComponentCompletionPropertyMap, Enum, TypeAnnotation, BusinessComponent, View } from '..';
+import { Enum, TypeAnnotation, BusinessComponent, View } from '..';
 import { ElementToVueOptions } from './ViewElement__';
 import type Identifier from './Identifier__';
 import BindAttribute, { attrConvertCamelCase } from './BindAttribute__';
 import type Assignment from './Assignment__';
 import type BatchAssignment from './BatchAssignment__';
 import DefaultValue from './DefaultValue__';
+import { config } from '../config';
 
 const Identifier_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
@@ -138,11 +139,13 @@ export class MemberExpression extends LogicItem {
       }
 
       if (
-        ComponentCompletionPropertyMap[elementTag] &&
-        ComponentCompletionPropertyMap[elementTag][this.property.name] &&
-        ComponentCompletionPropertyMap[elementTag][this.property.name].state
+        config?.allNodesAPI &&
+        config?.allNodesAPI[elementTag] &&
+        config?.allNodesAPI[elementTag].readablePropsMap &&
+        config?.allNodesAPI[elementTag].readablePropsMap[this.property.name] &&
+        config?.allNodesAPI[elementTag].readablePropsMap[this.property.name].state
       ) {
-        const { prop } = ComponentCompletionPropertyMap[elementTag][this.property.name];
+        const { prop } = config?.allNodesAPI[elementTag].readablePropsMap[this.property.name];
         if (!['data'].includes(this.property.name)) {
           return `this && this.__${elementName}_params && this.__${elementName}_params.${this.property.name}`;
         }
@@ -263,11 +266,13 @@ export class MemberExpression extends LogicItem {
       }
 
       if (
-        ComponentCompletionPropertyMap[elementTag] &&
-        ComponentCompletionPropertyMap[elementTag][this.property.name] &&
-        ComponentCompletionPropertyMap[elementTag][this.property.name].state
+        config?.allNodesAPI &&
+        config?.allNodesAPI[elementTag] &&
+        config?.allNodesAPI[elementTag].readablePropsMap &&
+        config?.allNodesAPI[elementTag].readablePropsMap[this.property.name] &&
+        config?.allNodesAPI[elementTag].readablePropsMap[this.property.name].state
       ) {
-        const { prop } = ComponentCompletionPropertyMap[elementTag][this.property.name];
+        const { prop } = config?.allNodesAPI[elementTag].readablePropsMap[this.property.name];
 
         if (!['data'].includes(this.property.name)) {
           return `this['__${elementName}_params'] && this['__${elementName}_params'].${this.property.name}`;
@@ -422,11 +427,13 @@ export class MemberExpression extends LogicItem {
     const prefix = type === 'toVue' ? '' : 'this.';
 
     if (
-      ComponentCompletionPropertyMap[elementTag] &&
-      ComponentCompletionPropertyMap[elementTag][this.property.name] &&
-      ComponentCompletionPropertyMap[elementTag][this.property.name].state
+      config?.allNodesAPI &&
+      config?.allNodesAPI[elementTag] &&
+      config?.allNodesAPI[elementTag].readablePropsMap &&
+      config?.allNodesAPI[elementTag].readablePropsMap[this.property.name] &&
+      config?.allNodesAPI[elementTag].readablePropsMap[this.property.name].state
     ) {
-      const { prop } = ComponentCompletionPropertyMap[elementTag][this.property.name];
+      const { prop } = config?.allNodesAPI[elementTag].readablePropsMap[this.property.name];
 
       if (!['data'].includes(this.property.name)) {
         return `${prefix}__${elementName}_params && ${prefix}__${elementName}_params.${this.property.name}`;

package/src/concepts/OverriddenLogic__.ts

@@ -1769,22 +1769,39 @@ export class OverriddenLogic extends BaseNode {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },

package/src/concepts/ViewElement__.ts

@@ -27,7 +27,6 @@ import type Identifier from './Identifier__';
 import { PAGE_COMPONENT_INCLUDE_TAG_MAP } from './View__';
 import type BusinessComponent from './BusinessComponent__';
 import type FrontendType from './FrontendType__';
-import { ComponentCompletionPropertyMap } from './View__';
 
 import { kebab2Camel } from '../utils';
 export interface ParseContext {
@@ -1777,7 +1776,7 @@ export class ViewElement extends Annotatable {
     if (hasDataSource && V && !T1) {
       const valueFieldAttr = self.bindAttrs?.find((attr) => attr.name === 'valueField');
       if (dataSourceSetted && ['static', 'string'].includes(valueFieldAttr?.type)) {
-        valueType = `nasl.util._formatEnum<typeof __item.${valueFieldAttr.value}>`;
+        valueType = `nasl.util._formatEnum<typeof __item.${valueFieldAttr.value || 'value'}>`;
       } else {
         valueType = `nasl.util._formatEnum<typeof __staticItem>`;
       }

package/src/concepts/View__.ts

@@ -46,6 +46,8 @@ const removedViewElementCache: {
   [key: string]: number | bigint;
 } = {};
 
+import { config } from '../config';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1857,7 +1859,7 @@ export class View extends Annotatable {
                 document.addEventListener('keydown', this.onKeyDown);
                 document.addEventListener('keyup', this.onKeyUp);
             },
-            beforeDestory() {
+            beforeDestroy() {
                 document.removeEventListener('keydown', this.onKeyDown);
                 document.removeEventListener('keyup', this.onKeyUp);
             },
@@ -2126,7 +2128,7 @@ export class View extends Annotatable {
         if (item.tag === 'template' && item.haveScope()) {
           index += 1;
         }
-        if (ComponentCompletionPropertyMap[item.tag]) {
+        if (config?.allNodesAPI && config?.allNodesAPI[item.tag]?.readablePropsMap) {
           componentList.push(item);
         }
         item.currentIndex = index;
@@ -2360,22 +2362,39 @@ export class View extends Annotatable {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },
@@ -3129,15 +3148,17 @@ export class View extends Annotatable {
 
   getSubLogics() {
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
-      if (asserts.isSubLogic(node)) {
-        // 仅仅是为了处理数据源中的子逻辑，Logic 下面的，交由Logic 自己处理
-        if (node?.getAncestor('Logic')) {
-          return false;
-        }
+      // 仅仅是为了处理数据源中的子逻辑，Logic 下面的，交由Logic 自己处理
+      if (node?.concept === 'Logic') {
+        return true;
+      }
+      if (node?.concept === 'SubLogic') {
         return true;
       }
     });
-    this.subLogics = subLogics as Array<SubLogic>;
+    this.subLogics = subLogics?.filter(node => {
+      return asserts.isSubLogic(node);
+    }) as Array<SubLogic>;
   }
 
   existingSubLogic: Set<string> = new Set<string>();