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

package/src/core/template/HandlebarsTemplateEngine.ts

@@ -15,8 +15,16 @@
 
 import * as Handlebars from 'handlebars';
 import {
-  ClassAnalysis, ConstructorParam, DecoratorConstants, DeserializationMode, GenerationContext, InterfaceAnalysis,
-  PropertyAnalysis, PropertyDecorators, PropertyGenerationInfo, PropertyKind
+  ClassAnalysis,
+  ConstructorParam,
+  DecoratorConstants,
+  DeserializationMode,
+  GenerationContext,
+  InterfaceAnalysis,
+  PropertyAnalysis,
+  PropertyDecorators,
+  PropertyGenerationInfo,
+  PropertyKind
 } from '..';
 import SerializationPathUtil from '../utils/SerializationPathUtil';
 import { CustomError, ErrorCodes } from '../utils/CustomError';
@@ -97,14 +105,24 @@ export class HandlebarsTemplateEngine {
     this.registerLogicHelpers();
   }
 
+  private isPrimitiveType(kind: string): boolean {
+    return ['string', 'number', 'boolean', 'bigint', 'undefined', 'null'].includes(kind);
+  }
+
+  private toUpperCase(name: string): string {
+    if (!name) {
+      return '';
+    }
+    return name.charAt(0).toUpperCase() + name.substring(1);
+  }
+
   private registerComparisonHelpers(): void {
     this.registerHelper('eq', (arg1: unknown, arg2: unknown) => {
       return (arg1 === arg2);
     });
 
     this.registerHelper('eqPrimitiveType', (kind: string) => {
-      const primitives = ['string', 'number', 'boolean', 'bigint', 'undefined', 'null'];
-      return primitives.includes(kind);
+      return this.isPrimitiveType(kind);
     });
 
     this.registerHelper('eqEmptyType', (kind: string) => {
@@ -149,9 +167,7 @@ export class HandlebarsTemplateEngine {
 
   private hasNonSerializableClassDecorator(classAnalysis: ClassAnalysis): boolean {
     const classDecorators = classAnalysis.originalClass?.getDecorators() || [];
-    return classDecorators.some(decorator =>
-      decorator.getName() !== 'Serializable'
-    );
+    return classDecorators.some(decorator => decorator.getName() !== 'Serializable');
   }
 
   private hasNonSerializablePropertyDecorators(classAnalysis: ClassAnalysis): boolean {
@@ -163,9 +179,8 @@ export class HandlebarsTemplateEngine {
     for (const prop of props) {
       const decorators = prop.getDecorators();
       if (decorators && Array.isArray(decorators)) {
-        const hasNonSerializableDecorator = decorators.some(decorator =>
-          !DecoratorConstants.SERIAL_DECORATORS.includes(decorator.getName())
-        );
+        const hasNonSerializableDecorator =
+          decorators.some(decorator => !DecoratorConstants.SERIAL_DECORATORS.includes(decorator.getName()));
         if (hasNonSerializableDecorator) {
           return true;
         }
@@ -223,6 +238,18 @@ export class HandlebarsTemplateEngine {
       return str.toLowerCase();
     });
 
+    this.registerHelper('toUpperCase', (str: string) => {
+      return this.toUpperCase(str);
+    });
+
+    this.registerHelper('getSerializer', (analysis: PropertyAnalysis) => {
+      if (this.isPrimitiveType(analysis.type.kind)) {
+        return `${analysis.name}Serializer`;
+      } else {
+        return `get${this.toUpperCase(analysis.name)}Serializer()`;
+      }
+    });
+
     this.registerHelper('genericParametersString', (parameters: string[]) => {
       return parameters.join(', ');
     });
@@ -233,7 +260,8 @@ export class HandlebarsTemplateEngine {
 
     // 过滤出泛型类型的属性(用于生成静态方法的泛型序列化器参数)
     this.registerHelper('filterGenericProperties', (properties: PropertyGenerationInfo[]) => {
-      return properties.filter(p => p.analysis.type.kind === PropertyKind.GENERIC && !p.analysis.decorators?.isTransient);
+      return properties.filter(
+        p => p.analysis.type.kind === PropertyKind.GENERIC && !p.analysis.decorators?.isTransient);
     });
   }
 

package/src/core/utils/ConfigManager.ts

@@ -19,7 +19,8 @@ export class ConfigManager {
   private static instance: ConfigManager;
   private config: TurboTransJsonPluginOptions | null = null;
 
-  private constructor() {}
+  private constructor() {
+  }
 
   public static getInstance(): ConfigManager {
     if (!ConfigManager.instance) {

package/src/core/utils/DeepCopyUtil.ts

@@ -175,7 +175,7 @@ export class DeepCopyUtil {
     if (typeof obj === 'object') {
       const copy: any = {};
       for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
           copy[key] = this.deepCopy((obj as any)[key]);
         }
       }

package/src/core/utils/GenericTypeSubstitutionUtil.ts

@@ -111,13 +111,6 @@ export class GenericTypeSubstitutionUtil {
     }
 
 
-
-
-
-
-
-
-
     // 重新计算依赖信息
     newStructure.dependencies = this.collectDependenciesFromChildren(newStructure);
 
@@ -131,7 +124,7 @@ export class GenericTypeSubstitutionUtil {
     return TypeHandlerRegistry.getInstance().parseType(typeNode, {
       depth: 0,
       genericParams: currentClassGenericParams // ✅ 传递当前类的泛型参数上下文
-    })
+    });
   }
 
   /**

package/src/core/utils/SerializationPathUtil.ts

@@ -14,8 +14,8 @@
  */
 
 import { FileUtil } from '@ohos/hvigor';
-import * as path from "path";
-import * as fs from "fs";
+import * as path from 'path';
+import * as fs from 'fs';
 import { ITaskContext, PathConstants } from '..';
 
 export default class SerializationPathUtil extends FileUtil {
@@ -34,11 +34,11 @@ export default class SerializationPathUtil extends FileUtil {
   }
 
   static isAbsolute(p: string): boolean {
-    return path.isAbsolute(p)
+    return path.isAbsolute(p);
   }
 
   static normalize(p: string): string {
-    return path.normalize(p)
+    return path.normalize(p);
   }
 
   static relative(from: string, to: string): string {
@@ -101,7 +101,8 @@ export default class SerializationPathUtil extends FileUtil {
   static scanEtsFiles(directory: string): string[] {
     const etsFiles: string[] = [];
 
-    const deepScanEtsFiles = (scanPath: string, relativePath: string) => {
+    const deepScanEtsFiles: (scanPath: string, relativePath: string) => void = (scanPath: string,
+      relativePath: string) => {
       let resolvePath = this.pathResolve(scanPath, relativePath);
 
       if (!this.exist(resolvePath)) {
@@ -119,7 +120,7 @@ export default class SerializationPathUtil extends FileUtil {
           etsFiles.push(resolvePath);
         }
       }
-    }
+    };
 
     deepScanEtsFiles(directory, '');
 

package/src/core/utils/TsMorphUtil.ts

@@ -18,7 +18,10 @@ import { Logger } from '../logger/Logger';
 
 export class TsMorphUtil {
   public static project: Project | null = null;
-  private constructor() { }
+
+  private constructor() {
+  }
+
   public static getProject(options?: ProjectOptions): Project {
     if (!this.project) {
       Logger.info('创建ts-morph项目');

package/src/index.ts

@@ -51,7 +51,7 @@ class TurboTransJSONPluginManager {
     return TurboTransJSONPluginManager.instance;
   }
 
-  initialization(node: HvigorNode, options: TurboTransJsonPluginOptions) {
+  initialization(node: HvigorNode, options: TurboTransJsonPluginOptions): void {
     initializeTypeHandlers();
     node.subNodes(subNode => {
       const subNodeName = subNode.getNodeName();
@@ -63,7 +63,7 @@ class TurboTransJSONPluginManager {
     });
   }
 
-  private setupHvigorHooks(hvigor: Hvigor) {
+  private setupHvigorHooks(hvigor: Hvigor): void {
     hvigor.nodesEvaluated(() => {
       this.moduleExecuteControllers.forEach(controller => {
         controller.execute();

package/src/json-plugin/JSONExecuteController.ts

@@ -65,7 +65,7 @@ export class JSONExecuteController {
     // 编译结束后的清理逻辑由clean任务处理
   }
 
-  private initTasks() {
+  private initTasks(): void {
     this.tasks.add(new CodeProcessingTask());
     this.tasks.add(new CleanTask());
     this.tasks.add(new SyncTask());
@@ -82,53 +82,66 @@ export class JSONExecuteController {
     SendableMergeabilityRegistry.clear();
   }
 
-  private registerHvigorTasks(target: Target, context: IModuleContext) {
+  private registerHvigorTasks(target: Target, context: IModuleContext): void {
     const targetContext = new TargetContextImpl(target, context);
     this.tasks.forEach((task) => {
       this.node.registerTask({
         name: task.taskName,
-        run: async () => {
-          try {
-            Logger.info(`${task.taskName} run`);
-            TempSerializerGenerator.getInstance().init(targetContext);
-            const result = task.run(targetContext);
-            // clean任务不需要生成序列化器
-            if (task.taskName !== TaskConstants.CLEAN_TASK) {
-              TempSerializerGenerator.getInstance().saveFile();
-            }
-            if (result instanceof Promise) {
-              await result;
-            }
-            if (task.taskName === TaskConstants.SYNC_TASK || task.taskName === TaskConstants.CODE_PROCESSING_TASK) {
-              this.taskCleanUp();
-            }
-            Logger.info(`${task.taskName} end`);
-          } catch (error) {
-            if (error instanceof CustomError) {
-              Logger.error(`Error: ${error.constructor.name}: ${error.code} ${error.message}\n${error.stack}`);
-            } else {
-              const err = error as Error;
-              Logger.error(`Error: ${err.constructor.name}: ${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);
+  }
+
+  private async runTask(task: ITask, targetContext: TargetContextImpl): Promise<void> {
+    try {
+      Logger.info(`${task.taskName} run`);
+      TempSerializerGenerator.getInstance().init(targetContext);
+      const result = task.run(targetContext);
+      // clean任务不需要生成序列化器
+      if (task.taskName !== TaskConstants.CLEAN_TASK) {
+        TempSerializerGenerator.getInstance().saveFile();
+      }
+      if (result instanceof Promise) {
+        await result;
+      }
+      if (task.taskName === TaskConstants.SYNC_TASK || task.taskName === TaskConstants.CODE_PROCESSING_TASK) {
+        this.taskCleanUp();
+      }
+      Logger.info(`${task.taskName} end`);
+    } catch (error) {
+      this.handleTaskError(error);
+    }
+  }
+
+  private handleTaskError(error: unknown): void {
+    if (error instanceof CustomError) {
+      Logger.error(`Error: ${error.constructor.name}: ${error.code} ${error.message}\n${error.stack}`);
+    } else {
+      const err = error as Error;
+      Logger.error(`Error: ${err.constructor.name}: ${ErrorCodes.INTERNAL_ERROR} ${err.message}\n${err.stack}`);
+    }
+    this.taskCleanUp();
+    throw new Error('serialization execute failed');
+  }
+
+  private registerCleanTaskHook(targetContext: TargetContextImpl): void {
     const cleanTask = this.node.getTaskByName('clean');
-    if (cleanTask) {
-      cleanTask.beforeRun(() => {
-        const generatedRootDir = targetContext.getOutputRoot();
-
-        if (SerializationPathUtil.exist(generatedRootDir)) {
-          Logger.info(`Clean up the generated directory: ${generatedRootDir}`);
-          SerializationPathUtil.rmSync(generatedRootDir, { recursive: true, force: true });
-        }
-      });
+    if (!cleanTask) {
+      return;
+    }
+    cleanTask.beforeRun(() => this.cleanGeneratedDirectory(targetContext));
+  }
+
+  private cleanGeneratedDirectory(targetContext: TargetContextImpl): void {
+    const generatedRootDir = targetContext.getOutputRoot();
+    if (!SerializationPathUtil.exist(generatedRootDir)) {
+      return;
     }
+    Logger.info(`Clean up the generated directory: ${generatedRootDir}`);
+    SerializationPathUtil.rmSync(generatedRootDir, { recursive: true, force: true });
   }
 }

package/src/json-plugin/interfaces/IModuleContext.ts

@@ -13,15 +13,15 @@
  * limitations under the License.
  */
 
-import { HvigorNode } from '@ohos/hvigor'
-import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile'
-import { OhosModuleContext } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context'
+import { HvigorNode } from '@ohos/hvigor';
+import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile';
+import { OhosModuleContext } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
 
 export interface IModuleContext {
-  readonly node: HvigorNode
-  readonly moduleContext: OhosModuleContext
-  readonly buildProfileOpt: ModuleBuildProfile.ModuleBuildOpt
-  readonly scanFiles: string[]
+  readonly node: HvigorNode;
+  readonly moduleContext: OhosModuleContext;
+  readonly buildProfileOpt: ModuleBuildProfile.ModuleBuildOpt;
+  readonly scanFiles: string[];
 
-  initScanFiles(scanDir: string[]): void
+  initScanFiles(scanDir: string[]): void;
 }

package/src/json-plugin/interfaces/ITargetContext.ts

@@ -13,13 +13,13 @@
  * limitations under the License.
  */
 
-import { Target } from '@ohos/hvigor-ohos-plugin'
-import { IModuleContext } from './IModuleContext'
-import { ITaskContext } from '../../core'
+import { Target } from '@ohos/hvigor-ohos-plugin';
+import { IModuleContext } from './IModuleContext';
+import { ITaskContext } from '../../core';
 
 export interface ITargetContext extends ITaskContext {
-  readonly target: Target
-  readonly context: IModuleContext
+  readonly target: Target;
+  readonly context: IModuleContext;
 
-  getCurrentTargetScanFiles(): string[]
+  getCurrentTargetScanFiles(): string[];
 }

package/src/json-plugin/interfaces/impl/ModuleContext.ts

@@ -13,20 +13,20 @@
  * limitations under the License.
  */
 
-import { HvigorNode } from '@ohos/hvigor'
-import { IModuleContext } from '../IModuleContext'
+import { HvigorNode } from '@ohos/hvigor';
+import { IModuleContext } from '../IModuleContext';
 import SerializationPathUtil from '../../../core/utils/SerializationPathUtil';
 import { OhosHapContext } from '@ohos/hvigor-ohos-plugin';
 import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile';
 
 export class ModuleContextImpl implements IModuleContext {
-  readonly node: HvigorNode
-  readonly moduleContext: OhosHapContext
-  readonly scanFiles: string[] = []
+  readonly node: HvigorNode;
+  readonly moduleContext: OhosHapContext;
+  readonly scanFiles: string[] = [];
 
   constructor(node: HvigorNode, moduleContext: OhosHapContext) {
-    this.node = node
-    this.moduleContext = moduleContext
+    this.node = node;
+    this.moduleContext = moduleContext;
   }
 
   /**
@@ -38,8 +38,8 @@ export class ModuleContextImpl implements IModuleContext {
 
   initScanFiles(scanDir: string[]): void {
     scanDir.forEach(dir => {
-      const scanPath = SerializationPathUtil.pathResolve(this.moduleContext.getModulePath(), dir)
-      this.scanFiles.push(...SerializationPathUtil.scanEtsFiles(scanPath))
-    })
+      const scanPath = SerializationPathUtil.pathResolve(this.moduleContext.getModulePath(), dir);
+      this.scanFiles.push(...SerializationPathUtil.scanEtsFiles(scanPath));
+    });
   }
 }

package/src/json-plugin/interfaces/impl/TargetContext.ts

@@ -13,24 +13,24 @@
  * limitations under the License.
  */
 
-import { Target } from '@ohos/hvigor-ohos-plugin'
-import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile'
-import { PathConstants} from '../../../core';
-import { IModuleContext } from '../IModuleContext'
-import { ITargetContext } from '../ITargetContext'
+import { Target } from '@ohos/hvigor-ohos-plugin';
+import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile';
+import { PathConstants } from '../../../core';
+import { IModuleContext } from '../IModuleContext';
+import { ITargetContext } from '../ITargetContext';
 import SerializationPathUtil from '../../../core/utils/SerializationPathUtil';
 import { CustomError, ErrorCodes } from '../../../core/utils/CustomError';
 
 export class TargetContextImpl implements ITargetContext {
-  readonly target: Target
-  readonly context: IModuleContext
+  readonly target: Target;
+  readonly context: IModuleContext;
 
-  private readonly DEFAULT_SOURCE_ROOT = PathConstants.DEFAULT_SOURCE_ROOT
-  private readonly GENERATED_ROOT = PathConstants.GENERATED_ROOT
+  private readonly DEFAULT_SOURCE_ROOT = PathConstants.DEFAULT_SOURCE_ROOT;
+  private readonly GENERATED_ROOT = PathConstants.GENERATED_ROOT;
 
   constructor(target: Target, context: IModuleContext) {
-    this.target = target
-    this.context = context
+    this.target = target;
+    this.context = context;
   }
 
   private get targetOpt(): ModuleBuildProfile.ModuleTargetBuildOpt {
@@ -46,21 +46,21 @@ export class TargetContextImpl implements ITargetContext {
    */
   getCurrentTargetScanFiles(): string[] {
     // 获取当前目标的所有源代码根目录的绝对路径
-    const absoluteSourceRoots = this.getAbsoluteSourceRoots()
+    const absoluteSourceRoots = this.getAbsoluteSourceRoots();
 
     // 过滤扫描文件，只保留在当前目标源代码根目录下的文件
     return this.context.scanFiles.filter(item => {
       // 标准化文件路径格式，确保路径分隔符统一
-      const normalizedFilePath = SerializationPathUtil.normalize(item)
+      const normalizedFilePath = SerializationPathUtil.normalize(item);
 
       // 检查文件路径是否以任一源代码根目录开头
       // 这样可以确保只处理属于当前目标的文件
-      return absoluteSourceRoots.some(sourceRoot => normalizedFilePath.startsWith(sourceRoot))
-    })
+      return absoluteSourceRoots.some(sourceRoot => normalizedFilePath.startsWith(sourceRoot));
+    });
   }
 
   getModuleName(): string {
-    return this.context.moduleContext.getModuleName()
+    return this.context.moduleContext.getModuleName();
   }
 
   getModulePath(): string {
@@ -69,104 +69,108 @@ export class TargetContextImpl implements ITargetContext {
 
   getPackageName(): string {
     // 这里需要获取oh-package.json5中配置的name
-    const packagePath = SerializationPathUtil.pathResolve(this.getModulePath(), 'oh-package.json5')
-    const ohPackageObj = SerializationPathUtil.readJson5(packagePath)
-    return ohPackageObj.name
+    const packagePath = SerializationPathUtil.pathResolve(this.getModulePath(), 'oh-package.json5');
+    const ohPackageObj = SerializationPathUtil.readJson5(packagePath);
+    return ohPackageObj.name;
   }
 
   mapToOutputPath(absSourceFile: string): string {
-    const normalizedFilePath = SerializationPathUtil.normalize(absSourceFile)
-    const moduleRoot = this.context.moduleContext.getModulePath()
-    const srcMainAbs = SerializationPathUtil.normalize(SerializationPathUtil.pathResolve(moduleRoot, this.DEFAULT_SOURCE_ROOT))
-    const generatedRootAbs = this.getOutputRoot()
+    const normalizedFilePath = SerializationPathUtil.normalize(absSourceFile);
+    const moduleRoot = this.context.moduleContext.getModulePath();
+    const srcMainAbs = SerializationPathUtil.normalize(
+      SerializationPathUtil.pathResolve(moduleRoot, this.DEFAULT_SOURCE_ROOT));
+    const generatedRootAbs = this.getOutputRoot();
 
     // 优先基于 src/main 做路径映射
     if (normalizedFilePath.startsWith(srcMainAbs + SerializationPathUtil.sep)) {
-      const relativeToSrcMain = SerializationPathUtil.relative(srcMainAbs, normalizedFilePath)
-      return SerializationPathUtil.join(generatedRootAbs, relativeToSrcMain)
+      const relativeToSrcMain = SerializationPathUtil.relative(srcMainAbs, normalizedFilePath);
+      return SerializationPathUtil.join(generatedRootAbs, relativeToSrcMain);
     }
 
     // 如果文件不在 src/main 下，退化为：找到匹配的任一 sourceRoot，映射到 generated 根下
-    const absoluteSourceRoots = this.getAbsoluteSourceRoots()
-    const matchedRoot = absoluteSourceRoots.find(root => normalizedFilePath.startsWith(root))
+    const absoluteSourceRoots = this.getAbsoluteSourceRoots();
+    const matchedRoot = absoluteSourceRoots.find(root => normalizedFilePath.startsWith(root));
     if (matchedRoot) {
-      const rel = SerializationPathUtil.relative(matchedRoot, normalizedFilePath)
-      return SerializationPathUtil.join(generatedRootAbs, rel)
+      const rel = SerializationPathUtil.relative(matchedRoot, normalizedFilePath);
+      return SerializationPathUtil.join(generatedRootAbs, rel);
     }
 
     // 否则直接放在 generated 根下，保持文件名
-    return SerializationPathUtil.join(generatedRootAbs, SerializationPathUtil.basename(normalizedFilePath))
+    return SerializationPathUtil.join(generatedRootAbs, SerializationPathUtil.basename(normalizedFilePath));
   }
 
   getOutputRoot(): string {
-    const moduleRoot = this.context.moduleContext.getModulePath()
-    const absolutePath = SerializationPathUtil.pathResolve(moduleRoot, this.GENERATED_ROOT)
-    return SerializationPathUtil.normalize(absolutePath)
+    const moduleRoot = this.context.moduleContext.getModulePath();
+    const absolutePath = SerializationPathUtil.pathResolve(moduleRoot, this.GENERATED_ROOT);
+    return SerializationPathUtil.normalize(absolutePath);
   }
 
   getRelativePath(absolutePath: string): string {
-    const outputRoot = this.getOutputRoot()
+    const outputRoot = this.getOutputRoot();
     // 从输出根目录推断项目根目录
     // 假设输出根目录为: <module>/src/generated
-    const moduleRoot = SerializationPathUtil.dirname(SerializationPathUtil.dirname(outputRoot))
+    const moduleRoot = SerializationPathUtil.dirname(SerializationPathUtil.dirname(outputRoot));
 
     try {
-      return SerializationPathUtil.relative(moduleRoot, absolutePath).replaceAll(SerializationPathUtil.sep, '/')
+      return SerializationPathUtil.relative(moduleRoot, absolutePath).replaceAll(SerializationPathUtil.sep, '/');
     } catch (error) {
       // 如果相对路径计算失败，返回原路径
-      return absolutePath
+      return absolutePath;
     }
   }
 
   isValidOutputPath(outputPath: string): boolean {
     try {
-      const outputRoot = this.getOutputRoot()
-      const resolvedOutputPath = SerializationPathUtil.pathResolve(outputPath)
-      const resolvedOutputRoot = SerializationPathUtil.pathResolve(outputRoot)
+      const outputRoot = this.getOutputRoot();
+      const resolvedOutputPath = SerializationPathUtil.pathResolve(outputPath);
+      const resolvedOutputRoot = SerializationPathUtil.pathResolve(outputRoot);
 
       // 检查输出路径是否在输出根目录下
-      return resolvedOutputPath.startsWith(resolvedOutputRoot)
+      return resolvedOutputPath.startsWith(resolvedOutputRoot);
     } catch (error) {
-      return false
+      return false;
     }
   }
 
   ensureOutputDirectory(outputPath: string): void {
-    SerializationPathUtil.ensureDirSync(SerializationPathUtil.dirname(outputPath))
+    SerializationPathUtil.ensureDirSync(SerializationPathUtil.dirname(outputPath));
   }
 
   calculateSourceRootToModuleRoot(absolutePath: string): string {
     // 处理Windows环境路径兼容性
-    const normalizedAbsolutePath = absolutePath.replaceAll(SerializationPathUtil.sep, '/')
+    const normalizedAbsolutePath = absolutePath.replaceAll(SerializationPathUtil.sep, '/');
 
     // 获取所有源根路径并标准化为统一格式（以 / 结尾）
     const sourceRoots = this.getAbsoluteSourceRoots().map(root =>
       root.replaceAll(SerializationPathUtil.sep, '/').replace(/\/$/, '') + '/'
-    )
+    );
 
     // 找到匹配的源根路径
-    const sourceRoot = sourceRoots.find(root => normalizedAbsolutePath.startsWith(root))
+    const sourceRoot = sourceRoots.find(root => normalizedAbsolutePath.startsWith(root));
 
     if (!sourceRoot) {
-      throw new CustomError(`无法找到匹配的源根路径: ${normalizedAbsolutePath}。可用的源根路径: ${sourceRoots.join(', ')}`, ErrorCodes.ROOT_DIRECTROY_NOT_FOUND)
+      throw new CustomError(
+        `无法找到匹配的源根路径: ${normalizedAbsolutePath}。可用的源根路径: ${sourceRoots.join(', ')}`,
+        ErrorCodes.ROOT_DIRECTROY_NOT_FOUND);
     }
 
     // 计算相对路径，移除源根路径的尾部分隔符进行计算
-    const sourceRootForRelative = sourceRoot.replace(/\/$/, '')
-    const absolutePathForRelative = normalizedAbsolutePath.replace(/\/$/, '')
+    const sourceRootForRelative = sourceRoot.replace(/\/$/, '');
+    const absolutePathForRelative = normalizedAbsolutePath.replace(/\/$/, '');
 
-    return SerializationPathUtil.relative(sourceRootForRelative, absolutePathForRelative).replaceAll(SerializationPathUtil.sep, '/')
+    return SerializationPathUtil.relative(sourceRootForRelative, absolutePathForRelative)
+      .replaceAll(SerializationPathUtil.sep, '/');
   }
 
   private get targetSourceRoots(): string[] {
     if (!this.targetOpt.source?.sourceRoots) {
-      return [this.DEFAULT_SOURCE_ROOT]
+      return [this.DEFAULT_SOURCE_ROOT];
     }
     // 检查默认路径是否已包含在sourceRoots中
     if (!this.targetOpt.source.sourceRoots.includes(this.DEFAULT_SOURCE_ROOT)) {
-      return [this.DEFAULT_SOURCE_ROOT, ...this.targetOpt.source.sourceRoots]
+      return [this.DEFAULT_SOURCE_ROOT, ...this.targetOpt.source.sourceRoots];
     }
-    return this.targetOpt.source.sourceRoots
+    return this.targetOpt.source.sourceRoots;
   }
 
   /**
@@ -177,20 +181,21 @@ export class TargetContextImpl implements ITargetContext {
    */
   private getAbsoluteSourceRoots(): string[] {
     // 获取当前模块的根目录路径
-    const moduleRoot = this.context.moduleContext.getModulePath()
+    const moduleRoot = this.context.moduleContext.getModulePath();
 
     // 将每个相对路径源代码根目录转换为绝对路径
     return this.targetSourceRoots.map((sourceRoot: string) => {
       // 将相对路径解析为基于模块根目录的绝对路径
       // path.resolve 会处理相对路径符号（如 ../ ./）
-      const absolutePath = SerializationPathUtil.pathResolve(moduleRoot, sourceRoot)
+      const absolutePath = SerializationPathUtil.pathResolve(moduleRoot, sourceRoot);
 
       // 标准化路径格式，确保路径分隔符统一，处理多余的分隔符
-      const normalizedPath = SerializationPathUtil.normalize(absolutePath)
+      const normalizedPath = SerializationPathUtil.normalize(absolutePath);
 
       // 确保路径以分隔符结尾，避免路径匹配错误
       // 例如：/project/src 不会错误匹配 /project/src2
-      return normalizedPath.endsWith(SerializationPathUtil.sep) ? normalizedPath : normalizedPath + SerializationPathUtil.sep
-    })
+      return normalizedPath.endsWith(SerializationPathUtil.sep) ? normalizedPath :
+        normalizedPath + SerializationPathUtil.sep;
+    });
   }
 }