@hadss/turbo-trans-json-plugin 1.0.0-rc.0 → 1.0.0-rc.2

package/dist/core/utils/GenericTypeSubstitutionUtil.js

@@ -4,11 +4,14 @@ exports.GenericTypeSubstitutionUtil = void 0;
 const __1 = require("..");
 const handlers_1 = require("../handlers");
 const DeepCopyUtil_1 = require("./DeepCopyUtil");
+const Logger_1 = require("../logger/Logger");
 class GenericTypeSubstitutionUtil {
     static buildGenericMapping(parentGenericParams, childTypeArguments) {
         const mapping = new Map();
         const length = Math.min(parentGenericParams.length, childTypeArguments.length);
+        Logger_1.Logger.debug(`[GenericMapping] Building mapping with ${length} parameters`);
         for (let i = 0; i < length; i++) {
+            Logger_1.Logger.debug(`[GenericMapping] ${parentGenericParams[i]} -> ${childTypeArguments[i].getText()}`);
             mapping.set(parentGenericParams[i], childTypeArguments[i]);
         }
         return mapping;
@@ -24,10 +27,17 @@ class GenericTypeSubstitutionUtil {
     static substituteTypeStructure(typeStructure, mapping, currentClassGenericParams = []) {
         if (typeStructure.kind === __1.PropertyKind.GENERIC) {
             const genericTypeName = typeStructure.sourceText;
+            Logger_1.Logger.debug(`[GenericSubstitution] Processing generic type: ${genericTypeName}`);
+            Logger_1.Logger.debug(`[GenericSubstitution] Available mappings: ${Array.from(mapping.keys()).join(', ')}`);
+            Logger_1.Logger.debug(`[GenericSubstitution] Current class generic params: ${currentClassGenericParams.join(', ')}`);
             if (mapping.has(genericTypeName)) {
                 const substitutedTypeNode = mapping.get(genericTypeName);
-                return this.constructTypeStructureFromTypeName(substitutedTypeNode, currentClassGenericParams);
+                Logger_1.Logger.debug(`[GenericSubstitution] Found mapping for ${genericTypeName} -> ${substitutedTypeNode.getText()}`);
+                const result = this.constructTypeStructureFromTypeName(substitutedTypeNode, currentClassGenericParams);
+                Logger_1.Logger.debug(`[GenericSubstitution] Result kind: ${result.kind}, sourceText: ${result.sourceText}`);
+                return result;
             }
+            Logger_1.Logger.warn(`[GenericSubstitution] No mapping found for generic type: ${genericTypeName}, keeping as-is`);
             return typeStructure;
         }
         const newStructure = DeepCopyUtil_1.DeepCopyUtil.copyTypeStructure(typeStructure);
@@ -36,6 +46,7 @@ class GenericTypeSubstitutionUtil {
         }
         if (newStructure.args) {
             newStructure.args = newStructure.args.map(arg => this.substituteTypeStructure(arg, mapping, currentClassGenericParams));
+            newStructure.sourceText = this.regenerateSourceText(newStructure);
         }
         newStructure.dependencies = this.collectDependenciesFromChildren(newStructure);
         return newStructure;
@@ -46,6 +57,21 @@ class GenericTypeSubstitutionUtil {
             genericParams: currentClassGenericParams
         });
     }
+    static regenerateSourceText(structure) {
+        if (!structure.args || structure.args.length === 0) {
+            return structure.sourceText;
+        }
+        if (structure.sourceText.endsWith('[]')) {
+            return `${structure.args[0].sourceText}[]`;
+        }
+        const genericStart = structure.sourceText.indexOf('<');
+        if (genericStart > 0) {
+            const containerName = structure.sourceText.substring(0, genericStart);
+            const argsText = structure.args.map(arg => arg.sourceText).join(', ');
+            return `${containerName}<${argsText}>`;
+        }
+        return structure.sourceText;
+    }
     static collectDependenciesFromChildren(children) {
         const allDependencies = [];
         if (children.unionDetails) {

package/dist/core/utils/SerializationPathUtil.d.ts

@@ -1,5 +1,5 @@
 import { FileUtil } from '@ohos/hvigor';
-import * as fs from "fs";
+import * as fs from 'fs';
 import { ITaskContext } from '..';
 export default class SerializationPathUtil extends FileUtil {
     static readonly sep: string;

package/dist/core/utils/TsMorphUtil.js

@@ -4,11 +4,16 @@ exports.TsMorphUtil = void 0;
 const ts_morph_1 = require("ts-morph");
 const Logger_1 = require("../logger/Logger");
 class TsMorphUtil {
-    constructor() { }
+    constructor() {
+    }
     static getProject(options) {
         if (!this.project) {
             Logger_1.Logger.info('创建ts-morph项目');
             this.project = new ts_morph_1.Project(options || {
+                manipulationSettings: {
+                    indentationText: ts_morph_1.IndentationText.TwoSpaces,
+                    quoteKind: ts_morph_1.QuoteKind.Single
+                },
                 compilerOptions: {
                     allowNonTsExtensions: true
                 }

package/dist/json-plugin/JSONExecuteController.d.ts

@@ -10,4 +10,8 @@ export declare class JSONExecuteController {
     private initTasks;
     private taskCleanUp;
     private registerHvigorTasks;
+    private runTask;
+    private handleTaskError;
+    private registerCleanTaskHook;
+    private cleanGeneratedDirectory;
 }

package/dist/json-plugin/JSONExecuteController.js

@@ -56,48 +56,58 @@ class JSONExecuteController {
         this.tasks.forEach((task) => {
             this.node.registerTask({
                 name: task.taskName,
-                run: async () => {
-                    try {
-                        core_1.Logger.info(`${task.taskName} run`);
-                        core_1.TempSerializerGenerator.getInstance().init(targetContext);
-                        const result = task.run(targetContext);
-                        if (task.taskName !== TaskConstants_1.TaskConstants.CLEAN_TASK) {
-                            core_1.TempSerializerGenerator.getInstance().saveFile();
-                        }
-                        if (result instanceof Promise) {
-                            await result;
-                        }
-                        if (task.taskName === TaskConstants_1.TaskConstants.SYNC_TASK || task.taskName === TaskConstants_1.TaskConstants.CODE_PROCESSING_TASK) {
-                            this.taskCleanUp();
-                        }
-                        core_1.Logger.info(`${task.taskName} end`);
-                    }
-                    catch (error) {
-                        if (error instanceof CustomError_1.CustomError) {
-                            core_1.Logger.error(`Error: ${error.constructor.name}: ${error.code} ${error.message}\n${error.stack}`);
-                        }
-                        else {
-                            const err = error;
-                            core_1.Logger.error(`Error: ${err.constructor.name}: ${CustomError_1.ErrorCodes.INTERNAL_ERROR} ${err.message}\n${err.stack}`);
-                        }
-                        this.taskCleanUp();
-                        throw new Error('serialization execute failed');
-                    }
-                },
+                run: async () => this.runTask(task, targetContext),
                 dependencies: task.dependencies.map((dep) => `${target.getTargetName()}@${dep}`),
                 postDependencies: task.postDependencies.map((dep) => `${target.getTargetName()}@${dep}`)
             });
         });
+        this.registerCleanTaskHook(targetContext);
+    }
+    async runTask(task, targetContext) {
+        try {
+            core_1.Logger.info(`${task.taskName} run`);
+            core_1.TempSerializerGenerator.getInstance().init(targetContext);
+            const result = task.run(targetContext);
+            if (task.taskName !== TaskConstants_1.TaskConstants.CLEAN_TASK) {
+                core_1.TempSerializerGenerator.getInstance().saveFile();
+            }
+            if (result instanceof Promise) {
+                await result;
+            }
+            if (task.taskName === TaskConstants_1.TaskConstants.SYNC_TASK || task.taskName === TaskConstants_1.TaskConstants.CODE_PROCESSING_TASK) {
+                this.taskCleanUp();
+            }
+            core_1.Logger.info(`${task.taskName} end`);
+        }
+        catch (error) {
+            this.handleTaskError(error);
+        }
+    }
+    handleTaskError(error) {
+        if (error instanceof CustomError_1.CustomError) {
+            core_1.Logger.error(`Error: ${error.constructor.name}: ${error.code} ${error.message}\n${error.stack}`);
+        }
+        else {
+            const err = error;
+            core_1.Logger.error(`Error: ${err.constructor.name}: ${CustomError_1.ErrorCodes.INTERNAL_ERROR} ${err.message}\n${err.stack}`);
+        }
+        this.taskCleanUp();
+        throw new Error('serialization execute failed');
+    }
+    registerCleanTaskHook(targetContext) {
         const cleanTask = this.node.getTaskByName('clean');
-        if (cleanTask) {
-            cleanTask.beforeRun(() => {
-                const generatedRootDir = targetContext.getOutputRoot();
-                if (SerializationPathUtil_1.default.exist(generatedRootDir)) {
-                    core_1.Logger.info(`Clean up the generated directory: ${generatedRootDir}`);
-                    SerializationPathUtil_1.default.rmSync(generatedRootDir, { recursive: true, force: true });
-                }
-            });
+        if (!cleanTask) {
+            return;
+        }
+        cleanTask.beforeRun(() => this.cleanGeneratedDirectory(targetContext));
+    }
+    cleanGeneratedDirectory(targetContext) {
+        const generatedRootDir = targetContext.getOutputRoot();
+        if (!SerializationPathUtil_1.default.exist(generatedRootDir)) {
+            return;
         }
+        core_1.Logger.info(`Clean up the generated directory: ${generatedRootDir}`);
+        SerializationPathUtil_1.default.rmSync(generatedRootDir, { recursive: true, force: true });
     }
 }
 exports.JSONExecuteController = JSONExecuteController;

package/dist/json-plugin/interfaces/impl/TargetContext.js

@@ -90,7 +90,8 @@ class TargetContextImpl {
         }
         const sourceRootForRelative = sourceRoot.replace(/\/$/, '');
         const absolutePathForRelative = normalizedAbsolutePath.replace(/\/$/, '');
-        return SerializationPathUtil_1.default.relative(sourceRootForRelative, absolutePathForRelative).replaceAll(SerializationPathUtil_1.default.sep, '/');
+        return SerializationPathUtil_1.default.relative(sourceRootForRelative, absolutePathForRelative)
+            .replaceAll(SerializationPathUtil_1.default.sep, '/');
     }
     get targetSourceRoots() {
         if (!this.targetOpt.source?.sourceRoots) {
@@ -106,7 +107,8 @@ class TargetContextImpl {
         return this.targetSourceRoots.map((sourceRoot) => {
             const absolutePath = SerializationPathUtil_1.default.pathResolve(moduleRoot, sourceRoot);
             const normalizedPath = SerializationPathUtil_1.default.normalize(absolutePath);
-            return normalizedPath.endsWith(SerializationPathUtil_1.default.sep) ? normalizedPath : normalizedPath + SerializationPathUtil_1.default.sep;
+            return normalizedPath.endsWith(SerializationPathUtil_1.default.sep) ? normalizedPath :
+                normalizedPath + SerializationPathUtil_1.default.sep;
         });
     }
 }

package/dist/json-plugin/tasks/BaseTask.d.ts

@@ -1,4 +1,4 @@
-import { ITask, CodeGenerationEngine } from '../../core';
+import { ITask, CodeGenerationEngine, IGenerationResult } from '../../core';
 import { BuildProfileUpdaterImpl } from '../../core/import-rewrite/services/BuildProfileUpdater';
 import { ITargetContext } from '../interfaces/ITargetContext';
 export declare abstract class BaseTask implements ITask {
@@ -8,7 +8,7 @@ export declare abstract class BaseTask implements ITask {
     protected readonly engine: CodeGenerationEngine;
     protected readonly buildProfileUpdater: BuildProfileUpdaterImpl;
     protected getScanFiles(context: ITargetContext): string[];
-    protected processWithLogging(scanFiles: string[], context: ITargetContext, taskName: string): import("../../core").IGenerationResult;
+    protected processWithLogging(scanFiles: string[], context: ITargetContext, taskName: string): IGenerationResult;
     protected executeImportRewrite(context: ITargetContext, taskName: string): void;
     abstract run(context: ITargetContext): void | Promise<void>;
 }

package/dist/json-plugin/tasks/WatchTask.js

@@ -63,8 +63,9 @@ class WatchTask extends BaseTask_1.BaseTask {
         });
     }
     setupWatchEvents(context) {
-        if (!this.watcher)
+        if (!this.watcher) {
             return;
+        }
         let debounceTimer = null;
         const debouncedGenerate = (filePath) => {
             if (debounceTimer) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hadss/turbo-trans-json-plugin",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.2",
   "description": "TurboTransJSON Compiler Plugin for automatic serialization code generation",
   "main": "dist/index.js",
   "scripts": {

package/src/core/Types.ts

@@ -19,40 +19,40 @@ import { ClassDeclaration, InterfaceDeclaration, TypeNode } from 'ts-morph';
 
 export enum PropertyKind {
   // ===== 基础类型（对应PrimitiveKind） =====
-  STRING = 'string',        // StringSerializer.INSTANCE
-  NUMBER = 'number',        // NumberSerializer.INSTANCE
-  BOOLEAN = 'boolean',      // BooleanSerializer.INSTANCE
-  BIGINT = 'bigint',        // BigintSerializer.INSTANCE
+  STRING = 'string', // StringSerializer.INSTANCE
+  NUMBER = 'number', // NumberSerializer.INSTANCE
+  BOOLEAN = 'boolean', // BooleanSerializer.INSTANCE
+  BIGINT = 'bigint', // BigintSerializer.INSTANCE
 
   // ===== 特殊原始类型 =====
-  NULL = 'null',            // NullSerializer.INSTANCE
-  UNDEFINED = 'undefined',  // UndefinedSerializer.INSTANCE
+  NULL = 'null', // NullSerializer.INSTANCE
+  UNDEFINED = 'undefined', // UndefinedSerializer.INSTANCE
 
   // ===== 集合类型（泛型构造器） =====
-  ARRAY = 'array',          // new ArraySerializer<T>(elementSerializer)
-  MAP = 'map',              // new MapSerializer<K,V>(keySerializer, valueSerializer)
-  SET = 'set',              // new SetSerializer<T>(elementSerializer)
-  RECORD = 'record',        // new RecordSerializer<K,V>(keySerializer, valueSerializer)
-  COLLECTIONS_ARRAY = 'collections.Array',    // new CollectionsArraySerializer<T>(elementSerializer)
-  COLLECTIONS_SET = 'collections.Set',        // new CollectionsSetSerializer<T>(elementSerializer)
-  COLLECTIONS_MAP = 'collections.Map',        // new CollectionsMapSerializer<K,V>(keySerializer, valueSerializer)
+  ARRAY = 'array', // new ArraySerializer<T>(elementSerializer)
+  MAP = 'map', // new MapSerializer<K,V>(keySerializer, valueSerializer)
+  SET = 'set', // new SetSerializer<T>(elementSerializer)
+  RECORD = 'record', // new RecordSerializer<K,V>(keySerializer, valueSerializer)
+  COLLECTIONS_ARRAY = 'collections.Array', // new CollectionsArraySerializer<T>(elementSerializer)
+  COLLECTIONS_SET = 'collections.Set', // new CollectionsSetSerializer<T>(elementSerializer)
+  COLLECTIONS_MAP = 'collections.Map', // new CollectionsMapSerializer<K,V>(keySerializer, valueSerializer)
 
   // ===== 复杂对象类型 =====
-  OBJECT = 'object',        // ObjectSerializer.INSTANCE
-  GENERIC = 'generic',      // Serializer<T>
+  OBJECT = 'object', // ObjectSerializer.INSTANCE
+  GENERIC = 'generic', // Serializer<T>
 
   // ===== 高级类型 =====
-  UNION = 'union',          // new UnionTypeSerializer<string | number>([string, number])
-  OPTIONAL = 'optional',    // new OptionalSerializer<T>(serializer) - for T | undefined
-  NULLABLE = 'nullable',    // new NullableSerializer<T>(serializer) - for T | null
+  UNION = 'union', // new UnionTypeSerializer<string | number>([string, number])
+  OPTIONAL = 'optional', // new OptionalSerializer<T>(serializer) - for T | undefined
+  NULLABLE = 'nullable', // new NullableSerializer<T>(serializer) - for T | null
   OPTIONAL_NULLABLE = 'optionalNullable', // new OptionalNullableSerializer<T>(serializer) - for T | null | undefined
-  ENUM = 'enum',            // new EnumSerializer<number>('Habit', [['HAVE_FUN', 0], ['READING', 1], ['SPORT', 2]])
-  TUPLE = 'tuple',          // new TupleSerializer<[string, number]>([string, number])
-  ARRAY_LIST = 'arrayList',       // new ArrayListSerializer<T>(elementSerializer)
-  HASH_MAP = 'hashMap',           // new HashMapSerializer<K,V>(keySerializer, valueSerializer)
-  HASH_SET = 'hashSet',           // new HashSetSerializer<T>(elementSerializer)
-  LIST = 'list',                 // new ListSerializer<T>(elementSerializer)
-  Date = 'date',                  // new DateSerializer()
+  ENUM = 'enum', // new EnumSerializer<number>('Habit', [['HAVE_FUN', 0], ['READING', 1], ['SPORT', 2]])
+  TUPLE = 'tuple', // new TupleSerializer<[string, number]>([string, number])
+  ARRAY_LIST = 'arrayList', // new ArrayListSerializer<T>(elementSerializer)
+  HASH_MAP = 'hashMap', // new HashMapSerializer<K,V>(keySerializer, valueSerializer)
+  HASH_SET = 'hashSet', // new HashSetSerializer<T>(elementSerializer)
+  LIST = 'list', // new ListSerializer<T>(elementSerializer)
+  Date = 'date', // new DateSerializer()
   Decimal = 'decimal', // new DecimalSerializer()
   INTERFACE = 'interface', // new AnySerializer<T>(interfaceDeclaration)
 
@@ -73,23 +73,23 @@ export enum DeserializationMode {
  */
 export interface ClassAnalysis {
   // 基础信息
-  className: string;              // 类名
-  sourceFilePath: string;         // 类在源码中的绝对路径
+  className: string; // 类名
+  sourceFilePath: string; // 类在源码中的绝对路径
   originalClass?: ClassDeclaration; // 原始AST引用（可选，用于高级处理和回溯）
 
   // 核心特性
-  generics: GenericInfo;          // 泛型信息
-  inheritance: InheritanceInfo;   // 继承信息
-  decorators: ClassDecorators;    // 类装饰器
+  generics: GenericInfo; // 泛型信息
+  inheritance: InheritanceInfo; // 继承信息
+  decorators: ClassDecorators; // 类装饰器
 
   // 属性分组（基于继承信息的智能分组）
-  ownProperties: PropertyAnalysis[];        // 当前类自己定义的属性
-  inheritedProperties: PropertyAnalysis[];  // 从父类继承且未重写的属性
+  ownProperties: PropertyAnalysis[]; // 当前类自己定义的属性
+  inheritedProperties: PropertyAnalysis[]; // 从父类继承且未重写的属性
   overriddenProperties: PropertyAnalysis[]; // 重写了父类的属性
-  properties: PropertyAnalysis[];           // 所有属性的合并视图(重写后的属性会覆盖父类属性，只保留一个)
+  properties: PropertyAnalysis[]; // 所有属性的合并视图(重写后的属性会覆盖父类属性，只保留一个)
 
   // 构造函数信息
-  constructorParams: ConstructorParam[];    // 构造函数参数
+  constructorParams: ConstructorParam[]; // 构造函数参数
 
   // Sendable合并性
   canMerge?: boolean;
@@ -103,10 +103,10 @@ export interface InterfaceAnalysis {
   inheritance: InheritanceInfo;
   decorators?: ClassDecorators;
 
-  ownProperties: PropertyAnalysis[];        // 当前接口自己定义的属性
-  inheritedProperties: PropertyAnalysis[];  // 从父类继承且未重写的属性
+  ownProperties: PropertyAnalysis[]; // 当前接口自己定义的属性
+  inheritedProperties: PropertyAnalysis[]; // 从父类继承且未重写的属性
   overriddenProperties: PropertyAnalysis[]; // 重写了父类的属性
-  properties: PropertyAnalysis[];           // 所有属性的合并视图(重写后的属性会覆盖父类属性，只保留一个)
+  properties: PropertyAnalysis[]; // 所有属性的合并视图(重写后的属性会覆盖父类属性，只保留一个)
 }
 
 // ============= 第二层：类的核心特性 =============
@@ -116,8 +116,8 @@ export interface InterfaceAnalysis {
  * 专门处理类和方法的泛型参数、约束、变型信息
  */
 export interface GenericInfo {
-  isGeneric: boolean;             // 是否为泛型类/方法
-  parameters: string[];           // 泛型参数名列表 ['T', 'U']
+  isGeneric: boolean; // 是否为泛型类/方法
+  parameters: string[]; // 泛型参数名列表 ['T', 'U']
 }
 
 /**
@@ -125,9 +125,9 @@ export interface GenericInfo {
  * 描述类的继承关系
  */
 export interface InheritanceInfo {
-  isInherited: boolean;               // 是否继承其他类
-  baseClassAnalysis?: ClassAnalysis | InterfaceAnalysis;  // 直接父类的详细信息
-  genericTypeArguments?: TypeNode[];    // 继承时传入的泛型参数
+  isInherited: boolean; // 是否继承其他类
+  baseClassAnalysis?: ClassAnalysis | InterfaceAnalysis; // 直接父类的详细信息
+  genericTypeArguments?: TypeNode[]; // 继承时传入的泛型参数
 }
 
 /**
@@ -144,8 +144,8 @@ export interface ClassDecorators {
  * 配置序列化行为的选项
  */
 export interface SerializableOptions {
-  generateSendable?: boolean;    // 是否生成Sendable变体类
-  with?: string;                 // 自定义序列化器工厂（完整表达式内容）
+  generateSendable?: boolean; // 是否生成Sendable变体类
+  with?: string; // 自定义序列化器工厂（完整表达式内容）
   deserializationMode?: DeserializationMode; // 反序列化模式（粗糙/精确）
 }
 
@@ -154,10 +154,10 @@ export interface SerializableOptions {
  * 描述类构造函数的参数结构
  */
 export interface ConstructorParam {
-  name: string;                   // 参数名称
-  type: string;                   // 参数类型字符串
-  isOptional: boolean;           // 是否可选
-  defaultValue?: string;          // 默认值（可选）
+  name: string; // 参数名称
+  type: string; // 参数类型字符串
+  isOptional: boolean; // 是否可选
+  defaultValue?: string; // 默认值（可选）
 }
 
 // ============= 第三层：属性分析结果 =============
@@ -167,11 +167,18 @@ export interface ConstructorParam {
  * 阅读路径：PropertyAnalysis → 基础信息 → 类型分析 → 装饰器
  */
 export interface PropertyAnalysis {
-  name: string;                   // 属性名称
-  defaultValue?: string;          // 默认值表达式字符串
+  name: string; // 属性名称
+  defaultValue?: string; // 默认值表达式字符串
   decorators?: PropertyDecorators; // 装饰器信息
-  isMust: boolean;                // 精确模式下反序列化时的必要性
-  type: TypeStructure;       // 完整的类型分析结果（详细类型信息）
+  isMust: boolean; // 精确模式下反序列化时的必要性
+  type: TypeStructure; // 完整的类型分析结果（详细类型信息）
+  visibility: PropertyVisibility; // 属性可见性修饰符
+}
+
+export enum PropertyVisibility {
+  PUBLIC = 'public',
+  PRIVATE = 'private',
+  PROTECTED = 'protected',
 }
 
 /**
@@ -179,10 +186,11 @@ export interface PropertyAnalysis {
  * 分离装饰器解析结果，避免与分析结果混合
  */
 export interface PropertyDecorators {
-  serialName?: string;            // @SerialName 自定义序列化名称
-  isRequired: boolean;            // @Required 是否必需字段
-  isTransient: boolean;           // @Transient 是否跳过序列化
-  with?: string;                  // @Serializable 自定义序列化器
+  serialName?: string; // @SerialName 自定义序列化名称
+  isRequired: boolean; // @Required 是否必需字段
+  isTransient: boolean; // @Transient 是否跳过序列化
+  isPlainValue: boolean; // @PlainValue 是否使用原始值（跳过类型转换）
+  with?: string; // @Serializable 自定义序列化器
 }
 
 // ============= 第五层：类型结构详情 =============
@@ -192,17 +200,17 @@ export interface PropertyDecorators {
  * 阅读路径：TypeStructure → 基础信息 → 子结构 → 特殊类型信息
  */
 export interface TypeStructure {
-  kind: PropertyKind;             // 类型种类（STRING, ARRAY, MAP等）
-  depth: number;                  // 嵌套深度（用于复杂度控制）
-  sourceText: string;             // 原始类型文本（如 "Array<Map<string, User>>"）
-  args: TypeStructure[]           // 泛型参数的类型
+  kind: PropertyKind; // 类型种类（STRING, ARRAY, MAP等）
+  depth: number; // 嵌套深度（用于复杂度控制）
+  sourceText: string; // 原始类型文本（如 "Array<Map<string, User>>"）
+  args: TypeStructure[]; // 泛型参数的类型
   // 类型依赖和特殊信息
   dependencies: TypeDependency[]; // 依赖信息列表（包含完整导入信息）
-  enumDetails?: EnumDetails;      // 枚举类型详细信息（仅当kind=ENUM时）
-  classDetails?: ClassDetails;    // 枚举类型详细信息（仅当kind=OBJECT时）
-  interfaceDetails?: InterfaceDetails; //（仅当kind=INTERFACE时）
+  enumDetails?: EnumDetails; // 枚举类型详细信息（仅当kind=ENUM时）
+  classDetails?: ClassDetails; // 枚举类型详细信息（仅当kind=OBJECT时）
+  interfaceDetails?: InterfaceDetails; // （仅当kind=INTERFACE时）
   unionDetails?: TypeStructure[]; // Union types 的成员类型
-  isOptional?: boolean;           // 是否可选
+  isOptional?: boolean; // 是否可选
 }
 
 // ============= 第六层：类型依赖信息 =============
@@ -219,12 +227,12 @@ export enum TypeKind {
  * 阅读路径：TypeDependency → 基础信息 → 来源信息 → 详细信息
  */
 export interface TypeDependency {
-  typeName: string;               // 类型名称（如 "User"）
-  typeKind: TypeKind;             // 类型种类
-  importPath: string;             // 导入路径（如 "sampleentry/ets/model/User"）
+  typeName: string; // 类型名称（如 "User"）
+  typeKind: TypeKind; // 类型种类
+  importPath: string; // 导入路径（如 "sampleentry/ets/model/User"）
 
-  source: DependencySource;       // 统一的来源信息
-  details?: TypeDetails;          // 扩展的类型详细信息（按需包含）
+  source: DependencySource; // 统一的来源信息
+  details?: TypeDetails; // 扩展的类型详细信息（按需包含）
 }
 
 /**
@@ -232,9 +240,9 @@ export interface TypeDependency {
  */
 export interface DependencySource {
   type: 'local' | 'imported' | 'builtin'; // 本地定义/外部导入/内置类型
-  sourceFilePath?: string;        // 源文件绝对路径（仅当 type='local'|'imported' 时）
-  originalImport?: string;        // 原始导入语句（仅当 type='imported' 时）
-  packageName?: string;           // 包名（如果是包导入）
+  sourceFilePath?: string; // 源文件绝对路径（仅当 type='local'|'imported' 时）
+  originalImport?: string; // 原始导入语句（仅当 type='imported' 时）
+  packageName?: string; // 包名（如果是包导入）
 }
 
 // ============= 第七层：类型详细信息 =============
@@ -254,7 +262,7 @@ export type TypeDetails =
  */
 export interface EnumDetails {
   kind: TypeKind.ENUM;
-  members: EnumMemberInfo[];      // 枚举成员列表
+  members: EnumMemberInfo[]; // 枚举成员列表
   valueType: 'string' | 'number'; // 枚举值类型
 }
 
@@ -262,9 +270,9 @@ export interface EnumDetails {
  * 枚举成员信息（从EnumDetails.members跳转到这里）
  */
 export interface EnumMemberInfo {
-  name: string;                   // 枚举成员名称（如 'HAVE_FUN'）
-  value: string | number;         // 枚举成员值（如 0 或 'football'）
-  literalValue: string;           // 字面量形式（用于代码生成，如 '0' 或 "'football'"）
+  name: string; // 枚举成员名称（如 'HAVE_FUN'）
+  value: string | number; // 枚举成员值（如 0 或 'football'）
+  literalValue: string; // 字面量形式（用于代码生成，如 '0' 或 "'football'"）
 }
 
 /**
@@ -273,7 +281,7 @@ export interface EnumMemberInfo {
 export interface ClassDetails {
   kind: TypeKind.CLASS;
   classDecl: ClassDeclaration;
-  isGeneric: boolean;             // 是否为泛型类
+  isGeneric: boolean; // 是否为泛型类
 }
 
 /**
@@ -282,7 +290,7 @@ export interface ClassDetails {
 export interface InterfaceDetails {
   kind: TypeKind.INTERFACE;
   interfaceDecl: InterfaceDeclaration;
-  isGeneric: boolean;             // 是否为泛型接口
+  isGeneric: boolean; // 是否为泛型接口
 }
 
 /**
@@ -290,8 +298,8 @@ export interface InterfaceDetails {
  */
 export interface TypeAliasDetails {
   kind: TypeKind.TYPE;
-  aliasedType: string;               // 别名指向的类型字符串（如 "User | Admin"）
-  resolvedType: TypeStructure;      // 解析后的实际类型（递归分析结果）
+  aliasedType: string; // 别名指向的类型字符串（如 "User | Admin"）
+  resolvedType: TypeStructure; // 解析后的实际类型（递归分析结果）
 }
 
 // ============= 代码生成阶段 =============
@@ -301,7 +309,7 @@ export interface TypeAliasDetails {
  * 阅读路径：GenerationContext → 类分析 → 属性生成信息 → 模板和配置
  */
 export interface GenerationContext {
-  class: ClassAnalysis | InterfaceAnalysis;           // 类分析结果
+  class: ClassAnalysis | InterfaceAnalysis; // 类分析结果
   properties: PropertyGenerationInfo[]; // 属性生成信息列表
   serialNameConstant: string;
 }
@@ -311,7 +319,7 @@ export interface GenerationContext {
  * 阅读路径：PropertyGenerationInfo → 分析结果 → 序列化器元数据 → 模板数据
  */
 export interface PropertyGenerationInfo {
-  analysis: PropertyAnalysis;     // 引用分析结果（不重复存储）
+  analysis: PropertyAnalysis; // 引用分析结果（不重复存储）
   serializer: SerializerMetadata; // 序列化器生成元数据
 }
 
@@ -319,13 +327,13 @@ export interface PropertyGenerationInfo {
  * 序列化器元数据（从PropertyGenerationInfo.serializer跳转到这里）
  */
 export interface SerializerMetadata {
-  name: string;                   // 序列化器名称（如 "ArraySerializer"）
-  typeDeclaration: string;        // 类型声明（如 "ArraySerializer<User>"）
-  instantiationTemplate: string;  // 实例化模板（如 "new ArraySerializer<User>(UserSerializer.INSTANCE)"）
-  encodeMethod: string;           // 编码方法名（如 "encodeSerializableElement"）
-  decodeMethod: string;           // 解码方法名（如 "decodeSerializableElement"）
-  decoderType: string;            // 解码器类型（如 "string | undefined"）
-  needsTypeAssertion?: boolean;   // 是否需要类型断言（字符串枚举等情况）
+  name: string; // 序列化器名称（如 "ArraySerializer"）
+  typeDeclaration: string; // 类型声明（如 "ArraySerializer<User>"）
+  instantiationTemplate: string; // 实例化模板（如 "new ArraySerializer<User>(UserSerializer.INSTANCE)"）
+  encodeMethod: string; // 编码方法名（如 "encodeSerializableElement"）
+  decodeMethod: string; // 解码方法名（如 "decodeSerializableElement"）
+  decoderType: string; // 解码器类型（如 "string | undefined"）
+  needsTypeAssertion?: boolean; // 是否需要类型断言（字符串枚举等情况）
 }
 
 // ============= 配置和选项 =============