@lcap/nasl 3.8.2-beta.7 → 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.7",
+  "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 = {
@@ -1657,7 +1657,7 @@ export class BusinessComponent extends BaseNode {
               logics: [newLogic],
             },
             this,
-            'events',
+            'bindEvents',
           );
           this.addBindEvent(event);
         } else {
@@ -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

@@ -368,7 +368,8 @@ export class CallInterface extends LogicItem {
       if (!this.calleeNamespace || !this.calleeName) throw new Error('调用接口为空');
       throw new Error(`${_name}下的${_interfaceName}接口未找到`);
     }
-    let isSimpleBody = false; // 兼容body只有基本类型的
+    // 兼容 body 基本类型、List、Object
+    let bodyType: 'primitive' | 'List'  = null;
     const _params = (_interface as Interface).params;
     const _queries = _params.filter((item) => item.in === 'query').map((item) => item.name);
     const _headers = _params.filter((item) => item.in === 'header').map((item) => item.name);
@@ -376,7 +377,9 @@ export class CallInterface extends LogicItem {
       .filter((item) => item.in === 'body')
       .map((item) => {
         if (item.typeAnnotation.typeKind === 'primitive') {
-          isSimpleBody = true;
+          bodyType = 'primitive';
+        } else if (item.typeAnnotation.typeKind === 'generic' && item.typeAnnotation.typeName === 'List') {
+          bodyType = 'List';
         }
         return item.name;
       });
@@ -420,9 +423,13 @@ export class CallInterface extends LogicItem {
     code = setArgumentCode(completeArguments, _headers, code, true, false);
     code += `},\n`;
 
-    if (isSimpleBody) {
+    if (bodyType === 'primitive') {
       code += `body: `;
       code = setArgumentCode(completeArguments, _body, code, false, false);
+    } else if (bodyType === 'List') {
+      code += `body: [`;
+      code = setArgumentCode(completeArguments, _body, code, false, true);
+      code += ']';
     } else {
       code += `body: {`;
       code = setArgumentCode(completeArguments, _body, code, false, true);
@@ -709,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/EnumItem__.ts

@@ -211,8 +211,8 @@ export class EnumItem extends BaseNode {
   toNaturalTS(state = createCompilerState()): string {
     let code = '';
 
-    if (state.descriptionComment)
-      code += createDescriptionComment(state, this, ['label']);
+    // if (state.descriptionComment)
+    //   code += createDescriptionComment(state, this, ['label']);
     code += `'${this.value}' = '${this.label?.value}'`;
 
     return code;

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';
           }
         },