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

package/src/core/logger/Logger.ts

@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { HvigorLogger } from '@ohos/hvigor'
+
+const PREFIX = '[TSerialization]'
+
+/**
+ * TSerialization 日志工具类
+ * 自动添加项目前缀和模块信息，简化日志输出
+ */
+export class Logger {
+  /** 当前模块上下文 */
+  private static currentModule: string = ''
+
+  /**
+   * 设置当前模块上下文
+   * @param moduleName 模块名称
+   */
+  static setModuleContext(moduleName: string): void {
+    this.currentModule = moduleName
+  }
+
+  /**
+   * 清除当前模块上下文
+   */
+  static clearModuleContext(): void {
+    this.currentModule = ''
+  }
+
+  /**
+   * 获取当前模块上下文
+   */
+  static getCurrentModule(): string {
+    return this.currentModule
+  }
+
+  /**
+   * 格式化日志消息
+   * @param msg 原始消息
+   * @returns 格式化后的消息
+   */
+  private static formatMessage(msg: string): string {
+    const modulePrefix = this.currentModule ? `[${this.currentModule}]` : ''
+    return `${PREFIX}${modulePrefix} ${msg}`
+  }
+
+  /**
+   * 输出错误日志
+   * @param msg 错误消息
+   * @param args 额外参数
+   */
+  static error(msg: string, ...args: unknown[]): void {
+    const formattedMsg = this.formatMessage(msg)
+    if (args.length > 0) {
+      HvigorLogger.getLogger().error(formattedMsg, ...args)
+    } else {
+      HvigorLogger.getLogger().error(formattedMsg)
+    }
+  }
+
+  /**
+   * 输出信息日志
+   * @param msg 信息消息
+   * @param args 额外参数
+   */
+  static info(msg: string, ...args: unknown[]): void {
+    const formattedMsg = this.formatMessage(msg)
+    if (args.length > 0) {
+      HvigorLogger.getLogger().info(formattedMsg, ...args)
+    } else {
+      HvigorLogger.getLogger().info(formattedMsg)
+    }
+  }
+
+  /**
+   * 输出警告日志
+   * @param msg 警告消息
+   * @param args 额外参数
+   */
+  static warn(msg: string, ...args: unknown[]): void {
+    const formattedMsg = this.formatMessage(msg)
+    if (args.length > 0) {
+      HvigorLogger.getLogger().warn(formattedMsg, ...args)
+    } else {
+      HvigorLogger.getLogger().warn(formattedMsg)
+    }
+  }
+
+  /**
+   * 输出调试日志
+   * @param msg 调试消息
+   * @param args 额外参数
+   */
+  static debug(msg: string, ...args: unknown[]): void {
+    const formattedMsg = this.formatMessage(msg)
+    if (args.length > 0) {
+      HvigorLogger.getLogger().debug(formattedMsg, ...args)
+    } else {
+      HvigorLogger.getLogger().debug(formattedMsg)
+    }
+  }
+
+  /**
+   * 在指定模块上下文中执行函数，执行完毕后自动清理上下文
+   * @param moduleName 模块名称
+   * @param fn 要执行的函数
+   * @returns 函数执行结果
+   */
+  static withModuleContext<T>(moduleName: string, fn: () => T): T {
+    const previousModule = this.currentModule
+    try {
+      this.setModuleContext(moduleName)
+      return fn()
+    } finally {
+      // 恢复之前的模块上下文
+      this.currentModule = previousModule
+    }
+  }
+
+  /**
+   * 在指定模块上下文中执行异步函数，执行完毕后自动清理上下文
+   * @param moduleName 模块名称
+   * @param fn 要执行的异步函数
+   * @returns Promise
+   */
+  static async withModuleContextAsync<T>(moduleName: string, fn: () => Promise<T>): Promise<T> {
+    const previousModule = this.currentModule
+    try {
+      this.setModuleContext(moduleName)
+      return await fn()
+    } finally {
+      // 恢复之前的模块上下文
+      this.currentModule = previousModule
+    }
+  }
+}

package/src/core/services/CodeAnalysisService.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ClassDeclaration, ModuleKind, Project, ScriptTarget } from 'ts-morph';
+import { ClassAnalysis, DecoratorConstants, Logger } from '..';
+import { ClassAnalyzer } from '../analyzers/ClassAnalyzer';
+import { TsMorphUtil } from '../utils/TsMorphUtil';
+
+export class CodeAnalysisService {
+  constructor() { }
+
+  analyzeFile(filePath: string): ClassAnalysis[] {
+    Logger.debug(`开始分析文件: ${filePath}`);
+
+    const sourceFile = TsMorphUtil.getProject().addSourceFileAtPath(filePath);
+    const classes = sourceFile.getClasses();
+    const results: ClassAnalysis[] = [];
+
+    for (const cls of classes) {
+      const classAnalysis = this.analyzeClass(cls);
+      if (classAnalysis) {
+        results.push(classAnalysis);
+      } else {
+        Logger.debug(`${cls.getName()}无@Serializable装饰器，跳过分析`);
+      }
+    }
+
+    Logger.debug(`文件分析完成: ${filePath}, 发现 ${results.length} 个@Serializable类`);
+
+    return results;
+  }
+
+  private analyzeClass(cls: ClassDeclaration): ClassAnalysis | null {
+    const decorators = cls.getDecorators();
+
+    for (const decorator of decorators) {
+      if (decorator.getName() === DecoratorConstants.SERIALIZABLE) {
+        // 找到@Serializable装饰器，开始分析
+        return ClassAnalyzer.analyzeClass(cls);
+      }
+    }
+
+    // 没有@Serializable装饰器，跳过
+    return null;
+  }
+
+  dispose(): void {
+    // 清理项目资源
+    const sourceFiles = TsMorphUtil.getProject().getSourceFiles();
+    Logger.info(`code analysis Clearing ${sourceFiles.length} source files...`);
+    sourceFiles.forEach((sourceFile) => {
+      TsMorphUtil.getProject().removeSourceFile(sourceFile);
+    });
+  }
+}

package/src/core/services/CodeGenerationEngine.ts

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ClassAnalysis, IGeneratedFile, IGenerationResult, Logger, ITaskContext, GeneratedFileInfo } from '..';
+import { CodeAnalysisService } from './CodeAnalysisService';
+import { CodeGenerationService } from './CodeGenerationService';
+import { SendableMergeabilityRegistry } from '../analyzers/SendableMergeabilityRegistry';
+import { SendableMergeChecker } from '../analyzers/SendableMergeChecker';
+import { CustomTypeAnalyzer } from '../analyzers/CustomTypeAnalyzer';
+
+export class CodeGenerationEngine {
+  private readonly analysisService: CodeAnalysisService
+  private readonly generationService: CodeGenerationService
+
+  // 保存分析结果供导入重写使用
+  private allClassAnalysis: ClassAnalysis[] = []
+
+  constructor() {
+    this.analysisService = new CodeAnalysisService()
+    this.generationService = new CodeGenerationService()
+  }
+
+  /**
+   * @param scanFiles 待处理的源文件路径列表
+   * @param context 任务上下文
+   * @returns 生成结果详情
+   */
+  processFilesUnified(scanFiles: string[], context: ITaskContext): IGenerationResult {
+    if (!scanFiles || scanFiles.length === 0) {
+      Logger.info('没有待处理的源文件')
+      return {
+        generatedFiles: [],
+        skippedFiles: []
+      }
+    }
+
+    const generatedFiles: IGeneratedFile[] = []
+    const skippedFiles: string[] = []
+
+    // 重置分析结果和合并性注册表
+    this.allClassAnalysis = []
+    SendableMergeabilityRegistry.clear()
+
+    Logger.info(`开始处理 ${scanFiles.length} 个源文件`)
+
+    // ========== 阶段1：分析所有文件并检查合并性 ==========
+    Logger.debug(`[阶段1] 开始分析所有文件`)
+    const fileAnalysisMap = new Map<string, ClassAnalysis[]>()
+
+    // 步骤1.1：分析所有文件的基本信息
+    for (const filePath of scanFiles) {
+      const classAnalysis = this.analysisService.analyzeFile(filePath)
+
+      if (classAnalysis.length === 0) {
+        skippedFiles.push(filePath)
+        Logger.debug(`跳过文件（无@Serializable类）: ${filePath}`)
+        continue
+      }
+
+      // 保存分析结果
+      fileAnalysisMap.set(filePath, classAnalysis)
+      this.allClassAnalysis.push(...classAnalysis)
+    }
+
+    Logger.debug(`[阶段1.1] 完成基本分析，共 ${this.allClassAnalysis.length} 个类`)
+
+    // 步骤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)
+      } else {
+        // 未启用 generateSendable 的类，注册为不可合并
+        SendableMergeabilityRegistry.register(analysis.className, false)
+      }
+    }
+
+    // ========== 阶段2：生成所有文件 ==========
+    Logger.debug(`[阶段2] 开始生成所有文件`)
+
+    for (const [filePath, classAnalysis] of fileAnalysisMap.entries()) {
+      const generatedFile = this.generationService.generateForSourceFile(filePath, classAnalysis, context)
+      if (generatedFile) {
+        generatedFiles.push(generatedFile)
+        Logger.debug(`成功处理文件: ${filePath}`)
+      } else {
+        Logger.warn(`文件生成失败: ${filePath}`)
+      }
+    }
+
+    Logger.info(`处理完成，成功 ${generatedFiles.length} 个，跳过 ${skippedFiles.length} 个`)
+
+    return { generatedFiles, skippedFiles }
+  }
+
+  /**
+   * @param filePath 源文件路径
+   * @param context 任务上下文
+   * @returns 生成的文件信息，如果无需生成则返回null
+   */
+  processFileUnified(filePath: string, context: ITaskContext): IGeneratedFile | null {
+    const classAnalysis = this.analysisService.analyzeFile(filePath)
+
+    // 如果没有@Serializable类，跳过生成
+    if (classAnalysis.length === 0) {
+      Logger.debug(`源文件 ${filePath} 无@Serializable类，跳过生成`)
+      return null
+    }
+
+    // 保存分析结果供导入重写使用
+    this.allClassAnalysis.push(...classAnalysis)
+
+    // 生成对应文件
+    return this.generationService.generateForSourceFile(filePath, classAnalysis, context)
+  }
+
+
+  /**
+   * 收集所有生成的文件信息
+   * 供导入重写功能使用
+   * @param context 任务上下文
+   * @returns 生成文件信息列表
+   */
+  collectGeneratedFileInfos(context: ITaskContext): GeneratedFileInfo[] {
+    // 按源文件路径分组收集类名
+    const fileInfoMap = new Map<string, GeneratedFileInfo>();
+
+    for (const analysisResult of this.allClassAnalysis) {
+      const sourceFilePath = analysisResult.sourceFilePath;
+
+      if (!fileInfoMap.has(sourceFilePath)) {
+        // 为新文件创建 GeneratedFileInfo
+        const generatedFilePath = context.mapToOutputPath(sourceFilePath);
+        fileInfoMap.set(sourceFilePath, {
+          sourceFilePath,
+          generatedFilePath,
+          classNames: new Set<string>()
+        });
+      }
+
+      // 添加类名到对应文件的集合中
+      const fileInfo = fileInfoMap.get(sourceFilePath)!;
+      fileInfo.classNames.add(analysisResult.className);
+    }
+
+    return Array.from(fileInfoMap.values());
+  }
+
+  /**
+   * 获取所有分析结果
+   * 供外部使用（如调试）
+   */
+  getAllAnalysisResults(): ClassAnalysis[] {
+    return [...this.allClassAnalysis]
+  }
+
+  /**
+   * 清理资源
+   * 注意：这个方法应该在整个流程（包括导入重写）完成后调用
+   */
+  cleanup(): void {
+    this.analysisService.dispose()
+    this.allClassAnalysis = []
+    CustomTypeAnalyzer.getInstance().clearCache()
+    SendableMergeabilityRegistry.clear()
+  }
+}

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

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * 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';
+import { ImportManager } from './shared/ImportManager';
+import { ClassAnalysis, IGeneratedFile, Logger, ITaskContext, GenerationContext } from '../..';
+import SerializationPathUtil from '../../utils/SerializationPathUtil';
+import { CustomError, ErrorCodes } from '../../utils/CustomError';
+import { TsMorphUtil } from '../../utils/TsMorphUtil';
+
+export class CodeGenerationService {
+  private readonly importManger: ImportManager;
+  private readonly originalClassGenerator: OriginalClassGenerator;
+  private readonly serializerGenerator: SerializerGenerator;
+  private readonly sendableGenerator: SendableClassGenerator;
+
+  constructor() {
+    this.importManger = new ImportManager();
+
+    this.originalClassGenerator = new OriginalClassGenerator(this.importManger);
+    this.serializerGenerator = new SerializerGenerator(this.importManger);
+    this.sendableGenerator = new SendableClassGenerator();
+  }
+
+  generateForSourceFile(sourcePath: string, results: ClassAnalysis[], context: ITaskContext): IGeneratedFile | null {
+    Logger.debug(`开始为 ${sourcePath} 文件生成代码: ${results.length} 个类`);
+    this.importManger.setContext(context);
+    // 1. 生成Sendable文件（sendableModel目录）- 包含Sendable类
+    this.generateSendableModelFiles(results, context);
+    // 2. 生成主文件（model目录）- 包含原始类、序列化器、toSendable方法
+    return this.generateMainModelFile(sourcePath, results, context);
+  }
+
+  private generateMainModelFile(
+    sourceFileAbs: string,
+    results: ClassAnalysis[],
+    context: ITaskContext
+  ): IGeneratedFile | null {
+    const originalSourceFile = TsMorphUtil.getProject().addSourceFileAtPath(sourceFileAbs);
+    // 计算输出路径
+    const outputPath = context.mapToOutputPath(sourceFileAbs);
+    // 确保输出目录存在
+    context.ensureOutputDirectory(outputPath);
+    // 验证输出路径有效性
+    if (!context.isValidOutputPath(outputPath)) {
+      throw new CustomError(`输出路径无效: ${outputPath}`, ErrorCodes.INVALID_OUTPUT_FAIL);
+    }
+    // 创建输出文件
+    const outputSourceFile = TsMorphUtil.getProject().createSourceFile(outputPath, '', { overwrite: true });
+
+    const serializableGeneratorContext: (GenerationContext | string)[] = [];
+    for (const classAnalysis of results) {
+      serializableGeneratorContext.push(this.serializerGenerator.generate(outputSourceFile, classAnalysis, context));
+    }
+
+    // 生成原始类结构
+    this.originalClassGenerator.generate(outputSourceFile, originalSourceFile, results, context);
+
+    for (const content of serializableGeneratorContext) {
+      this.serializerGenerator.generateRegistration(outputSourceFile, content);
+    }
+
+    // 添加导入语句
+    this.importManger.getImportDeclarations().forEach((importDeclaration) => {
+      outputSourceFile.addImportDeclaration({
+        moduleSpecifier: importDeclaration.specifier,
+        namedImports: [...new Set(importDeclaration.names)]
+      });
+    });
+    this.importManger.getDefaultImport().forEach((importDeclaration) => {
+      outputSourceFile.addImportDeclaration({
+        moduleSpecifier: importDeclaration.specifier,
+        defaultImport: importDeclaration.name
+      });
+    });
+    // 格式化代码
+    outputSourceFile.formatText();
+    // 保存文件
+    outputSourceFile.saveSync();
+    // 返回生成结果
+    this.cleanup();
+    return {
+      sourcePath: sourceFileAbs,
+      outputPath,
+      contentLength: outputSourceFile.getFullText().length,
+      serializerCount: results.length,
+      generatedAt: Date.now()
+    };
+  }
+
+  private generateSendableModelFiles(results: ClassAnalysis[], context: ITaskContext): void {
+    for (const classAnalysis of results) {
+      // 跳过可合并的类（它们已经在主文件中生成为Sendable类）
+      if (classAnalysis.canMerge) {
+        Logger.debug(`类 ${classAnalysis.className} 采用合并策略，跳过独立Sendable文件生成`);
+        continue;
+      }
+
+      // 双版本策略：生成独立的Sendable文件
+      if (this.sendableGenerator.canHandle(classAnalysis)) {
+        this.generateSendableFile(classAnalysis, context);
+      }
+    }
+  }
+
+  private generateSendableFile(result: ClassAnalysis, context: ITaskContext): void {
+    Logger.debug(`类 ${result.className} 采用独立Sendable文件生成`);
+    const sendableOutputPath = SerializationPathUtil.mapToSendableOutputPath(result.className, context);
+    context.ensureOutputDirectory(sendableOutputPath);
+    const sendableImportManager = new ImportManager();
+    sendableImportManager.setContext(context);
+    sendableImportManager.registerArkTSImports(['lang']);
+    const sendableSourceFile = TsMorphUtil.getProject().createSourceFile(sendableOutputPath, '', { overwrite: true });
+    this.sendableGenerator.generate(sendableSourceFile, result, sendableImportManager);
+    if (this.sendableGenerator.needsCollectionsImport(result)) {
+      this.importManger.registerArkTSImports(['collections']);
+    }
+    this.importManger.registerCustomTypeImport(sendableOutputPath, `Sendable${result.className}`);
+    sendableImportManager.getImportDeclarations().forEach((importDeclaration) => {
+      sendableSourceFile.addImportDeclaration({
+        moduleSpecifier: importDeclaration.specifier,
+        namedImports: [...new Set(importDeclaration.names)]
+      });
+    });
+    sendableImportManager.getDefaultImport().forEach((importDeclaration) => {
+      sendableSourceFile.addImportDeclaration({
+        moduleSpecifier: importDeclaration.specifier,
+        defaultImport: importDeclaration.name
+      });
+    });
+    sendableSourceFile.formatText();
+    sendableSourceFile.saveSync();
+  }
+
+  // ============= 验证和清理 =============
+
+  private cleanup(): void {
+    // 注意import是共享的，所以每个文件生成结束以后需要清空
+    this.importManger.clear();
+
+    // 清理项目缓存
+    // 注意：不要完全dispose project，因为它可能被重复使用
+  }
+}