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

package/src/core/logger/Logger.ts

@@ -13,9 +13,9 @@
  * limitations under the License.
  */
 
-import { HvigorLogger } from '@ohos/hvigor'
+import { HvigorLogger } from '@ohos/hvigor';
 
-const PREFIX = '[TSerialization]'
+const PREFIX = '[TSerialization]';
 
 /**
  * TSerialization 日志工具类
@@ -23,28 +23,28 @@ const PREFIX = '[TSerialization]'
  */
 export class Logger {
   /** 当前模块上下文 */
-  private static currentModule: string = ''
+  private static currentModule: string = '';
 
   /**
    * 设置当前模块上下文
    * @param moduleName 模块名称
    */
   static setModuleContext(moduleName: string): void {
-    this.currentModule = moduleName
+    this.currentModule = moduleName;
   }
 
   /**
    * 清除当前模块上下文
    */
   static clearModuleContext(): void {
-    this.currentModule = ''
+    this.currentModule = '';
   }
 
   /**
    * 获取当前模块上下文
    */
   static getCurrentModule(): string {
-    return this.currentModule
+    return this.currentModule;
   }
 
   /**
@@ -53,8 +53,8 @@ export class Logger {
    * @returns 格式化后的消息
    */
   private static formatMessage(msg: string): string {
-    const modulePrefix = this.currentModule ? `[${this.currentModule}]` : ''
-    return `${PREFIX}${modulePrefix} ${msg}`
+    const modulePrefix = this.currentModule ? `[${this.currentModule}]` : '';
+    return `${PREFIX}${modulePrefix} ${msg}`;
   }
 
   /**
@@ -63,11 +63,11 @@ export class Logger {
    * @param args 额外参数
    */
   static error(msg: string, ...args: unknown[]): void {
-    const formattedMsg = this.formatMessage(msg)
+    const formattedMsg = this.formatMessage(msg);
     if (args.length > 0) {
-      HvigorLogger.getLogger().error(formattedMsg, ...args)
+      HvigorLogger.getLogger().error(formattedMsg, ...args);
     } else {
-      HvigorLogger.getLogger().error(formattedMsg)
+      HvigorLogger.getLogger().error(formattedMsg);
     }
   }
 
@@ -77,11 +77,11 @@ export class Logger {
    * @param args 额外参数
    */
   static info(msg: string, ...args: unknown[]): void {
-    const formattedMsg = this.formatMessage(msg)
+    const formattedMsg = this.formatMessage(msg);
     if (args.length > 0) {
-      HvigorLogger.getLogger().info(formattedMsg, ...args)
+      HvigorLogger.getLogger().info(formattedMsg, ...args);
     } else {
-      HvigorLogger.getLogger().info(formattedMsg)
+      HvigorLogger.getLogger().info(formattedMsg);
     }
   }
 
@@ -91,11 +91,11 @@ export class Logger {
    * @param args 额外参数
    */
   static warn(msg: string, ...args: unknown[]): void {
-    const formattedMsg = this.formatMessage(msg)
+    const formattedMsg = this.formatMessage(msg);
     if (args.length > 0) {
-      HvigorLogger.getLogger().warn(formattedMsg, ...args)
+      HvigorLogger.getLogger().warn(formattedMsg, ...args);
     } else {
-      HvigorLogger.getLogger().warn(formattedMsg)
+      HvigorLogger.getLogger().warn(formattedMsg);
     }
   }
 
@@ -105,11 +105,11 @@ export class Logger {
    * @param args 额外参数
    */
   static debug(msg: string, ...args: unknown[]): void {
-    const formattedMsg = this.formatMessage(msg)
+    const formattedMsg = this.formatMessage(msg);
     if (args.length > 0) {
-      HvigorLogger.getLogger().debug(formattedMsg, ...args)
+      HvigorLogger.getLogger().debug(formattedMsg, ...args);
     } else {
-      HvigorLogger.getLogger().debug(formattedMsg)
+      HvigorLogger.getLogger().debug(formattedMsg);
     }
   }
 
@@ -120,13 +120,13 @@ export class Logger {
    * @returns 函数执行结果
    */
   static withModuleContext<T>(moduleName: string, fn: () => T): T {
-    const previousModule = this.currentModule
+    const previousModule = this.currentModule;
     try {
-      this.setModuleContext(moduleName)
-      return fn()
+      this.setModuleContext(moduleName);
+      return fn();
     } finally {
       // 恢复之前的模块上下文
-      this.currentModule = previousModule
+      this.currentModule = previousModule;
     }
   }
 
@@ -137,13 +137,13 @@ export class Logger {
    * @returns Promise
    */
   static async withModuleContextAsync<T>(moduleName: string, fn: () => Promise<T>): Promise<T> {
-    const previousModule = this.currentModule
+    const previousModule = this.currentModule;
     try {
-      this.setModuleContext(moduleName)
-      return await fn()
+      this.setModuleContext(moduleName);
+      return await fn();
     } finally {
       // 恢复之前的模块上下文
-      this.currentModule = previousModule
+      this.currentModule = previousModule;
     }
   }
 }

package/src/core/services/CodeAnalysisService.ts

@@ -13,13 +13,14 @@
  * limitations under the License.
  */
 
-import { ClassDeclaration, ModuleKind, Project, ScriptTarget } from 'ts-morph';
+import { ClassDeclaration } from 'ts-morph';
 import { ClassAnalysis, DecoratorConstants, Logger } from '..';
 import { ClassAnalyzer } from '../analyzers/ClassAnalyzer';
 import { TsMorphUtil } from '../utils/TsMorphUtil';
 
 export class CodeAnalysisService {
-  constructor() { }
+  constructor() {
+  }
 
   analyzeFile(filePath: string): ClassAnalysis[] {
     Logger.debug(`开始分析文件: ${filePath}`);

package/src/core/services/CodeGenerationEngine.ts

@@ -21,15 +21,15 @@ import { SendableMergeChecker } from '../analyzers/SendableMergeChecker';
 import { CustomTypeAnalyzer } from '../analyzers/CustomTypeAnalyzer';
 
 export class CodeGenerationEngine {
-  private readonly analysisService: CodeAnalysisService
-  private readonly generationService: CodeGenerationService
+  private readonly analysisService: CodeAnalysisService;
+  private readonly generationService: CodeGenerationService;
 
   // 保存分析结果供导入重写使用
-  private allClassAnalysis: ClassAnalysis[] = []
+  private allClassAnalysis: ClassAnalysis[] = [];
 
   constructor() {
-    this.analysisService = new CodeAnalysisService()
-    this.generationService = new CodeGenerationService()
+    this.analysisService = new CodeAnalysisService();
+    this.generationService = new CodeGenerationService();
   }
 
   /**
@@ -39,72 +39,72 @@ export class CodeGenerationEngine {
    */
   processFilesUnified(scanFiles: string[], context: ITaskContext): IGenerationResult {
     if (!scanFiles || scanFiles.length === 0) {
-      Logger.info('没有待处理的源文件')
+      Logger.info('没有待处理的源文件');
       return {
         generatedFiles: [],
         skippedFiles: []
-      }
+      };
     }
 
-    const generatedFiles: IGeneratedFile[] = []
-    const skippedFiles: string[] = []
+    const generatedFiles: IGeneratedFile[] = [];
+    const skippedFiles: string[] = [];
 
     // 重置分析结果和合并性注册表
-    this.allClassAnalysis = []
-    SendableMergeabilityRegistry.clear()
+    this.allClassAnalysis = [];
+    SendableMergeabilityRegistry.clear();
 
-    Logger.info(`开始处理 ${scanFiles.length} 个源文件`)
+    Logger.info(`开始处理 ${scanFiles.length} 个源文件`);
 
     // ========== 阶段1：分析所有文件并检查合并性 ==========
-    Logger.debug(`[阶段1] 开始分析所有文件`)
-    const fileAnalysisMap = new Map<string, ClassAnalysis[]>()
+    Logger.debug(`[阶段1] 开始分析所有文件`);
+    const fileAnalysisMap = new Map<string, ClassAnalysis[]>();
 
     // 步骤1.1：分析所有文件的基本信息
     for (const filePath of scanFiles) {
-      const classAnalysis = this.analysisService.analyzeFile(filePath)
+      const classAnalysis = this.analysisService.analyzeFile(filePath);
 
       if (classAnalysis.length === 0) {
-        skippedFiles.push(filePath)
-        Logger.debug(`跳过文件（无@Serializable类）: ${filePath}`)
-        continue
+        skippedFiles.push(filePath);
+        Logger.debug(`跳过文件（无@Serializable类）: ${filePath}`);
+        continue;
       }
 
       // 保存分析结果
-      fileAnalysisMap.set(filePath, classAnalysis)
-      this.allClassAnalysis.push(...classAnalysis)
+      fileAnalysisMap.set(filePath, classAnalysis);
+      this.allClassAnalysis.push(...classAnalysis);
     }
 
-    Logger.debug(`[阶段1.1] 完成基本分析，共 ${this.allClassAnalysis.length} 个类`)
+    Logger.debug(`[阶段1.1] 完成基本分析，共 ${this.allClassAnalysis.length} 个类`);
 
     // 步骤1.2：检查所有类的合并性并注册到全局注册表
-    Logger.debug(`[阶段1.2] 开始检查合并性并注册`)
+    Logger.debug(`[阶段1.2] 开始检查合并性并注册`);
     for (const analysis of this.allClassAnalysis) {
       // 仅对启用 generateSendable 的类检查合并性
       if (analysis.decorators.serializable?.generateSendable) {
-        analysis.canMerge = SendableMergeChecker.check(analysis)
-        SendableMergeabilityRegistry.register(analysis.className, analysis.canMerge)
+        analysis.canMerge = SendableMergeChecker.check(analysis);
+        SendableMergeabilityRegistry.register(analysis.className, analysis.canMerge);
       } else {
         // 未启用 generateSendable 的类，注册为不可合并
-        SendableMergeabilityRegistry.register(analysis.className, false)
+        SendableMergeabilityRegistry.register(analysis.className, false);
       }
     }
 
     // ========== 阶段2：生成所有文件 ==========
-    Logger.debug(`[阶段2] 开始生成所有文件`)
+    Logger.debug(`[阶段2] 开始生成所有文件`);
 
     for (const [filePath, classAnalysis] of fileAnalysisMap.entries()) {
-      const generatedFile = this.generationService.generateForSourceFile(filePath, classAnalysis, context)
+      const generatedFile = this.generationService.generateForSourceFile(filePath, classAnalysis, context);
       if (generatedFile) {
-        generatedFiles.push(generatedFile)
-        Logger.debug(`成功处理文件: ${filePath}`)
+        generatedFiles.push(generatedFile);
+        Logger.debug(`成功处理文件: ${filePath}`);
       } else {
-        Logger.warn(`文件生成失败: ${filePath}`)
+        Logger.warn(`文件生成失败: ${filePath}`);
       }
     }
 
-    Logger.info(`处理完成，成功 ${generatedFiles.length} 个，跳过 ${skippedFiles.length} 个`)
+    Logger.info(`处理完成，成功 ${generatedFiles.length} 个，跳过 ${skippedFiles.length} 个`);
 
-    return { generatedFiles, skippedFiles }
+    return { generatedFiles, skippedFiles };
   }
 
   /**
@@ -113,19 +113,19 @@ export class CodeGenerationEngine {
    * @returns 生成的文件信息，如果无需生成则返回null
    */
   processFileUnified(filePath: string, context: ITaskContext): IGeneratedFile | null {
-    const classAnalysis = this.analysisService.analyzeFile(filePath)
+    const classAnalysis = this.analysisService.analyzeFile(filePath);
 
     // 如果没有@Serializable类，跳过生成
     if (classAnalysis.length === 0) {
-      Logger.debug(`源文件 ${filePath} 无@Serializable类，跳过生成`)
-      return null
+      Logger.debug(`源文件 ${filePath} 无@Serializable类，跳过生成`);
+      return null;
     }
 
     // 保存分析结果供导入重写使用
-    this.allClassAnalysis.push(...classAnalysis)
+    this.allClassAnalysis.push(...classAnalysis);
 
     // 生成对应文件
-    return this.generationService.generateForSourceFile(filePath, classAnalysis, context)
+    return this.generationService.generateForSourceFile(filePath, classAnalysis, context);
   }
 
 
@@ -165,7 +165,7 @@ export class CodeGenerationEngine {
    * 供外部使用（如调试）
    */
   getAllAnalysisResults(): ClassAnalysis[] {
-    return [...this.allClassAnalysis]
+    return [...this.allClassAnalysis];
   }
 
   /**
@@ -173,9 +173,9 @@ export class CodeGenerationEngine {
    * 注意：这个方法应该在整个流程（包括导入重写）完成后调用
    */
   cleanup(): void {
-    this.analysisService.dispose()
-    this.allClassAnalysis = []
-    CustomTypeAnalyzer.getInstance().clearCache()
-    SendableMergeabilityRegistry.clear()
+    this.analysisService.dispose();
+    this.allClassAnalysis = [];
+    CustomTypeAnalyzer.getInstance().clearCache();
+    SendableMergeabilityRegistry.clear();
   }
 }

package/src/core/services/CodeGenerationService/CodeGenerationService.ts

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-import { IndentationText, Project, QuoteKind } from 'ts-morph';
 import { OriginalClassGenerator } from './generators/OriginalClassGenerator';
 import { SendableClassGenerator } from './generators/SendableClassGenerator';
 import { SerializerGenerator } from './generators/SerializerGenerator';
@@ -69,7 +68,7 @@ export class CodeGenerationService {
     }
 
     // 生成原始类结构
-    this.originalClassGenerator.generate(outputSourceFile, originalSourceFile, results, context);
+    this.originalClassGenerator.generate(outputSourceFile, originalSourceFile, results);
 
     for (const content of serializableGeneratorContext) {
       this.serializerGenerator.generateRegistration(outputSourceFile, content);

package/src/core/services/CodeGenerationService/generators/MergedSendableClassGenerator.ts

@@ -89,22 +89,6 @@ export class MergedSendableClassGenerator {
     classDecl.addImplements(['ITSerializable', 'lang.ISendable']);
   }
 
-  private generateGetTypeMethod(classDecl: ClassDeclaration, classAnalysis: ClassAnalysis): void {
-    // 检查是否已存在该方法
-    if (classDecl.getMethod('getType')) {
-      Logger.warn(`类 ${classAnalysis.className} 已存在getType方法，跳过生成`);
-      return;
-    }
-
-    const methodBody = `return ${classAnalysis.className};`;
-
-    classDecl.addMethod({
-      name: 'getType',
-      returnType: 'Function',
-      statements: [methodBody]
-    });
-  }
-
   /**
    * 生成toSendable方法
    * 对于合并版Sendable类，直接返回自身（因为类本身已经是Sendable）
@@ -162,19 +146,6 @@ export class MergedSendableClassGenerator {
 
     const methodBody = 'return TJSON.toString(this, typeKey)';
 
-    // 获取类的泛型参数
-    const genericParameters = classAnalysis.generics.parameters;
-
-    // 构建完整的类型名（包含泛型参数）
-    let fullTypeName: string;
-    if (genericParameters.length > 0) {
-      // 对于泛型类：ClassName<T, U>
-      fullTypeName = `${classDecl.getNameOrThrow()}<${genericParameters.join(', ')}>`;
-    } else {
-      // 对于非泛型类：ClassName
-      fullTypeName = classDecl.getNameOrThrow();
-    }
-
     classDecl.addMethod({
       name: 'toJson',
       returnType: 'string',

package/src/core/services/CodeGenerationService/generators/OriginalClassGenerator.ts

@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-import { ClassDeclaration, Project, SourceFile } from 'ts-morph';
-import { ClassAnalysis, PropertyAnalysis, Logger, PropertyKind, ITaskContext } from '../../..';
+import { ClassDeclaration, SourceFile } from 'ts-morph';
+import { ClassAnalysis, PropertyAnalysis, Logger, PropertyKind } from '../../..';
 import { ImportManager } from '../shared/ImportManager';
 import SerializationPathUtil from '../../../utils/SerializationPathUtil';
 import { ConversionDirection } from '../../../handlers/ITypeHandler';
@@ -32,7 +32,7 @@ export class OriginalClassGenerator {
     this.mergedSendableGenerator = new MergedSendableClassGenerator();
   }
 
-  generate(outputSourceFile: SourceFile, originalSourceFile: SourceFile, results: ClassAnalysis[], context: ITaskContext): void {
+  generate(outputSourceFile: SourceFile, originalSourceFile: SourceFile, results: ClassAnalysis[]): void {
     this.registerImports();
 
     // 1. 获取原始源文件的完整内容并移除原始import语句
@@ -53,7 +53,7 @@ export class OriginalClassGenerator {
         this.mergedSendableGenerator.generate(targetClass, result);
       } else {
         this.addITSerializableInterface(targetClass);
-        this.addStaticSerialName(targetClass, result, context);
+        this.addStaticSerialName(targetClass, result);
         this.generateConvertToSendableMethod(targetClass, result);
         this.generateToJsonMethod(targetClass, result);
       }
@@ -129,14 +129,7 @@ export class OriginalClassGenerator {
     Logger.debug(`为类 ${classDecl.getName()} 添加ITSerializable接口实现`);
   }
 
-  private generateSerialNameConstant(result: ClassAnalysis, context: ITaskContext): string {
-    const relativePath = context.calculateSourceRootToModuleRoot(result.sourceFilePath);
-    const serialName = SerializationPathUtil.join(context.getPackageName(), relativePath, result.className + '.class')
-      .replaceAll(SerializationPathUtil.sep, '/');
-    return result.decorators.serialName || serialName;
-  }
-
-  private addStaticSerialName(classDecl: ClassDeclaration, result: ClassAnalysis, context: ITaskContext): void {
+  private addStaticSerialName(classDecl: ClassDeclaration, result: ClassAnalysis): void {
     // 添加静态属性
     classDecl.addProperty({
       name: 'SERIAL_NAME',
@@ -148,22 +141,6 @@ export class OriginalClassGenerator {
     Logger.debug(`为类 ${classDecl.getName()} 添加静态属性 serialName`);
   }
 
-  private generateGetTypeMethod(classDecl: ClassDeclaration, result: ClassAnalysis): void {
-    // 检查是否已存在该方法
-    if (classDecl.getMethod('getType')) {
-      Logger.warn(`类 ${result.className} 已存在getType方法，跳过生成`);
-      return;
-    }
-
-    const methodBody = `return ${result.className};`;
-
-    classDecl.addMethod({
-      name: 'getType',
-      returnType: 'Function',
-      statements: [methodBody]
-    });
-  }
-
   private generateConvertToSendableMethod(classDecl: ClassDeclaration, result: ClassAnalysis): void {
     // 检查是否已存在该方法
     if (classDecl.getMethod('toSendable')) {
@@ -205,19 +182,6 @@ export class OriginalClassGenerator {
 
     const methodBody = 'return TJSON.toString(this, typeKey)';
 
-    // 获取类的泛型参数
-    const genericParameters = result.generics.parameters;
-
-    // 构建完整的类型名（包含泛型参数）
-    let fullTypeName: string;
-    if (genericParameters.length > 0) {
-      // 对于泛型类：ClassName<T, U>
-      fullTypeName = `${classDecl.getNameOrThrow()}<${genericParameters.join(', ')}>`;
-    } else {
-      // 对于非泛型类：ClassName
-      fullTypeName = classDecl.getNameOrThrow();
-    }
-
     classDecl.addMethod({
       name: 'toJson',
       returnType: 'string',
@@ -233,34 +197,14 @@ export class OriginalClassGenerator {
   private registerImports(): void {
     this.importManager.registerJsonImports(['ITSerializable', 'TJSON']);
 
-    this.importManager.registerCoreImports(['TypeKey', 'Serializable']);
+    this.importManager.registerCoreImports(['TypeKey', 'Serializable', 'Encoder', 'SerialDescriptor']);
   }
 
   // ============= toSendable方法生成 =============
 
   private generateConvertToSendableMethodBody(classAnalysis: ClassAnalysis, returnType: string): string {
-    const constructorProps: PropertyAnalysis[] = [];
-    // 遍历 constructorParams 按顺序处理
-    classAnalysis.constructorParams.forEach((cp) => {
-      // 查找 classAnalysis.properties 中是否存在该属性
-      const matchingProperty = classAnalysis.properties.find((p) => p.name === cp.name);
-
-      // 如果找到匹配的属性，按顺序添加到 constructorProps
-      if (matchingProperty) {
-        constructorProps.push({
-          ...matchingProperty,
-          type: {
-            ...matchingProperty.type,
-            // 使用 constructorParam 中的 isOptional
-            isOptional: cp.isOptional,
-          }
-        });
-      }
-    });
-
-    const assignmentProps = classAnalysis.properties.filter((p) => {
-      return classAnalysis.constructorParams.every((cp) => cp.name !== p.name);
-    });
+    const constructorProps = this.getConstructorProperties(classAnalysis);
+    const assignmentProps = this.getAssignmentProperties(classAnalysis);
     const statements: string[] = [];
 
     // 生成构造函数调用
@@ -283,6 +227,29 @@ export class OriginalClassGenerator {
     return statements.join('\n');
   }
 
+  private getConstructorProperties(classAnalysis: ClassAnalysis): PropertyAnalysis[] {
+    const constructorProps: PropertyAnalysis[] = [];
+    classAnalysis.constructorParams.forEach((cp) => {
+      const matchingProperty = classAnalysis.properties.find((p) => p.name === cp.name);
+      if (matchingProperty) {
+        constructorProps.push({
+          ...matchingProperty,
+          type: {
+            ...matchingProperty.type,
+            isOptional: cp.isOptional,
+          }
+        });
+      }
+    });
+    return constructorProps;
+  }
+
+  private getAssignmentProperties(classAnalysis: ClassAnalysis): PropertyAnalysis[] {
+    return classAnalysis.properties.filter((p) => {
+      return classAnalysis.constructorParams.every((cp) => cp.name !== p.name);
+    });
+  }
+
   private generateConstructorCall(constructorProps: PropertyAnalysis[], returnType: string): string {
     if (constructorProps.length === 0) {
       return `new ${returnType}()`;