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

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

package/src/json-plugin/tasks/BaseTask.ts

@@ -13,11 +13,12 @@
  * limitations under the License.
  */
 
-import { ITask, Logger, ImportRewriteServiceImpl, ConfigManager, CodeGenerationEngine } from '../../core';
+import {
+  ITask, Logger, ImportRewriteServiceImpl, ConfigManager, CodeGenerationEngine, IGenerationResult
+} from '../../core';
 import { BuildProfileUpdaterImpl } from '../../core/import-rewrite/services/BuildProfileUpdater';
 import { ITargetContext } from '../interfaces/ITargetContext';
-import {logger} from 'handlebars';
-import {TaskConstants} from '../constants/TaskConstants';
+import { TaskConstants } from '../constants/TaskConstants';
 import SerializationPathUtil from '../../core/utils/SerializationPathUtil';
 
 export abstract class BaseTask implements ITask {
@@ -39,7 +40,7 @@ export abstract class BaseTask implements ITask {
     return scanFiles;
   }
 
-  protected processWithLogging(scanFiles: string[], context: ITargetContext, taskName: string) {
+  protected processWithLogging(scanFiles: string[], context: ITargetContext, taskName: string): IGenerationResult {
     Logger.debug(`Start executing ${taskName} and process ${scanFiles.length} files`);
 
     this.buildProfileUpdater.updateSourceRoots(context); // 更新builde-profile.json5中的sourceRoot

package/src/json-plugin/tasks/CleanTask.ts

@@ -19,18 +19,18 @@ import { ITargetContext } from '../interfaces/ITargetContext';
 import SerializationPathUtil from '../../core/utils/SerializationPathUtil';
 
 export class CleanTask implements ITask {
-  readonly taskName: string = TaskConstants.CLEAN_TASK
-  readonly dependencies: string[] = [] // CLI任务无依赖
-  readonly postDependencies: string[] = [] // CLI任务无依赖
+  readonly taskName: string = TaskConstants.CLEAN_TASK;
+  readonly dependencies: string[] = []; // CLI任务无依赖
+  readonly postDependencies: string[] = []; // CLI任务无依赖
 
   run(context: ITargetContext): void {
-    Logger.info('Start the code cleaning task')
+    Logger.info('Start the code cleaning task');
 
-    const generatedRootDir = context.getOutputRoot()
+    const generatedRootDir: string = context.getOutputRoot();
 
     if (SerializationPathUtil.exist(generatedRootDir)) {
-      Logger.info(`Clean up the generated directory: ${generatedRootDir}`)
-      SerializationPathUtil.rmSync(generatedRootDir, { recursive: true, force: true })
+      Logger.info(`Clean up the generated directory: ${generatedRootDir}`);
+      SerializationPathUtil.rmSync(generatedRootDir, { recursive: true, force: true });
     }
   }
 }

package/src/json-plugin/tasks/WatchTask.ts

@@ -55,45 +55,47 @@ export class WatchTask extends BaseTask {
   }
 
   private setupWatchEvents(context: ITargetContext): void {
-    if (!this.watcher) return
+    if (!this.watcher) {
+      return;
+    }
 
-    let debounceTimer: NodeJS.Timeout | null = null
+    let debounceTimer: NodeJS.Timeout | null = null;
 
     // 防抖处理，避免频繁触发
-    const debouncedGenerate = (filePath: string) => {
+    const debouncedGenerate: (filePath: string) => void = (filePath: string) => {
       if (debounceTimer) {
-        clearTimeout(debounceTimer)
+        clearTimeout(debounceTimer);
       }
       debounceTimer = setTimeout(() => {
-        this.generateCode(filePath, context)
-      }, 500) // 500ms 防抖
-    }
+        this.generateCode(filePath, context);
+      }, 500); // 500ms 防抖
+    };
 
     this.watcher
       .on('add', (filePath: string) => {
-        Logger.info(`New file detected: ${filePath}`)
-        debouncedGenerate(filePath)
+        Logger.info(`New file detected: ${filePath}`);
+        debouncedGenerate(filePath);
       })
       .on('change', (filePath: string) => {
-        Logger.info(`File change detected: ${filePath}`)
-        debouncedGenerate(filePath)
+        Logger.info(`File change detected: ${filePath}`);
+        debouncedGenerate(filePath);
       })
       .on('unlink', (filePath: string) => {
-        Logger.info(`File deletion detected: ${filePath}`)
-        debouncedGenerate(filePath)
+        Logger.info(`File deletion detected: ${filePath}`);
+        debouncedGenerate(filePath);
       })
       .on('error', (error: unknown) => {
-        Logger.error(`File monitoring error: ${error}`)
+        Logger.error(`File monitoring error: ${error}`);
       })
       .on('ready', () => {
-        Logger.info('The initial file scan is complete. Start listening for file changes...')
-      })
+        Logger.info('The initial file scan is complete. Start listening for file changes...');
+      });
   }
 
   private generateCode(scanFile: string, context: ITargetContext): void {
     // 统一处理：逐文件分析 → 直接生成
-    const processingResult = this.engine.processFileUnified(scanFile, context)
+    const processingResult = this.engine.processFileUnified(scanFile, context);
 
-    Logger.info(`The code generation is complete, and the output path is ${processingResult?.outputPath}`)
+    Logger.info(`The code generation is complete, and the output path is ${processingResult?.outputPath}`);
   }
 }

package/template/SerializerPerformanceTemplate.hbs

@@ -7,13 +7,13 @@ deserialize(decoder: Decoder, plain: ESObject): {{class.className}}{{#if class.g
     const result = new {{class.className}}{{#if class.generics.isGeneric}}<{{genericParametersString class.generics.parameters}}>{{/if}}(
     {{#each (getCtorProperties class.constructorParams properties)}}
       {{#unless analysis.decorators.isTransient}}
-        {{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}decoder.{{serializer.decodeMethod}}(plain[keys[{{getPropertyIndex this ../properties}}]]){{else}}this.{{analysis.name}}Serializer.deserialize(decoder, plain[keys[{{getPropertyIndex this ../properties}}]]){{/if}}{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}}{{#unless @last}},{{/unless}}
+        {{#if analysis.decorators.isPlainValue}}plain[keys[{{getPropertyIndex this ../properties}}]]{{else}}{{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}decoder.{{serializer.decodeMethod}}(plain[keys[{{getPropertyIndex this ../properties}}]]){{else}}this.{{getSerializer analysis}}.deserialize(decoder, plain[keys[{{getPropertyIndex this ../properties}}]]){{/if}}{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}}{{/if}}{{#unless @last}},{{/unless}}
       {{/unless}}
     {{/each}});
   {{else}}
     const result: ESObject = {};
   {{/if}}
-  
+
 
   {{! 可选属性赋值（构造函数外的属性）}}
   {{#each (postConstructorAssignments class.constructorParams properties)}}
@@ -21,12 +21,22 @@ deserialize(decoder: Decoder, plain: ESObject): {{class.className}}{{#if class.g
       const {{analysis.name}}PlainValue: ESObject = plain[keys[{{getPropertyIndex this ../properties}}]];
       {{#if analysis.defaultValue}}
       {{! 有默认值的属性 }}
+      {{#if (eq analysis.visibility "private")}}
+      ObjectUtils.setProp(result, '{{analysis.name}}', {{analysis.name}}PlainValue === undefined ? {{analysis.defaultValue}} :
+        {{#if analysis.decorators.isPlainValue}}plain[keys[{{getPropertyIndex this ../properties}}]]{{else}}{{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}decoder.{{serializer.decodeMethod}}(plain[keys[{{getPropertyIndex this ../properties}}]]){{else}}this.{{getSerializer analysis}}.deserialize(decoder, plain[keys[{{getPropertyIndex this ../properties}}]]){{/if}}{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}}{{/if}});
+      {{else}}
       result.{{analysis.name}} = {{analysis.name}}PlainValue === undefined ? {{analysis.defaultValue}} :
-        {{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}decoder.{{serializer.decodeMethod}}(plain[keys[{{getPropertyIndex this ../properties}}]]){{else}}this.{{analysis.name}}Serializer.deserialize(decoder, plain[keys[{{getPropertyIndex this ../properties}}]]){{/if}}{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}};
+        {{#if analysis.decorators.isPlainValue}}plain[keys[{{getPropertyIndex this ../properties}}]]{{else}}{{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}decoder.{{serializer.decodeMethod}}(plain[keys[{{getPropertyIndex this ../properties}}]]){{else}}this.{{getSerializer analysis}}.deserialize(decoder, plain[keys[{{getPropertyIndex this ../properties}}]]){{/if}}{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}}{{/if}};
+      {{/if}}
       {{else}}
       {{! 无默认值的属性 }}
+      {{#if (eq analysis.visibility "private")}}
+      ObjectUtils.setProp(result, '{{analysis.name}}', {{analysis.name}}PlainValue === undefined ? undefined :
+        {{#if analysis.decorators.isPlainValue}}plain[keys[{{getPropertyIndex this ../properties}}]]{{else}}{{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}decoder.{{serializer.decodeMethod}}(plain[keys[{{getPropertyIndex this ../properties}}]]){{else}}this.{{getSerializer analysis}}.deserialize(decoder, plain[keys[{{getPropertyIndex this ../properties}}]]){{/if}}{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}}{{/if}});
+      {{else}}
       result.{{analysis.name}} = {{analysis.name}}PlainValue === undefined ? undefined :
-        {{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}decoder.{{serializer.decodeMethod}}(plain[keys[{{getPropertyIndex this ../properties}}]]){{else}}this.{{analysis.name}}Serializer.deserialize(decoder, plain[keys[{{getPropertyIndex this ../properties}}]]){{/if}}{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}};
+        {{#if analysis.decorators.isPlainValue}}plain[keys[{{getPropertyIndex this ../properties}}]]{{else}}{{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}decoder.{{serializer.decodeMethod}}(plain[keys[{{getPropertyIndex this ../properties}}]]){{else}}this.{{getSerializer analysis}}.deserialize(decoder, plain[keys[{{getPropertyIndex this ../properties}}]]){{/if}}{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}}{{/if}};
+      {{/if}}
       {{/if}}
     {{/unless}}
   {{/each}}

package/template/SerializerStrictTemplate.hbs

@@ -27,10 +27,14 @@ deserialize(decoder: Decoder, plain: ESObject): {{class.className}}{{#if class.g
       {{#each properties}}
       case {{@index}}:
         {{analysis.name}}Seen = true;
+        {{#if analysis.decorators.isPlainValue}}
+        {{analysis.name}}Value = value;
+        {{else}}
         {{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}
         {{analysis.name}}Value = decoder.{{serializer.decodeMethod}}(value);
         {{else}}
-        {{analysis.name}}Value = this.{{analysis.name}}Serializer.deserialize(decoder, value){{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}};
+        {{analysis.name}}Value = this.{{getSerializer analysis}}.deserialize(decoder, value){{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}};
+        {{/if}}
         {{/if}}
         break;
       {{/each}}
@@ -80,7 +84,11 @@ deserialize(decoder: Decoder, plain: ESObject): {{class.className}}{{#if class.g
   {{#each (postConstructorAssignments class.constructorParams properties)}}
   {{#unless analysis.decorators.isTransient}}
   if ({{analysis.name}}Seen) {
+    {{#if (eq analysis.visibility "private")}}
+    ObjectUtils.setProp(result, '{{analysis.name}}', {{analysis.name}}Value!{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}});
+    {{else}}
     result.{{analysis.name}} = {{analysis.name}}Value!{{#if serializer.needsTypeAssertion}} as {{analysis.type.sourceText}}{{/if}};
+    {{/if}}
   }
   {{/unless}}
   {{/each}}

package/template/SerializerTemplate.hbs

@@ -14,11 +14,15 @@ export class {{class.className}}Serializer<{{genericParametersString class.gener
   {{! 属性序列化器声明 }}
   {{#each properties}}
     {{#unless (eqPrimitiveType analysis.type.kind)}}
-    private readonly {{analysis.name}}Serializer: {{serializer.typeDeclaration}};
+    private get{{toUpperCase analysis.name}}Serializer: () => {{serializer.typeDeclaration}};
     {{/unless}}
   {{/each}}
 
-  readonly serialDescriptor: SerialDescriptor;
+  private getSerialDescriptor: () => SerialDescriptor;
+
+  get serialDescriptor(): SerialDescriptor {
+    return this.getSerialDescriptor();
+  }
 
   constructor(
     {{#each class.generics.parameters}}
@@ -29,39 +33,37 @@ export class {{class.className}}Serializer<{{genericParametersString class.gener
     {{! 初始化属性序列化器 }}
     {{#each properties}}
       {{#unless (eqPrimitiveType analysis.type.kind)}}
-      this.{{analysis.name}}Serializer = {{serializer.instantiationTemplate}};
+      this.get{{toUpperCase analysis.name}}Serializer = () => {
+        const serializer: {{serializer.typeDeclaration}} = {{serializer.instantiationTemplate}};
+        this.get{{toUpperCase analysis.name}}Serializer = () => serializer;
+        return serializer;
+      };
       {{/unless}}
     {{/each}}
 
-    this.serialDescriptor = buildClassSerialDescriptor(
-      {{class.className}}_SERIAL_NAME,
-      builder => {
-        {{#each properties}}
-          {{! 处理数字属性名的特殊情况 }}
-          {{#if (isNumericPropertyName (formatPropertyName analysis))}}
-          builder.element({
-            elementName: '{{formatPropertyName analysis}}',
-            elementDecodingName: this.fixNonNegativeIntegerElementName('{{formatPropertyName analysis}}'),
-            descriptor:
-              {{#if (eqPrimitiveType analysis.type.kind)}}
-                {{serializer.name}}.INSTANCE.serialDescriptor
-              {{else}}
-                this.{{analysis.name}}Serializer.serialDescriptor
-              {{/if}}
-          });
-          {{else}}
-          builder.element({
-            elementName: '{{formatPropertyName analysis}}',
-            descriptor:
-              {{#if (eqPrimitiveType analysis.type.kind)}}
-                {{serializer.name}}.INSTANCE.serialDescriptor
-              {{else}}
-                this.{{analysis.name}}Serializer.serialDescriptor
+    this.getSerialDescriptor = () => {
+      const descriptor: SerialDescriptor = buildClassSerialDescriptor(
+        {{class.className}}_SERIAL_NAME,
+        builder => {
+          {{#each properties}}
+            {{! 处理数字属性名的特殊情况 }}
+            builder.element({
+              elementName: '{{formatPropertyName analysis}}',
+              {{#if (isNumericPropertyName (formatPropertyName analysis))}}
+              elementDecodingName: this.fixNonNegativeIntegerElementName('{{formatPropertyName analysis}}'),
               {{/if}}
-          });
-          {{/if}}
-        {{/each}}
-      });
+              descriptor:
+                {{#if (eqPrimitiveType analysis.type.kind)}}
+                  {{serializer.name}}.INSTANCE.serialDescriptor
+                {{else}}
+                  lazy(() => this.{{getSerializer analysis}}.serialDescriptor)
+                {{/if}}
+            });
+          {{/each}}
+        });
+      this.getSerialDescriptor = () => descriptor;
+      return descriptor;
+    }
   }
 {{else}}
 {{! 非泛型类：单例模式 }}
@@ -78,30 +80,45 @@ export class {{class.className}}Serializer extends Serializer<{{class.className}
 
   {{! 属性序列化器声明 }}
   {{#each properties}}
+    {{#if (eqPrimitiveType analysis.type.kind)}}
     private readonly {{analysis.name}}Serializer: {{serializer.typeDeclaration}} = {{serializer.instantiationTemplate}};
+    {{else}}
+    private get{{toUpperCase analysis.name}}Serializer: () => {{serializer.typeDeclaration}} = () => {
+      const serializer: {{serializer.typeDeclaration}} = {{serializer.instantiationTemplate}};
+      this.get{{toUpperCase analysis.name}}Serializer = () => serializer;
+      return serializer;
+    };
+    {{/if}}
   {{/each}}
 
   {{! 序列描述符构建 }}
-  readonly serialDescriptor: SerialDescriptor = buildClassSerialDescriptor(
+  private getSerialDescriptor: () => SerialDescriptor = () => {
+    const descriptor: SerialDescriptor = buildClassSerialDescriptor(
       {{class.className}}_SERIAL_NAME,
       builder => {
         {{#each properties}}
-          {{! 处理数字属性名的特殊情况 }}
-          {{#if (isNumericPropertyName (formatPropertyName analysis))}}
           builder.element({
             elementName: '{{formatPropertyName analysis}}',
+            {{! 处理数字属性名的特殊情况 }}
+            {{#if (isNumericPropertyName (formatPropertyName analysis))}}
             elementDecodingName: this.fixNonNegativeIntegerElementName('{{formatPropertyName analysis}}'),
+            {{/if}}
+            {{#if (eqPrimitiveType analysis.type.kind)}}
             descriptor: this.{{analysis.name}}Serializer.serialDescriptor
+            {{else}}
+            descriptor: lazy(() => this.{{getSerializer analysis}}.serialDescriptor)
+            {{/if}}
           });
-          {{else}}
-          builder.element({
-            elementName: '{{formatPropertyName analysis}}',
-            descriptor: this.{{analysis.name}}Serializer.serialDescriptor
-          });
-          {{/if}}
         {{/each}}
       }
     )
+    this.getSerialDescriptor = () => descriptor;
+    return descriptor;
+  }
+
+  get serialDescriptor(): SerialDescriptor {
+    return this.getSerialDescriptor();
+  }
 
   private constructor() {
     super();
@@ -121,21 +138,29 @@ export class {{class.className}}Serializer extends Serializer<{{class.className}
     {{/if}}
   }
 
-  private innerSerialize(encoder: Encoder, value: {{#if class.generics.isGeneric}}{{class.className}}<{{genericParametersString class.generics.parameters}}>{{else}}{{class.className}}{{/if}}): ESObject { 
+  private innerSerialize(encoder: Encoder, value: {{#if class.generics.isGeneric}}{{class.className}}<{{genericParametersString class.generics.parameters}}>{{else}}{{class.className}}{{/if}}): ESObject {
     const keys = this.serialDescriptor.elementNames;
     const result = encoder.newObject();
     {{#each properties}}
-      {{! 根据类型选择编码方法 }}
-      {{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}
-      encoder.{{serializer.encodeMethod}}(result, keys[{{@index}}], value.{{analysis.name}});
+    {{! 根据类型选择编码方法 }}
+      {{#if (eq analysis.visibility "private")}}
+        {{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}
+          encoder.{{serializer.encodeMethod}}(result, keys[{{@index}}], ObjectUtils.getProp(value, '{{analysis.name}}'));
+        {{else}}
+          encoder.encodeSerializableElement(result, keys[{{@index}}], this.{{getSerializer analysis}}, ObjectUtils.getProp(value, '{{analysis.name}}'));
+        {{/if}}
       {{else}}
-      encoder.encodeSerializableElement(result, keys[{{@index}}], this.{{analysis.name}}Serializer, value.{{analysis.name}});
+        {{#if (and (eqPrimitiveType analysis.type.kind) (not (hasDecoratorWith analysis.decorators)))}}
+          encoder.{{serializer.encodeMethod}}(result, keys[{{@index}}], value.{{analysis.name}});
+        {{else}}
+          encoder.encodeSerializableElement(result, keys[{{@index}}], this.{{getSerializer analysis}}, value.{{analysis.name}});
+        {{/if}}
       {{/if}}
     {{/each}}
 
     return result;
   }
-  
+
   {{! 动态包含反序列化模板 - 使用从上下文传递的deserializeTemplate参数 }}
   {{> (lookup . "deserializeTemplate")}}
 }