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

package/src/core/analyzers/CustomTypeAnalyzer.ts

@@ -16,6 +16,8 @@
 import {
   ClassDeclaration,
   EnumDeclaration,
+  EnumMember,
+  ImportDeclaration,
   InterfaceDeclaration,
   SourceFile,
   TypeAliasDeclaration
@@ -38,7 +40,8 @@ export class CustomTypeAnalyzer {
   /** 类型查找缓存 <名称+路径，依赖地址> */
   private searchCache = new Map<string, TypeDependency | null>();
 
-  private constructor() { }
+  private constructor() {
+  }
 
   public static getInstance(): CustomTypeAnalyzer {
     return this.INSTANCE;
@@ -96,7 +99,8 @@ export class CustomTypeAnalyzer {
     return null;
   }
 
-  public findClassDeclFromClassName(className: string, sourceFile: SourceFile): ClassDeclaration | InterfaceDeclaration | null {
+  public findClassDeclFromClassName(className: string,
+    sourceFile: SourceFile): ClassDeclaration | InterfaceDeclaration | null {
     const res = this.findDefinition(className, sourceFile);
     if (res && res.typeKind === TypeKind.CLASS) {
       return (res.details as ClassDetails).classDecl;
@@ -134,43 +138,72 @@ export class CustomTypeAnalyzer {
     for (const importDecl of imports) {
       // TODO:当前实现只处理命名导入，default导入和命名空间导入暂未支持
       const namedImports = importDecl.getNamedImports();
+      const matchedImport = namedImports.find(ni => ni.getName() === targetName);
+
+      if (!matchedImport) {
+        continue;
+      }
+
       const specifierValue = importDecl.getModuleSpecifierValue();
+      const result = this.processImportMatch(importDecl, targetName, sourceFile, specifierValue);
 
-      // 检查是否在命名导入中找到了目标类型
-      for (const namedImport of namedImports) {
-        const importName = namedImport.getName();
-        if (importName === targetName) {
-          // 找到了导入的类型，现在需要解析文件路径
-          const moduleSpecifier = importDecl.getModuleSpecifierValue();
-          const resolvedPath = this.resolveImportPath(moduleSpecifier, sourceFile);
-
-          if (resolvedPath && SerializationPathUtil.exist(resolvedPath)) {
-            // 加载外部文件并查找类型定义
-            const externalSourceFile = this.getOrLoadSourceFile(resolvedPath);
-            if (externalSourceFile) {
-              const typeDetail = this.searchInSourceFile(targetName, externalSourceFile);
-              if (typeDetail) {
-                return {
-                  typeName: targetName,
-                  typeKind: typeDetail.kind,
-                  importPath: specifierValue,
-                  source: {
-                    type: 'imported',
-                    sourceFilePath: externalSourceFile.getFilePath(),
-                    originalImport: specifierValue
-                  },
-                  details: typeDetail
-                };
-              }
-            }
-          }
-        }
+      if (result) {
+        return result;
       }
     }
 
     return null;
   }
 
+  /**
+   * 处理导入匹配，解析外部文件中的类型定义
+   *
+   * 处理流程：
+   * 1. 解析模块路径 → 路径无效则返回 null
+   * 2. 加载外部源文件 → 加载失败则返回 null
+   * 3. 在外部文件中查找类型 → 未找到则返回 null
+   * 4. 构建并返回类型依赖信息
+   */
+  private processImportMatch(
+    importDecl: ImportDeclaration,
+    targetName: string,
+    sourceFile: SourceFile,
+    specifierValue: string
+  ): TypeDependency | null {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    const resolvedPath = this.resolveImportPath(moduleSpecifier, sourceFile);
+
+    // 条件1：路径解析失败或文件不存在，无法继续处理
+    if (!resolvedPath || !SerializationPathUtil.exist(resolvedPath)) {
+      return null;
+    }
+
+    // 条件2：无法加载外部源文件（文件损坏或格式不支持）
+    const externalSourceFile = this.getOrLoadSourceFile(resolvedPath);
+    if (!externalSourceFile) {
+      return null;
+    }
+
+    // 条件3：在外部文件中未找到目标类型定义
+    const typeDetail = this.searchInSourceFile(targetName, externalSourceFile);
+    if (!typeDetail) {
+      return null;
+    }
+
+    // 所有条件通过，构建类型依赖结果
+    return {
+      typeName: targetName,
+      typeKind: typeDetail.kind,
+      importPath: specifierValue,
+      source: {
+        type: 'imported',
+        sourceFilePath: externalSourceFile.getFilePath(),
+        originalImport: specifierValue
+      },
+      details: typeDetail
+    };
+  }
+
   private findInCrossModule(targetName: string, sourceFile: SourceFile): TypeDependency | null {
     // TODO: 跨模块暂未实现
     return null;
@@ -214,53 +247,25 @@ export class CustomTypeAnalyzer {
 
   private parseEnumDetails(enumDecl: EnumDeclaration): EnumDetails {
     const members: EnumMemberInfo[] = [];
-    let valueType: 'string' | 'number' = 'number'; // 默认为数值类型
-    let numericValue = 0; // 用于自动递增的数值
+    let valueType: 'string' | 'number' = 'number';
+    let numericValue = 0;
 
     const enumMembers = enumDecl.getMembers();
     for (const member of enumMembers) {
-      const memberName = member.getName();
-      let memberValue: string | number;
-      let literalValue: string;
-
-      const initializer = member.getInitializer();
-      if (initializer) {
-        // 有显式初始值
-        const initText = initializer.getText().trim();
-
-        // 判断是字符串还是数值
-        if (initText.startsWith('"') && initText.endsWith('"')) {
-          // 字符串枚举
-          memberValue = initText.slice(1, -1); // 去掉引号
-          literalValue = initText; // 保留引号
-          valueType = 'string';
-        } else if (initText.startsWith("'") && initText.endsWith("'")) {
-          // 字符串枚举（单引号）
-          memberValue = initText.slice(1, -1); // 去掉引号
-          literalValue = `"${memberValue}"`; // 统一使用双引号
-          valueType = 'string';
-        } else {
-          // 数值枚举
-          const numValue = parseInt(initText, 10);
-          if (!isNaN(numValue)) {
-            memberValue = numValue;
-            literalValue = numValue.toString();
-            numericValue = numValue + 1; // 更新下一个自动值
-          } else {
-            // 复杂表达式，暂时当作字符串处理
-            memberValue = initText;
-            literalValue = `"${initText}"`;
-            valueType = 'string';
-          }
-        }
-      } else {
-        // 没有显式初始值，使用自动递增的数值
-        memberValue = numericValue;
-        literalValue = numericValue.toString();
-        numericValue++;
+      const {
+        memberValue,
+        literalValue,
+        type,
+        nextValue
+      } = this.parseEnumMember(member, numericValue);
+      numericValue = nextValue;
+
+      if (type === 'string') {
+        valueType = 'string';
       }
+
       members.push({
-        name: memberName,
+        name: member.getName(),
         value: memberValue,
         literalValue
       });
@@ -268,6 +273,73 @@ export class CustomTypeAnalyzer {
     return { kind: TypeKind.ENUM, valueType, members };
   }
 
+  /**
+   * 解析枚举成员的值信息
+   *
+   * 处理四种情况（互斥，按优先级顺序判断）：
+   * 1. 无初始化器 → 使用自增数字值
+   * 2. 双引号字符串 "value" → 字符串类型
+   * 3. 单引号字符串 'value' → 字符串类型（转换为双引号）
+   * 4. 数字字面量 → 数字类型，后续成员从此值+1继续自增
+   * 5. 其他表达式 → 作为字符串处理（兜底情况）
+   *
+   * @param member 枚举成员节点
+   * @param numericValue 当前自增数字值
+   * @returns 成员值信息，包含实际值、字面量表示、类型和下一个自增值
+   */
+  private parseEnumMember(member: EnumMember, numericValue: number): {
+    memberValue: string | number;
+    literalValue: string;
+    type: 'string' | 'number';
+    nextValue: number
+  } {
+    const initializer = member.getInitializer();
+
+    // 情况1：无初始化器，使用自增数字值（如 enum { A, B, C } 中的 A=0, B=1, C=2）
+    if (!initializer) {
+      return {
+        memberValue: numericValue,
+        literalValue: numericValue.toString(),
+        type: 'number',
+        nextValue: numericValue + 1
+      };
+    }
+
+    const initText = initializer.getText().trim();
+
+    // 情况2：双引号字符串（如 enum { A = "hello" }）
+    if (initText.startsWith('"') && initText.endsWith('"')) {
+      return this.createStringEnumResult(initText.slice(1, -1), initText, numericValue);
+    }
+
+    // 情况3：单引号字符串（如 enum { A = 'hello' }），转换为双引号格式
+    if (initText.startsWith("'") && initText.endsWith("'")) {
+      const val = initText.slice(1, -1);
+      return this.createStringEnumResult(val, `"${val}"`, numericValue);
+    }
+
+    // 情况4：数字字面量（如 enum { A = 10 }），后续成员从 11 开始自增
+    const numValue = parseInt(initText, 10);
+    if (!isNaN(numValue)) {
+      return { memberValue: numValue, literalValue: numValue.toString(), type: 'number', nextValue: numValue + 1 };
+    }
+
+    // 情况5：其他表达式（如常量引用），作为字符串处理
+    return this.createStringEnumResult(initText, `"${initText}"`, numericValue);
+  }
+
+  /**
+   * 创建字符串类型枚举成员结果
+   * 注意：字符串枚举不影响自增值，nextValue 保持不变
+   */
+  private createStringEnumResult(
+    memberValue: string,
+    literalValue: string,
+    numericValue: number
+  ): { memberValue: string; literalValue: string; type: 'string'; nextValue: number } {
+    return { memberValue, literalValue, type: 'string', nextValue: numericValue };
+  }
+
   private parseClassDetails(classDecl: ClassDeclaration): ClassDetails {
     return {
       kind: TypeKind.CLASS,

package/src/core/constants/DecoratorConstants.ts

@@ -18,11 +18,12 @@
  */
 export class DecoratorConstants {
   // TSerialization装饰器
-  static readonly SERIALIZABLE = 'Serializable'
-  static readonly SERIAL_NAME = 'SerialName'
-  static readonly REQUIRED = 'Required'
-  static readonly TRANSIENT = 'Transient'
-  static readonly PLAIN_VALUE = 'PlainValue'
+  static readonly SERIALIZABLE = 'Serializable';
+  static readonly SERIAL_NAME = 'SerialName';
+  static readonly REQUIRED = 'Required';
+  static readonly TRANSIENT = 'Transient';
+  static readonly PLAIN_VALUE = 'PlainValue';
 
-  static readonly SERIAL_DECORATORS = [this.SERIALIZABLE, this.SERIAL_NAME, this.REQUIRED, this.TRANSIENT, this.PLAIN_VALUE];
+  static readonly SERIAL_DECORATORS = [this.SERIALIZABLE, this.SERIAL_NAME, this.REQUIRED, this.TRANSIENT,
+    this.PLAIN_VALUE];
 }

package/src/core/constants/PathConstants.ts

@@ -18,14 +18,14 @@
  */
 export class PathConstants {
   /** 默认源代码根目录 */
-  static readonly DEFAULT_SOURCE_ROOT = './src/main'
-  
+  static readonly DEFAULT_SOURCE_ROOT = './src/main';
+
   /** 生成代码根目录 */
-  static readonly GENERATED_ROOT = './src/generated'
-  
+  static readonly GENERATED_ROOT = './src/generated';
+
   /** 支持的文件扩展名 */
-  static readonly ETS_EXTENSIONS = '.ets'
-  
+  static readonly ETS_EXTENSIONS = '.ets';
+
   /** 默认扫描目录 */
-  static readonly DEFAULT_SCAN_DIRS = ['src/main/ets']
+  static readonly DEFAULT_SCAN_DIRS = ['src/main/ets'];
 }

package/src/core/constants/StringConstants.ts

@@ -18,133 +18,133 @@
  * 避免硬编码字符串散布在代码中
  */
 export class StringConstants {
-  
+
   // ========== 基础类型字符串 ==========
-  static readonly TYPE_BOOLEAN = 'boolean'
-  static readonly TYPE_NUMBER = 'number'
-  static readonly TYPE_STRING = 'string'
-  static readonly TYPE_BIGINT = 'bigint'
-  static readonly TYPE_NULL = 'null'
-  static readonly TYPE_UNDEFINED = 'undefined'
-  static readonly TYPE_ARRAY = 'array'
-  static readonly TYPE_SET = 'set'
-  static readonly TYPE_MAP = 'map'
-  static readonly TYPE_UNION = 'union'
-  static readonly TYPE_ENUM = 'enum'
+  static readonly TYPE_BOOLEAN = 'boolean';
+  static readonly TYPE_NUMBER = 'number';
+  static readonly TYPE_STRING = 'string';
+  static readonly TYPE_BIGINT = 'bigint';
+  static readonly TYPE_NULL = 'null';
+  static readonly TYPE_UNDEFINED = 'undefined';
+  static readonly TYPE_ARRAY = 'array';
+  static readonly TYPE_SET = 'set';
+  static readonly TYPE_MAP = 'map';
+  static readonly TYPE_UNION = 'union';
+  static readonly TYPE_ENUM = 'enum';
 
   // ========== 序列化器名称 ==========
   // 基础类型序列化器（单例INSTANCE模式）
-  static readonly BOOLEAN_SERIALIZER = 'BooleanSerializer'
-  static readonly NUMBER_SERIALIZER = 'NumberSerializer'
-  static readonly STRING_SERIALIZER = 'StringSerializer'
-  static readonly BIGINT_SERIALIZER = 'BigintSerializer'
-  
+  static readonly BOOLEAN_SERIALIZER = 'BooleanSerializer';
+  static readonly NUMBER_SERIALIZER = 'NumberSerializer';
+  static readonly STRING_SERIALIZER = 'StringSerializer';
+  static readonly BIGINT_SERIALIZER = 'BigintSerializer';
+
   // 特殊原始类型序列化器（单例INSTANCE模式）
-  static readonly NULL_SERIALIZER = 'NullSerializer'
-  static readonly UNDEFINED_SERIALIZER = 'UndefinedSerializer'
-  
+  static readonly NULL_SERIALIZER = 'NullSerializer';
+  static readonly UNDEFINED_SERIALIZER = 'UndefinedSerializer';
+
   // 集合类型序列化器（泛型构造器模式）
-  static readonly ARRAY_SERIALIZER = 'ArraySerializer'
-  static readonly COLLECTIONS_ARRAY_SERIALIZER = 'CollectionsArraySerializer'
-  static readonly MAP_SERIALIZER = 'MapSerializer'
-  static readonly COLLECTIONS_MAP_SERIALIZER = 'CollectionsMapSerializer'
-  static readonly SET_SERIALIZER = 'SetSerializer'
-  static readonly COLLECTIONS_SET_SERIALIZER = 'CollectionsSetSerializer'
-  static readonly RECORD_SERIALIZER = 'RecordSerializer'
+  static readonly ARRAY_SERIALIZER = 'ArraySerializer';
+  static readonly COLLECTIONS_ARRAY_SERIALIZER = 'CollectionsArraySerializer';
+  static readonly MAP_SERIALIZER = 'MapSerializer';
+  static readonly COLLECTIONS_MAP_SERIALIZER = 'CollectionsMapSerializer';
+  static readonly SET_SERIALIZER = 'SetSerializer';
+  static readonly COLLECTIONS_SET_SERIALIZER = 'CollectionsSetSerializer';
+  static readonly RECORD_SERIALIZER = 'RecordSerializer';
 
   // 高级类型序列化器（特殊构造器模式）
-  static readonly UNION_TYPE_SERIALIZER = 'UnionTypeSerializer'
-  static readonly OPTIONAL_SERIALIZER = 'OptionalSerializer'
-  static readonly NULLABLE_SERIALIZER = 'NullableSerializer'
-  static readonly ENUM_SERIALIZER = 'EnumSerializer'
-  
+  static readonly UNION_TYPE_SERIALIZER = 'UnionTypeSerializer';
+  static readonly OPTIONAL_SERIALIZER = 'OptionalSerializer';
+  static readonly NULLABLE_SERIALIZER = 'NullableSerializer';
+  static readonly ENUM_SERIALIZER = 'EnumSerializer';
+
   // 通用序列化器
-  static readonly SERIALIZER = 'Serializer'
-  static readonly SERIALIZER_FACTORY = 'SerializerFactory'
+  static readonly SERIALIZER = 'Serializer';
+  static readonly SERIALIZER_FACTORY = 'SerializerFactory';
 
   // ========== 编码/解码方法名 ==========
   // 基础类型专用编码方法
-  static readonly ENCODE_BOOLEAN_ELEMENT = 'encodeBooleanElement'
-  static readonly ENCODE_NUMBER_ELEMENT = 'encodeNumberElement'
-  static readonly ENCODE_STRING_ELEMENT = 'encodeStringElement'
-  static readonly ENCODE_BIGINT_ELEMENT = 'encodeBigintElement'
-  
+  static readonly ENCODE_BOOLEAN_ELEMENT = 'encodeBooleanElement';
+  static readonly ENCODE_NUMBER_ELEMENT = 'encodeNumberElement';
+  static readonly ENCODE_STRING_ELEMENT = 'encodeStringElement';
+  static readonly ENCODE_BIGINT_ELEMENT = 'encodeBigintElement';
+
   // 特殊原始类型专用编码方法
-  static readonly ENCODE_NULL_ELEMENT = 'encodeNullElement'
-  static readonly ENCODE_UNDEFINED_ELEMENT = 'encodeUndefinedElement'
-  
+  static readonly ENCODE_NULL_ELEMENT = 'encodeNullElement';
+  static readonly ENCODE_UNDEFINED_ELEMENT = 'encodeUndefinedElement';
+
   // 通用编码方法
-  static readonly ENCODE_SERIALIZABLE_ELEMENT = 'encodeSerializableElement'
+  static readonly ENCODE_SERIALIZABLE_ELEMENT = 'encodeSerializableElement';
 
   // 基础类型专用解码方法
-  static readonly DECODE_BOOLEAN = 'decodeBoolean'
-  static readonly DECODE_NUMBER = 'decodeNumber'
-  static readonly DECODE_STRING = 'decodeString'
-  static readonly DECODE_BIGINT = 'decodeBigint'
-  
+  static readonly DECODE_BOOLEAN = 'decodeBoolean';
+  static readonly DECODE_NUMBER = 'decodeNumber';
+  static readonly DECODE_STRING = 'decodeString';
+  static readonly DECODE_BIGINT = 'decodeBigint';
+
   // 特殊原始类型专用解码方法
-  static readonly DECODE_NULL = 'decodeNull'
-  static readonly DECODE_UNDEFINED = 'decodeUndefined'
-  
+  static readonly DECODE_NULL = 'decodeNull';
+  static readonly DECODE_UNDEFINED = 'decodeUndefined';
+
   // 通用解码方法
-  static readonly DESERIALIZABLE = 'deserialize'
+  static readonly DESERIALIZABLE = 'deserialize';
 
   // ========== 导入模块相关 ==========
-  static readonly IMPORT_BUILD_CLASS_SERIAL_DESCRIPTOR = 'buildClassSerialDescriptor'
-  static readonly IMPORT_DECODER = 'Decoder'
-  static readonly IMPORT_ENCODER = 'Encoder'
-  static readonly IMPORT_SERIAL_DESCRIPTOR = 'SerialDescriptor'
-  static readonly IMPORT_SERIALIZER = 'Serializer'
+  static readonly IMPORT_BUILD_CLASS_SERIAL_DESCRIPTOR = 'buildClassSerialDescriptor';
+  static readonly IMPORT_DECODER = 'Decoder';
+  static readonly IMPORT_ENCODER = 'Encoder';
+  static readonly IMPORT_SERIAL_DESCRIPTOR = 'SerialDescriptor';
+  static readonly IMPORT_SERIALIZER = 'Serializer';
 
-  static readonly IMPORT_TJSON = 'TJSON'
-  static readonly IMPORT_IT_SERIALIZABLE = 'ITSerializable'
-  static readonly IMPORT_LANG = 'lang'
+  static readonly IMPORT_TJSON = 'TJSON';
+  static readonly IMPORT_IT_SERIALIZABLE = 'ITSerializable';
+  static readonly IMPORT_LANG = 'lang';
 
   // ========== 类型推断相关 ==========
-  static readonly BOOLEAN_WRAPPER = 'Boolean'
-  static readonly NUMBER_WRAPPER = 'Number'
-  static readonly STRING_WRAPPER = 'String'
+  static readonly BOOLEAN_WRAPPER = 'Boolean';
+  static readonly NUMBER_WRAPPER = 'Number';
+  static readonly STRING_WRAPPER = 'String';
 
-  static readonly ARRAY_SUFFIX = '[]'
-  static readonly ARRAY_PREFIX = 'array<'
+  static readonly ARRAY_SUFFIX = '[]';
+  static readonly ARRAY_PREFIX = 'array<';
 
   // ========== 默认值相关 ==========
-  static readonly DEFAULT_VALUE_FALSE = 'false'
-  static readonly DEFAULT_VALUE_ZERO = '0'
-  static readonly DEFAULT_VALUE_EMPTY_STRING = "''"
-  static readonly DEFAULT_VALUE_ZERO_BIGINT = '0n'
-  static readonly DEFAULT_VALUE_UNDEFINED = 'undefined'
+  static readonly DEFAULT_VALUE_FALSE = 'false';
+  static readonly DEFAULT_VALUE_ZERO = '0';
+  static readonly DEFAULT_VALUE_EMPTY_STRING = "''";
+  static readonly DEFAULT_VALUE_ZERO_BIGINT = '0n';
+  static readonly DEFAULT_VALUE_UNDEFINED = 'undefined';
 
   // ========== 模板字符串片段 ==========
-  static readonly TEMPLATE_ELEMENT_NAME = 'element'
-  static readonly TEMPLATE_SENDABLE_ERROR_PREFIX = 'Sendable support not enabled for'
-  
+  static readonly TEMPLATE_ELEMENT_NAME = 'element';
+  static readonly TEMPLATE_SENDABLE_ERROR_PREFIX = 'Sendable support not enabled for';
+
   // ========== 文件操作相关 ==========
-  static readonly FILE_OPERATION_EMPTY_STRING = ''
-  static readonly REGEX_IMPORT_STATEMENT = /import\s+({[^}]+}|\w+)\s+from\s+'([^']+)'/
-  static readonly REGEX_SRC_MAIN_ETS = /\/src\/main\/ets\/(.*)\.ets$/
-  
+  static readonly FILE_OPERATION_EMPTY_STRING = '';
+  static readonly REGEX_IMPORT_STATEMENT = /import\s+({[^}]+}|\w+)\s+from\s+'([^']+)'/;
+  static readonly REGEX_SRC_MAIN_ETS = /\/src\/main\/ets\/(.*)\.ets$/;
+
   // ========== 分隔符和连接符 ==========
-  static readonly SEPARATOR_COMMA = ','
-  static readonly SEPARATOR_COMMA_NEWLINE = ',\n'
-  static readonly SEPARATOR_NEWLINE = '\n'
-  static readonly SEPARATOR_COMMA_SPACE = ', '
-  static readonly JOIN_ELEMENT_PREFIX = ',\n  '
-  
+  static readonly SEPARATOR_COMMA = ',';
+  static readonly SEPARATOR_COMMA_NEWLINE = ',\n';
+  static readonly SEPARATOR_NEWLINE = '\n';
+  static readonly SEPARATOR_COMMA_SPACE = ', ';
+  static readonly JOIN_ELEMENT_PREFIX = ',\n  ';
+
   // ========== 正则表达式字符串 ==========
-  static readonly CURLY_BRACE_START = '{'
-  static readonly PATH_RELATIVE_PREFIX = './'
-  static readonly INSTANCE_SUFFIX = '.INSTANCE'
-  static readonly SERIALIZER_SUFFIX = 'Serializer'
-  
+  static readonly CURLY_BRACE_START = '{';
+  static readonly PATH_RELATIVE_PREFIX = './';
+  static readonly INSTANCE_SUFFIX = '.INSTANCE';
+  static readonly SERIALIZER_SUFFIX = 'Serializer';
+
   // ========== 日志前缀 ==========
-  static readonly LOG_PREFIX_T_SERIALIZATION = '[TSerialization]'
-  static readonly LOG_MODULE_PREFIX_TEMPLATE = '[${module}]'
-  
+  static readonly LOG_PREFIX_T_SERIALIZATION = '[TSerialization]';
+  static readonly LOG_MODULE_PREFIX_TEMPLATE = '[${module}]';
+
   // ========== 插件标识 ==========
-  static readonly PLUGIN_ID = 'turboTransJsonPlugin'
-  
+  static readonly PLUGIN_ID = 'turboTransJsonPlugin';
+
   // ========== 模块标识符 ==========
-  static readonly JSON_MODULE_SPECIFIER = '@hadss/hmserialization-json'
-  static readonly ARKTS_MODULE_SPECIFIER = '@kit.ArkTS'
+  static readonly JSON_MODULE_SPECIFIER = '@hadss/hmserialization-json';
+  static readonly ARKTS_MODULE_SPECIFIER = '@kit.ArkTS';
 }

package/src/core/handlers/BaseTypeHandler.ts

@@ -24,13 +24,21 @@ export abstract class BaseTypeHandler implements ITypeHandler {
 
   // 子类必须实现的所有核心方法
   abstract matches(typeNode: TypeNode, context: TypeContext): boolean;
+
   abstract parse(typeNode: TypeNode, context: TypeContext): TypeStructure;
+
   abstract getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata;
+
   abstract generateInstantiation(structure: TypeStructure): string;
+
   abstract generateTypeDeclaration(structure: TypeStructure): string;
+
   abstract generateTypeKey(structure: TypeStructure): string;
+
   abstract generateSendableTypeDeclaration(structure: TypeStructure): string;
-  abstract generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string;
+
+  abstract generatePropertyConversion(structure: TypeStructure, sourceValue: string,
+    direction: ConversionDirection): string;
 
   /** 获取序列化器名称（约定：TypeName + Serializer）*/
   protected getSerializerName(): string {
@@ -55,7 +63,8 @@ export abstract class BaseTypeHandler implements ITypeHandler {
    * @param defaultInstantiation 默认实例化代码
    * @param structure 类型结构
    */
-  protected applyWithParam(withParam: string | undefined, defaultInstantiation: string, structure: TypeStructure): string {
+  protected applyWithParam(withParam: string | undefined, defaultInstantiation: string,
+    structure: TypeStructure): string {
     if (!withParam) {
       return defaultInstantiation;
     }

package/src/core/handlers/CustomClassHandler.ts

@@ -99,9 +99,9 @@ export class CustomClassHandler extends BaseTypeHandler implements ITypeHandler
     }
   }
 
-  private parseGenericArguments(typeArgs: TypeNode[], context: TypeContext): { 
-    dependencies: TypeDependency[]; 
-    parsedArgs: TypeStructure[] 
+  private parseGenericArguments(typeArgs: TypeNode[], context: TypeContext): {
+    dependencies: TypeDependency[];
+    parsedArgs: TypeStructure[]
   } {
     const dependencies: TypeDependency[] = [];
     const parsedArgs: TypeStructure[] = typeArgs.map(arg => {
@@ -113,7 +113,7 @@ export class CustomClassHandler extends BaseTypeHandler implements ITypeHandler
       dependencies.push(...argStructure.dependencies);
       return argStructure;
     });
-    
+
     return { dependencies, parsedArgs };
   }