@lcap/nasl 3.8.2-alpha.2 → 3.8.2-alpha.4

package/sandbox-natural/stdlib/{nasl.util.ts → nasl.util.d.ts}

@@ -1,19 +1,27 @@
+/** 循环函数ForEach
+* 这是唯一一个可以在逻辑中使用的循环函数，用于遍历列表中的元素，禁止使用for、forEach等其他循环语句。
+*/
+declare function ForEach<T>(list: List<T>, start: Integer, end: Integer, fn: (item: T, index: Integer) => void): void;
+
+/* 基本运算函数，用于数学计算 */
+declare function plus(left: Decimal, right: Decimal): Decimal;
+declare function minus(left: Decimal, right: Decimal): Decimal;
+declare function multiply(left: Decimal, right: Decimal): Decimal;
+declare function divide(left: Decimal, right: Decimal): Decimal;
+declare function remainder(left: Decimal, right: Decimal): Decimal;
+
 declare namespace nasl.util {
-  // 类型转换与格式化函数
+  /* 类型转换与格式化函数 */
   export function Convert(value: null): <T extends never>() => T;
   export function FormatNumber(doubleValue: Decimal | Long, digits: Long, showGroups: Boolean): String;
-  /**
-   * @example nasl.util.FormatDateTime(dataTime1, 'yyyy-MM-dd HH:mm:ss', 'global')
-  */
+  // @example nasl.util.FormatDateTime(dataTime1, 'yyyy-MM-dd HH:mm:ss', 'global')
   export function FormatDateTime(dateTime: DateTime, formatter: String, timeZone: string): String;
   export function FormatDate(date: Date, formatter: String): String;
-  /**
-   * @example nasl.util.FromString<Date>(variable1)
-   */
+  // @example nasl.util.FromString<Date>(variable1)
   export function FromString<T extends Decimal | Date | Time | DateTime | Long | Boolean>(value: String): T;
   export function ToString(value: Any): String;
 
-  // 字符串函数
+  /* 字符串函数 */
   export function Length(str1: String): Decimal;
   export function Length<K, V>(str1: Map<K, V>): Decimal;
   export function Length<T>(str1: List<T>): Decimal;
@@ -27,19 +35,23 @@ declare namespace nasl.util {
   export function ToUpper(str1: String): String;
   export function Trim(str1: String): String;
 
-  // 日期与时间函数
+  /* 日期与时间函数 */
   export function CurrDate(): Date;
   export function CurrDateTime(): DateTime;
   export function CurrTime(): Time;
-  export function DateDiff<T extends Date | Time | DateTime>(dateTime1: T, dateTime2: T, calcType: 'd' | 'h' | 'm' | 's', isAbs: Boolean): Decimal;
-  /* 为指定日期时间调整增加（减少）时间 */
+  // 计算两个日期时间之间的差值，calcType 支持年、季度、月、周、天、时分秒，默认为 'd'
+  export function DateDiff<T extends Date | Time | DateTime>(dateTime1: T, dateTime2: T, calcType: 'y' | 'q' | 'M' | 'w' | 'd' | 'h' | 'm' | 's', isAbs: Boolean): Decimal;
+  // 为指定日期时间调整增加（减少）时间
   export function AlterDateTime<T extends Date | DateTime>(dateTime: T, option: 'Increase' | 'Decrease', amount: Long, unit: 'day' | 'week' | 'month' | 'quarter' | 'year'): T;
-  /* 按指定维度计算日期，如“所在年-第几周”。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。*/
-  export function GetDateCount<T extends Date | DateTime>(dateTime: T, metric: 'week-year', timeZone: string): Time;
-  /* 按“星期几”获取指定日期范围内的日子。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。target 取值范围 [1,2,3,4,5,6,7] */
-  export function GetSpecificDaysOfWeek<T extends Date | DateTime>(startDate: T, endDate: T, target: List<Long>, timeZone?: String): List<T>;
+  /** 按指定维度计算日期的序号。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算
+  * @param dateTime: 日期或日期时间
+  * @param metric: 计算维度，格式为'小日期单位-大日期单位'。日期单位包括：'year'、'quarter'、'month'、'week'、'day'。如设置 'week-year'，则返回当前日期是所在年的第几周, 'day-week'，则返回当前日期是所在周的第几天。
+  */
+  export function GetDateCount<T extends Date | DateTime>(dateTime: T, metric: 'week-year'): Time;
+  // 按“星期几”获取指定日期范围内的日子。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。target 取值范围 [1,2,3,4,5,6,7]
+  export function GetSpecificDaysOfWeek<T extends Date | DateTime>(startDate: T, endDate: T, target: List<Long>): List<T>;
 
-  // 列表（List）函数
+  /* 列表（List）函数 */
   export function Add<T, K extends T>(list: List<T>, item: K): void;
   export function AddAll<T>(list: List<T>, addList: List<T>): Decimal;
   export function Contains<T, K extends T>(list: List<T>, item: K): Boolean;
@@ -66,7 +78,7 @@ declare namespace nasl.util {
   export function RemoveAt<T>(list: List<T>, index: Long): T;
   export function Set<T, K extends T>(list: List<T>, index: Decimal, item: K): T;
 
-  // 映射（Map）函数
+  /* 映射（Map）函数 */
   export function MapContains<K, V>(map: Map<K, V>, key: K): Boolean;
   export function MapGet<K, V>(map: Map<K, V>, key: K): V;
   export function MapPut<K, V>(map: Map<K, V>, key: K, value: V): void;
@@ -74,62 +86,56 @@ declare namespace nasl.util {
   export function MapRemove<K, V>(map: Map<K, V>, key: K): void;
   export function MapValues<K, V>(map: Map<K, V>): List<V>;
 
-  // 枚举函数
-  /**
-  * @example nasl.util.EnumToList<app.enums.aEnum>();
+  /* 枚举函数，项目中可使用的枚举类型均定义在 app.enums 中 */
+  /** 将指定枚举转换枚举value和text的List集合
+  * @example nasl.util.EnumToList<app.enums.UserSourceEnum>();
   */
   export function EnumToList<T extends Enums>(): List<{ text: String, value: String; }>;
-  // 将指定枚举值转换为文本
+  // 返回枚举指定value的标题字符串
   export function EnumValueToText<T extends Enums>(value: any): String;
   // 在指定枚举中找到与参数相同的枚举值并返回
   export function StringToEnumValue<T extends Enums>(value: String): T;
 
-  // 数学函数
-  /**
-   * 整数/小数 操作
+  /* 数学函数 */
+  /** 整数/小数 操作
    * @param mode: 'HalfUp' | 'TowardsZero' | 'TowardsInfinity' === '四舍五入' | '截断、向零取整，如 -2.6 取整为 -2' | '进位、向正负无穷取整，如 -1.1 取整为 -2'
    */
   export function Round(value: Decimal, mode: 'HalfUp' | 'TowardsZero' | 'TowardsInfinity'): Decimal;
-
-  // 其他函数
+  /* 其他函数 */
   export function Clear<T>(struct: T): T;
   export function Clone<T>(struct: T): T;
+  // 判断参数是否为有效值，null、空字符串、纯空格、长度为0的集合均不被视为有效值，传入多个参数时，判断是否全部都是有效值 */
   export function HasValue(...args: Any[]): Boolean;
   // RandomInt 生成的数字为整数，如果需要指定位数的随机数，需要在数字前按照位数要求补 0
   export function RandomInt(start: Long, end: Long): Long;
 
   // New 系列函数使用
-  /**
-   * T 类型必填
+  /** 生成新的列表，T 类型必填
    * @example const variable1 = nasl.util.NewList<Boolean | Long>([true, false, 1])
    */
   export function NewList<T>(args: T[]): List<T>;
-  /**
-   * T 类型必填
+  /** 生成新的映射，K、T 类型必填
    * @example const variable1 = nasl.util.NewMap<String, Long>({'123': 456})
    */
   export function NewMap<K, T>(args: any): Map<K, T>;
-  /**
-   * T 类型必填
+  /** 生成新的数据实体，T 类型必填
    * class Entity1 { id: Long; property1: String; property2: String;}
    * @example const variable1 = nasl.util.NewEntity<Entity1>({id: 123, property1: '123', property2: '456'})
    */
   export function NewEntity<T>(arg: T): T;
-  /**
-   * T 类型必填
+  /** 生成新的结构体，T 类型必填
    * class Structure1 { id: Long; property1: String; property2: String;}
    * @example const variable1 = nasl.util.NewStructure<Structure1>({id: 123, property1: '123', property2: '456'})
    */
   export function NewStructure<T>(arg: T): T;
-  /**
+  /** 生成新的匿名结构体, 无需定义类型
    * @example const variable1 = nasl.util.NewAnonymousStructure({property1: '123', property2: '456'})
    */
   export function NewAnonymousStructure(arg: Any): Any;
 
   export function consoleLog(arg: Any): void;
   export function jsonSerialize(arg: Any): String;
-  /**
-   * T 为返回值类型，必填
+  /** JSON 反序列化, T 为返回值类型，必填
    * @example nasl.util.jsonDeserialize<Boolean>(variable1);
    */
   export function jsonDeserialize<T>(arg: String): T;

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/BindAttribute__.ts

@@ -165,7 +165,7 @@ export class BindAttribute extends BaseNode {
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<BindAttribute>) {
-    source = { ...BindAttribute.getDefaultOptions(), ...source};
+    source = { ...BindAttribute.getDefaultOptions(), ...source };
     super(source);
     super.subConstructor(source);
   }
@@ -546,7 +546,7 @@ export class BindAttribute extends BaseNode {
     if (typeof options === 'string') {
       validationRule = (this.rules as ValidationRule[]).find((item) => item.name === options);
       if (!validationRule) {
-        throw new Error(`找不到验证规则 ${  options}`);
+        throw new Error(`找不到验证规则 ${options}`);
       }
     } else {
       validationRule = options;
@@ -938,7 +938,7 @@ export class BindAttribute extends BaseNode {
         transfromUnionTypeAnnotation(expTypeAnnotation, this.app);
         if (expTypeAnnotation?.typeNamespace?.endsWith('.metadataTypes')) {
           const referenceNode =
-            this.app.findNodeByCompleteName(`${expTypeAnnotation.typeNamespace  }.${  expTypeAnnotation.typeName}`)
+            this.app.findNodeByCompleteName(`${expTypeAnnotation.typeNamespace}.${expTypeAnnotation.typeName}`)
               ?.typeAnnotation || {};
           value = `$utils['ToString']('${referenceNode?.typeNamespace}.${referenceNode.typeName}', ${value})`;
         } else {
@@ -970,7 +970,7 @@ export class BindAttribute extends BaseNode {
   }
 
   @withSourceMapGenerator
-  *toEmbeddedTS(state = createCompilerState(), options: { carryName: boolean } = { carryName: false }): TranslatorGenerator {
+  *toEmbeddedTS(state = createCompilerState(), options: { carryName: boolean; } = { carryName: false }): TranslatorGenerator {
     const self = this;
     const { name, type, value, rules, expression, playground } = self;
     const humpName = self.toHump(name);
@@ -1037,7 +1037,7 @@ export class BindAttribute extends BaseNode {
 
       'dataSource',
       'converter',
-    ]
+    ];
 
     // @ts-ignore
     if (prop?.implicitToString) {
@@ -1185,17 +1185,22 @@ export class BindAttribute extends BaseNode {
       ) {
         return node.parentNode;
       }
-        return this.findCurrentElementParent(node.parentNode);
+      return this.findCurrentElementParent(node.parentNode);
 
     }
-      return undefined;
+    return undefined;
 
   }
 
   @withSourceMap()
   toNaturalTS(state = createCompilerState()): string {
     let code = `${utils.firstLowerCase(utils.kebab2Camel(this.name))}: `;
-
+    if (['dataSchema'].includes(this.name)) {
+      if (state?.typeMap?.[this.nodePath]) {
+        code += `'${state?.typeMap?.[this.nodePath]}'`;
+        return code;
+      }
+    }
     if (['destination', 'externalDestination'].includes(this.name) && this.type === 'dynamic') {
       code += (this as any)[this.name].toNaturalTS(
         shiftState(state, code, { tabSize: state.tabSize + 1, inline: true }),
@@ -1208,9 +1213,9 @@ export class BindAttribute extends BaseNode {
       });
       code += `\n${indent(state.tabSize)}]`;
     } else if (this.type === 'dynamic' && this.sync) {
-      code += 'sync('
-      code += this.expression?.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize, inline: true }));
-      code += ')';
+      const value = this.expression?.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize, inline: true }));
+      if (value) code += `sync(${value})`;
+      else code += value;
     } else {
       if (this.type === 'string') code += `'${this.value?.replace(/'/g, "\\'")}'`;
       else if (this.type === 'static') code += `${this.value}`;
@@ -1275,7 +1280,7 @@ export function attrConvertCamelCase(str: string) {
     if (index === 0) {
       return strItem;
     }
-      return `${strItem.slice(0, 1).toUpperCase()}${strItem.slice(1)}`;
+    return `${strItem.slice(0, 1).toUpperCase()}${strItem.slice(1)}`;
 
   });
   return strList.join('');

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

@@ -1511,7 +1511,7 @@ export class CallLogic extends LogicItem {
       }
     };
     // 调用实体逻辑特殊处理
-    if (tsCalleeNamespace.endsWith('.logics')) calleeKey = calleeKey.replace('.logics', 'Entity');
+    if (tsCalleeNamespace.startsWith('app.dataSources.') && tsCalleeNamespace.endsWith('.logics')) calleeKey = calleeKey.replace('.logics', 'Entity');
     code += calleeKey;
     setTypeArguments();
     setInputParam();

package/src/concepts/Logic__.ts

@@ -1276,7 +1276,7 @@ export class Logic extends Annotatable {
   }
 
   get __isVirtual() {
-    const isDisabled = !!this.getAncestor('HistoryProcessV2') || ['enabled', 'history'].includes(this.processV2?.status)
+    const isDisabled = !!this.getAncestor('HistoryProcessV2') || ['enabled', 'history'].includes(this.processV2?.status);
     return isDisabled || this.process?.__isVirtual || false;
   }
 
@@ -1551,7 +1551,7 @@ export class Logic extends Annotatable {
     const self = this;
 
     // 获取所有子节点用于树上填充
-    self.getSubLogics()
+    self.getSubLogics();
 
     yield waitOqlQueryComponentChildrenFinish(self);
     let code = '';
@@ -1610,7 +1610,7 @@ export class Logic extends Annotatable {
               leftIndex.length === 1
                 ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
                 : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
+                returnOrigin('');
             const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
@@ -1663,7 +1663,7 @@ export class Logic extends Annotatable {
             leftIndex.length === 1
               ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
               : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                  returnOrigin('');
+              returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
@@ -1934,7 +1934,7 @@ export class Logic extends Annotatable {
               leftIndex.length === 1
                 ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
                 : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
+                returnOrigin('');
             const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
@@ -2049,7 +2049,7 @@ export class Logic extends Annotatable {
             leftIndex.length === 1
               ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
               : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                  returnOrigin('');
+              returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
@@ -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('');
+                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';
           }
         },
@@ -2277,19 +2294,29 @@ export class Logic extends Annotatable {
     }
 
     code += `(`;
-    if (this.parentNode?.concept === 'BindEvent') {
-      code += `event`;
+    if (state?.typeMap?.[this.nodePath]) {
+      code += state?.typeMap?.[this.nodePath];
+    } else {
+      if (this.parentNode?.concept === 'BindEvent') {
+        code += `event`;
+      }
+      this.params.forEach((param, index) => {
+        code += param.toNaturalTS(shiftState(state, code, { inline: true }));
+        if (index !== this.params.length - 1) code += ', ';
+      });
     }
-    this.params.forEach((param, index) => {
-      code += param.toNaturalTS(shiftState(state, code, { inline: true }));
-      if (index !== this.params.length - 1) code += ', ';
-    });
     code += ')';
 
     // 兼容 return 没有类型情况
-    if (this.returns.length && (this.returns[0].typeAnnotation || this.returns[0].__TypeAnnotation)) {
-      code += ': ';
-      code += this.returns[0].typeAnnotation?.toNaturalTS(shiftState(state, code, { inline: true })) || this.returns[0].__TypeAnnotation?.toNaturalTS(shiftState(state, code, { inline: true }));
+    if (this.returns.length) {
+      if (state?.typeMap?.[this.returns[0]?.nodePath]) {
+        code += ': ';
+        code += state?.typeMap?.[this.returns[0]?.nodePath];
+      } else if (this.returns[0].typeAnnotation || this.returns[0].__TypeAnnotation) {
+        code += ': ';
+        const typeAnnotation = this.returns[0].typeAnnotation || this.returns[0].__TypeAnnotation;
+        code += typeAnnotation?.toNaturalTS(shiftState(state, code, { inline: true }));
+      }
     }
 
     if (state.declaration) {
@@ -2372,17 +2399,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 }));
@@ -2515,8 +2542,8 @@ export class Logic extends Annotatable {
           collectionTSCode === '__IDENTIFIER__'
             ? collectionTSCode
             : callFunction.isLoopMap && index === 0
-            ? `${collectionTSCode}.__getKey(0)`
-            : `${collectionTSCode}.__get(0)`,
+              ? `${collectionTSCode}.__getKey(0)`
+              : `${collectionTSCode}.__get(0)`,
         );
       }
     });
@@ -2658,9 +2685,8 @@ export class Logic extends Annotatable {
     if (asserts.isFrontendLibrary(this.parentNode)) {
       _path += `/frontends/${this.parentNode.type}`;
     } else if (this.parentNode.concept === 'BindEvent' && this.getAncestor('Frontend')) {
-      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${
-        this.getAncestor('Frontend')?.name
-      }/bindEvents/${name}.ts`;
+      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${this.getAncestor('Frontend')?.name
+        }/bindEvents/${name}.ts`;
     }
     return `/embedded/${this.getAncestor('App')?.name}${_path}/logics/${name}.ts`;
   }
@@ -2750,9 +2776,9 @@ export class Logic extends Annotatable {
     super.delete();
     this.body.forEach((el) => {
       if (asserts.isCallInterface(el)) {
-        el.deleteCallNode()
+        el.deleteCallNode();
       }
-    })
+    });
     this.traverseChildren(async (el) => {
       if (el?.concept === 'CallQueryComponent') (el as CallQueryComponent).removeStructure();
       // 仅仅针对 自定义连接器下的 Loigc，其他需要界定边界