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

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

@@ -47,7 +47,7 @@ export class ImportManager {
     }
   }
 
-  registerArkTSImports(names: string[]) {
+  registerArkTSImports(names: string[]): void {
     const arkTSModule = '@kit.ArkTS';
 
     for (const name of names) {
@@ -59,7 +59,7 @@ export class ImportManager {
     // 智能去重：检查是否已有同名类型的更好路径
     if (this.typeToModulePath.has(importedName)) {
       const existingModulePath = this.typeToModulePath.get(importedName)!;
-      
+
       // 如果当前路径是模块化路径，而已存在的是相对路径，则替换
       if (this.isModularPath(modulePath) && this.isRelativePath(existingModulePath)) {
         // 移除旧的相对路径导入
@@ -106,10 +106,10 @@ export class ImportManager {
    * 判断是否为模块化路径（不以 . 或 / 开头，不是 @开头的包名）
    */
   private isModularPath(modulePath: string): boolean {
-    return !modulePath.startsWith('.') && 
-           !modulePath.startsWith('/') && 
-           !modulePath.startsWith('@') &&
-           modulePath.includes('/');
+    return !modulePath.startsWith('.') &&
+      !modulePath.startsWith('/') &&
+      !modulePath.startsWith('@') &&
+      modulePath.includes('/');
   }
 
   private isRelativePath(modulePath: string): boolean {
@@ -120,7 +120,7 @@ export class ImportManager {
     if (this.imports.has(modulePath)) {
       const existingInfo = this.imports.get(modulePath)!;
       const filteredNames = existingInfo.importedNames.filter(name => name !== importedName);
-      
+
       if (filteredNames.length === 0) {
         // 如果该模块没有其他导入，则删除整个模块
         this.imports.delete(modulePath);
@@ -134,7 +134,7 @@ export class ImportManager {
     }
   }
 
-  getImportDeclarations() {
+  getImportDeclarations(): Array<{ specifier: string, names: string[] }> {
     const imports: Array<{ specifier: string, names: string[] }> = [];
     for (const [specifier, infos] of this.imports) {
       imports.push({ specifier: specifier, names: infos.importedNames });

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(', ');
     });
@@ -230,6 +257,12 @@ export class HandlebarsTemplateEngine {
     this.registerHelper('genericParametersESObjString', (parameters: string[]) => {
       return parameters.map(() => 'ESObject').join(', ');
     });
+
+    // 过滤出泛型类型的属性(用于生成静态方法的泛型序列化器参数)
+    this.registerHelper('filterGenericProperties', (properties: PropertyGenerationInfo[]) => {
+      return properties.filter(
+        p => p.analysis.type.kind === PropertyKind.GENERIC && !p.analysis.decorators?.isTransient);
+    });
   }
 
   private registerPropertyAnalysisHelpers(): void {

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

@@ -25,7 +25,8 @@ export class DeepCopyUtil {
       defaultValue: original.defaultValue,
       decorators: this.copyPropertyDecorators(original.decorators),
       isMust: original.isMust,
-      type: this.copyTypeStructure(original.type)
+      type: this.copyTypeStructure(original.type),
+      visibility: original.visibility
     };
   }
 
@@ -37,6 +38,7 @@ export class DeepCopyUtil {
       serialName: original.serialName,
       isRequired: original.isRequired,
       isTransient: original.isTransient,
+      isPlainValue: original.isPlainValue,
       with: original.with
     };
   }
@@ -173,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

@@ -17,6 +17,7 @@ import { TypeNode } from 'ts-morph';
 import { PropertyAnalysis, TypeStructure, PropertyKind, TypeDependency } from '..';
 import { TypeHandlerRegistry } from '../handlers';
 import { DeepCopyUtil } from './DeepCopyUtil';
+import { Logger } from '../logger/Logger';
 
 export class GenericTypeSubstitutionUtil {
   /**
@@ -30,7 +31,9 @@ export class GenericTypeSubstitutionUtil {
 
     const length = Math.min(parentGenericParams.length, childTypeArguments.length);
 
+    Logger.debug(`[GenericMapping] Building mapping with ${length} parameters`);
     for (let i = 0; i < length; i++) {
+      Logger.debug(`[GenericMapping] ${parentGenericParams[i]} -> ${childTypeArguments[i].getText()}`);
       mapping.set(parentGenericParams[i], childTypeArguments[i]);
     }
 
@@ -71,12 +74,20 @@ export class GenericTypeSubstitutionUtil {
     if (typeStructure.kind === PropertyKind.GENERIC) {
       // 对于泛型类型，sourceText 就是泛型参数名（如 "T", "U", "TData"）
       const genericTypeName = typeStructure.sourceText;
+      Logger.debug(`[GenericSubstitution] Processing generic type: ${genericTypeName}`);
+      Logger.debug(`[GenericSubstitution] Available mappings: ${Array.from(mapping.keys()).join(', ')}`);
+      Logger.debug(`[GenericSubstitution] Current class generic params: ${currentClassGenericParams.join(', ')}`);
+
       if (mapping.has(genericTypeName)) {
         const substitutedTypeNode = mapping.get(genericTypeName)!;
+        Logger.debug(`[GenericSubstitution] Found mapping for ${genericTypeName} -> ${substitutedTypeNode.getText()}`);
 
-        return this.constructTypeStructureFromTypeName(substitutedTypeNode, currentClassGenericParams);
+        const result = this.constructTypeStructureFromTypeName(substitutedTypeNode, currentClassGenericParams);
+        Logger.debug(`[GenericSubstitution] Result kind: ${result.kind}, sourceText: ${result.sourceText}`);
+        return result;
       }
       // 如果没有找到对应的映射，保持原样
+      Logger.warn(`[GenericSubstitution] No mapping found for generic type: ${genericTypeName}, keeping as-is`);
       return typeStructure;
     }
 
@@ -95,8 +106,11 @@ export class GenericTypeSubstitutionUtil {
       newStructure.args = newStructure.args.map(
         arg => this.substituteTypeStructure(arg, mapping, currentClassGenericParams)
       );
+      // 重新生成 sourceText 以反映泛型参数替换
+      newStructure.sourceText = this.regenerateSourceText(newStructure);
     }
 
+
     // 重新计算依赖信息
     newStructure.dependencies = this.collectDependenciesFromChildren(newStructure);
 
@@ -110,7 +124,36 @@ export class GenericTypeSubstitutionUtil {
     return TypeHandlerRegistry.getInstance().parseType(typeNode, {
       depth: 0,
       genericParams: currentClassGenericParams // ✅ 传递当前类的泛型参数上下文
-    })
+    });
+  }
+
+  /**
+   * 根据替换后的 args 重新生成 sourceText
+   * 保持原始格式（数组字面量 T[] 或泛型形式 Container<T>）
+   * @param structure 类型结构
+   * @returns 重新生成的 sourceText
+   */
+  private static regenerateSourceText(structure: TypeStructure): string {
+    if (!structure.args || structure.args.length === 0) {
+      return structure.sourceText;
+    }
+
+    // 处理数组字面量形式: T[] -> NewT[]
+    if (structure.sourceText.endsWith('[]')) {
+      return `${structure.args[0].sourceText}[]`;
+    }
+
+    // 处理泛型形式: Container<T> 或 Container<K, V>
+    // 提取容器名称（在 < 之前的部分）
+    const genericStart = structure.sourceText.indexOf('<');
+    if (genericStart > 0) {
+      const containerName = structure.sourceText.substring(0, genericStart);
+      const argsText = structure.args.map(arg => arg.sourceText).join(', ');
+      return `${containerName}<${argsText}>`;
+    }
+
+    // 其他情况保持原样
+    return structure.sourceText;
   }
 
   private static collectDependenciesFromChildren(children: TypeStructure): TypeDependency[] {

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

@@ -13,17 +13,24 @@
  * limitations under the License.
  */
 
-import { Project, ProjectOptions, TypeChecker } from 'ts-morph';
+import { IndentationText, Project, ProjectOptions, QuoteKind, TypeChecker } from 'ts-morph';
 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项目');
       this.project = new Project(
         options || {
+          manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces,
+            quoteKind: QuoteKind.Single
+          },
           compilerOptions: {
             allowNonTsExtensions: true
           }

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));
+    });
   }
 }