@hadss/turbo-trans-json-plugin 1.0.0-rc.1 → 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

@@ -19,7 +19,8 @@ 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/generators/OriginalClassGenerator.ts

@@ -203,28 +203,8 @@ export class OriginalClassGenerator {
   // ============= 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[] = [];
 
     // 生成构造函数调用
@@ -247,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}()`;