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

package/README.md

@@ -23,7 +23,7 @@ TurboTransJSONPlugin 是一个基于 Hvigor 构建系统的编译时插件，专
 {
   "modelVersion": "6.0.0",
   "dependencies": {
-    "@hadss/turbo-trans-json-plugin": "^1.0.0",
+    "@hadss/turbo-trans-json-plugin": "latest",
     // 使用npm仓版本号
   }
   // ...其余配置

package/dist/core/Types.d.ts

@@ -90,11 +90,18 @@ export interface PropertyAnalysis {
     decorators?: PropertyDecorators;
     isMust: boolean;
     type: TypeStructure;
+    visibility: PropertyVisibility;
+}
+export declare enum PropertyVisibility {
+    PUBLIC = "public",
+    PRIVATE = "private",
+    PROTECTED = "protected"
 }
 export interface PropertyDecorators {
     serialName?: string;
     isRequired: boolean;
     isTransient: boolean;
+    isPlainValue: boolean;
     with?: string;
 }
 export interface TypeStructure {

package/dist/core/Types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeKind = exports.DeserializationMode = exports.PropertyKind = void 0;
+exports.TypeKind = exports.PropertyVisibility = exports.DeserializationMode = exports.PropertyKind = void 0;
 var PropertyKind;
 (function (PropertyKind) {
     PropertyKind["STRING"] = "string";
@@ -38,6 +38,12 @@ var DeserializationMode;
     DeserializationMode["PERFORMANCE"] = "performance";
     DeserializationMode["STRICT"] = "strict";
 })(DeserializationMode || (exports.DeserializationMode = DeserializationMode = {}));
+var PropertyVisibility;
+(function (PropertyVisibility) {
+    PropertyVisibility["PUBLIC"] = "public";
+    PropertyVisibility["PRIVATE"] = "private";
+    PropertyVisibility["PROTECTED"] = "protected";
+})(PropertyVisibility || (exports.PropertyVisibility = PropertyVisibility = {}));
 var TypeKind;
 (function (TypeKind) {
     TypeKind["CLASS"] = "class";

package/dist/core/analyzers/ClassAnalyzer.js

@@ -240,7 +240,19 @@ class ClassAnalyzer {
         const substitutedProperties = classAnalysis.ownProperties.map((property) => GenericTypeSubstitutionUtil_1.GenericTypeSubstitutionUtil.substitutePropertyType(property, genericMapping, currentClassGenericParams));
         allProperties.push(...substitutedProperties);
         if (classAnalysis.inheritance.isInherited && classAnalysis.inheritance.baseClassAnalysis) {
-            const ancestorProperties = this.collectAllAncestorProperties(classAnalysis.inheritance.baseClassAnalysis, classAnalysis.inheritance.genericTypeArguments || [], currentClassGenericParams);
+            const parentGenericTypeArgs = classAnalysis.inheritance.genericTypeArguments || [];
+            const resolvedParentGenericArgs = parentGenericTypeArgs.map(typeArg => {
+                const typeStructure = handlers_1.TypeHandlerRegistry.getInstance().parseType(typeArg, {
+                    depth: 0,
+                    genericParams: parentGenericParams
+                });
+                if (typeStructure.kind === Types_1.PropertyKind.GENERIC && genericMapping.has(typeStructure.sourceText)) {
+                    return genericMapping.get(typeStructure.sourceText);
+                }
+                return typeArg;
+            });
+            Logger_1.Logger.debug(`[CollectAncestors] Resolved parent generic args: ${resolvedParentGenericArgs.map(a => a.getText()).join(', ')}`);
+            const ancestorProperties = this.collectAllAncestorProperties(classAnalysis.inheritance.baseClassAnalysis, resolvedParentGenericArgs, currentClassGenericParams);
             allProperties.push(...ancestorProperties);
         }
         return allProperties;
@@ -266,10 +278,14 @@ class ClassAnalyzer {
         if (!typeNode) {
             throw new CustomError_1.CustomError(`无法分析属性 '${name}' 的类型。请检查属性声明。`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
         }
-        const defaultValue = prop instanceof ts_morph_1.PropertyDeclaration ? this.analyzeDefaultValue(prop, constructorParams) : undefined;
+        const defaultValue = prop instanceof ts_morph_1.PropertyDeclaration ?
+            this.analyzeDefaultValue(prop, constructorParams) : undefined;
         const decorators = prop instanceof ts_morph_1.PropertyDeclaration ? this.analyzePropertyDecorators(prop) : undefined;
         const type = handlers_1.TypeHandlerRegistry.getInstance().parseType(typeNode, { genericParams: genericParameters, depth: 0 });
         type.isOptional = prop.hasQuestionToken();
+        const visibility = prop.hasModifier(ts_morph_1.SyntaxKind.PrivateKeyword) ? Types_1.PropertyVisibility.PRIVATE :
+            prop.hasModifier(ts_morph_1.SyntaxKind.ProtectedKeyword) ? Types_1.PropertyVisibility.PROTECTED :
+                Types_1.PropertyVisibility.PUBLIC;
         const constructorParam = constructorParams.find((param) => param.name === name);
         const isParamOptional = constructorParam
             ? constructorParam.isOptional ||
@@ -295,7 +311,8 @@ class ClassAnalyzer {
             defaultValue,
             decorators,
             type,
-            isMust
+            isMust,
+            visibility
         };
     }
     static analyzePropertyType(prop) {
@@ -352,7 +369,8 @@ class ClassAnalyzer {
             return undefined;
         }
         const exprText = expression.getText();
-        const supportedTypes = ['Map', 'Set', 'WeakMap', 'WeakSet', 'Array', 'Object', 'ArrayList', 'HashMap', 'HashSet', 'LinkedList', 'Decimal', 'List'];
+        const supportedTypes = ['Map', 'Set', 'WeakMap', 'WeakSet', 'Array', 'Object', 'ArrayList', 'HashMap', 'HashSet',
+            'LinkedList', 'Decimal', 'List'];
         if (!supportedTypes.includes(exprText)) {
             return undefined;
         }
@@ -434,6 +452,7 @@ class ClassAnalyzer {
         const decorators = prop.getDecorators();
         let isRequired = false;
         let isTransient = false;
+        let isPlainValue = false;
         let serialName;
         let _with;
         decorators.forEach((decorator) => {
@@ -448,6 +467,9 @@ class ClassAnalyzer {
                 case constants_1.DecoratorConstants.TRANSIENT:
                     isTransient = true;
                     break;
+                case constants_1.DecoratorConstants.PLAIN_VALUE:
+                    isPlainValue = true;
+                    break;
                 case constants_1.DecoratorConstants.SERIALIZABLE:
                     _with = this.parseSerializableOptions(decorator).with;
             }
@@ -463,15 +485,24 @@ class ClassAnalyzer {
             if (_with) {
                 conflictingDecorators.push('@Serializable');
             }
+            if (isPlainValue) {
+                conflictingDecorators.push('@PlainValue');
+            }
             if (conflictingDecorators.length > 0) {
                 throw new CustomError_1.CustomError(`属性 '${prop.getName()}' 的注解冲突：@Transient 与 ${conflictingDecorators.join(', ')} 不能同时使用。\n` +
                     `@Transient 表示跳过序列化，与其他序列化配置注解互斥。\n` +
                     `请移除 @Transient 或移除其他序列化注解。`, CustomError_1.ErrorCodes.ANNOTATION_CONFLICT);
             }
         }
+        if (isPlainValue && _with) {
+            throw new CustomError_1.CustomError(`属性 '${prop.getName()}' 的注解冲突：@PlainValue 与 @Serializable(with:) 不能同时使用。\n` +
+                `@PlainValue 跳过类型转换直接使用原始值，与自定义序列化器冲突。\n` +
+                `请移除 @PlainValue 或移除自定义序列化器。`, CustomError_1.ErrorCodes.ANNOTATION_CONFLICT);
+        }
         return {
             isRequired,
             isTransient,
+            isPlainValue,
             serialName,
             with: _with
         };

package/dist/core/constants/DecoratorConstants.d.ts

@@ -3,5 +3,6 @@ export declare class DecoratorConstants {
     static readonly SERIAL_NAME = "SerialName";
     static readonly REQUIRED = "Required";
     static readonly TRANSIENT = "Transient";
+    static readonly PLAIN_VALUE = "PlainValue";
     static readonly SERIAL_DECORATORS: string[];
 }

package/dist/core/constants/DecoratorConstants.js

@@ -10,4 +10,5 @@ DecoratorConstants.SERIALIZABLE = 'Serializable';
 DecoratorConstants.SERIAL_NAME = 'SerialName';
 DecoratorConstants.REQUIRED = 'Required';
 DecoratorConstants.TRANSIENT = 'Transient';
-DecoratorConstants.SERIAL_DECORATORS = [_a.SERIALIZABLE, _a.SERIAL_NAME, _a.REQUIRED, _a.TRANSIENT];
+DecoratorConstants.PLAIN_VALUE = 'PlainValue';
+DecoratorConstants.SERIAL_DECORATORS = [_a.SERIALIZABLE, _a.SERIAL_NAME, _a.REQUIRED, _a.TRANSIENT, _a.PLAIN_VALUE];

package/dist/core/handlers/CustomClassHandler.js

@@ -166,7 +166,6 @@ class CustomClassHandler extends BaseTypeHandler_1.BaseTypeHandler {
             throw new CustomError_1.CustomError(`Type ${classDetails.classDecl.getName()} is not sendable.
         please add @Sendable or @Serializable({ generateSendable: true })`, CustomError_1.ErrorCodes.NOT_SENDABLE);
         }
-        return structure.sourceText;
     }
     generatePropertyConversion(structure, sourceValue, direction) {
         const classDetails = structure.classDetails;

package/dist/core/services/CodeGenerationService/CodeGenerationService.js

@@ -37,7 +37,7 @@ class CodeGenerationService {
         for (const classAnalysis of results) {
             serializableGeneratorContext.push(this.serializerGenerator.generate(outputSourceFile, classAnalysis, context));
         }
-        this.originalClassGenerator.generate(outputSourceFile, originalSourceFile, results, context);
+        this.originalClassGenerator.generate(outputSourceFile, originalSourceFile, results);
         for (const content of serializableGeneratorContext) {
             this.serializerGenerator.generateRegistration(outputSourceFile, content);
         }

package/dist/core/services/CodeGenerationService/generators/MergedSendableClassGenerator.d.ts

@@ -6,7 +6,6 @@ export declare class MergedSendableClassGenerator {
     private removeTurboTransDecorators;
     private addSendableDecorator;
     private addITSerializableInterface;
-    private generateGetTypeMethod;
     private generateConvertToSendableMethod;
     private generateToOriginMethod;
     private generateToJsonMethod;

package/dist/core/services/CodeGenerationService/generators/MergedSendableClassGenerator.js

@@ -45,18 +45,6 @@ class MergedSendableClassGenerator {
         }
         classDecl.addImplements(['ITSerializable', 'lang.ISendable']);
     }
-    generateGetTypeMethod(classDecl, classAnalysis) {
-        if (classDecl.getMethod('getType')) {
-            __1.Logger.warn(`类 ${classAnalysis.className} 已存在getType方法，跳过生成`);
-            return;
-        }
-        const methodBody = `return ${classAnalysis.className};`;
-        classDecl.addMethod({
-            name: 'getType',
-            returnType: 'Function',
-            statements: [methodBody]
-        });
-    }
     generateConvertToSendableMethod(classDecl, classAnalysis) {
         if (classDecl.getMethod('toSendable')) {
             __1.Logger.warn(`类 ${classAnalysis.className} 已存在toSendable方法，跳过生成`);
@@ -95,14 +83,6 @@ class MergedSendableClassGenerator {
             return;
         }
         const methodBody = 'return TJSON.toString(this, typeKey)';
-        const genericParameters = classAnalysis.generics.parameters;
-        let fullTypeName;
-        if (genericParameters.length > 0) {
-            fullTypeName = `${classDecl.getNameOrThrow()}<${genericParameters.join(', ')}>`;
-        }
-        else {
-            fullTypeName = classDecl.getNameOrThrow();
-        }
         classDecl.addMethod({
             name: 'toJson',
             returnType: 'string',

package/dist/core/services/CodeGenerationService/generators/OriginalClassGenerator.d.ts

@@ -1,16 +1,14 @@
 import { SourceFile } from 'ts-morph';
-import { ClassAnalysis, ITaskContext } from '../../..';
+import { ClassAnalysis } from '../../..';
 import { ImportManager } from '../shared/ImportManager';
 export declare class OriginalClassGenerator {
     private readonly importManager;
     private readonly mergedSendableGenerator;
     constructor(importManager: ImportManager);
-    generate(outputSourceFile: SourceFile, originalSourceFile: SourceFile, results: ClassAnalysis[], context: ITaskContext): void;
+    generate(outputSourceFile: SourceFile, originalSourceFile: SourceFile, results: ClassAnalysis[]): void;
     private copySourceFileContentWithoutImports;
     private addITSerializableInterface;
-    private generateSerialNameConstant;
     private addStaticSerialName;
-    private generateGetTypeMethod;
     private generateConvertToSendableMethod;
     private generateToJsonMethod;
     private registerImports;

package/dist/core/services/CodeGenerationService/generators/OriginalClassGenerator.js

@@ -16,7 +16,7 @@ class OriginalClassGenerator {
         this.importManager = importManager;
         this.mergedSendableGenerator = new MergedSendableClassGenerator_1.MergedSendableClassGenerator();
     }
-    generate(outputSourceFile, originalSourceFile, results, context) {
+    generate(outputSourceFile, originalSourceFile, results) {
         this.registerImports();
         const contentWithoutImports = this.copySourceFileContentWithoutImports(originalSourceFile);
         const tempSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile('temp.ts', contentWithoutImports, {
@@ -31,7 +31,7 @@ class OriginalClassGenerator {
             }
             else {
                 this.addITSerializableInterface(targetClass);
-                this.addStaticSerialName(targetClass, result, context);
+                this.addStaticSerialName(targetClass, result);
                 this.generateConvertToSendableMethod(targetClass, result);
                 this.generateToJsonMethod(targetClass, result);
             }
@@ -85,13 +85,7 @@ class OriginalClassGenerator {
         classDecl.addImplements('ITSerializable');
         __1.Logger.debug(`为类 ${classDecl.getName()} 添加ITSerializable接口实现`);
     }
-    generateSerialNameConstant(result, context) {
-        const relativePath = context.calculateSourceRootToModuleRoot(result.sourceFilePath);
-        const serialName = SerializationPathUtil_1.default.join(context.getPackageName(), relativePath, result.className + '.class')
-            .replaceAll(SerializationPathUtil_1.default.sep, '/');
-        return result.decorators.serialName || serialName;
-    }
-    addStaticSerialName(classDecl, result, context) {
+    addStaticSerialName(classDecl, result) {
         classDecl.addProperty({
             name: 'SERIAL_NAME',
             type: 'string',
@@ -101,18 +95,6 @@ class OriginalClassGenerator {
         });
         __1.Logger.debug(`为类 ${classDecl.getName()} 添加静态属性 serialName`);
     }
-    generateGetTypeMethod(classDecl, result) {
-        if (classDecl.getMethod('getType')) {
-            __1.Logger.warn(`类 ${result.className} 已存在getType方法，跳过生成`);
-            return;
-        }
-        const methodBody = `return ${result.className};`;
-        classDecl.addMethod({
-            name: 'getType',
-            returnType: 'Function',
-            statements: [methodBody]
-        });
-    }
     generateConvertToSendableMethod(classDecl, result) {
         if (classDecl.getMethod('toSendable')) {
             __1.Logger.warn(`类 ${result.className} 已存在toSendable方法，跳过生成`);
@@ -144,14 +126,6 @@ class OriginalClassGenerator {
             return;
         }
         const methodBody = 'return TJSON.toString(this, typeKey)';
-        const genericParameters = result.generics.parameters;
-        let fullTypeName;
-        if (genericParameters.length > 0) {
-            fullTypeName = `${classDecl.getNameOrThrow()}<${genericParameters.join(', ')}>`;
-        }
-        else {
-            fullTypeName = classDecl.getNameOrThrow();
-        }
         classDecl.addMethod({
             name: 'toJson',
             returnType: 'string',
@@ -165,7 +139,7 @@ class OriginalClassGenerator {
     }
     registerImports() {
         this.importManager.registerJsonImports(['ITSerializable', 'TJSON']);
-        this.importManager.registerCoreImports(['TypeKey', 'Serializable']);
+        this.importManager.registerCoreImports(['TypeKey', 'Serializable', 'Encoder', 'SerialDescriptor']);
     }
     generateConvertToSendableMethodBody(classAnalysis, returnType) {
         const constructorProps = [];

package/dist/core/services/CodeGenerationService/generators/SerializerGenerator.js

@@ -20,7 +20,7 @@ class SerializerGenerator {
     generate(sourceFile, result, context) {
         if (result.decorators?.serializable?.with) {
             sourceFile.addStatements(this.generateBuiltinSerializerRegistrationForSupplementary(context, result));
-            return this.generateCustomSerializerRegistration(sourceFile, result);
+            return this.generateCustomSerializerRegistration(result);
         }
         this.registerImports(result);
         const templateContext = {
@@ -49,7 +49,8 @@ class SerializerGenerator {
         const requiredBuiltinSerializers = this.getAllRequiredSerializers(result.properties);
         this.importManager.registerCoreImports([
             'Serializer', 'SerialDescriptor', 'buildClassSerialDescriptor',
-            'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'registerAutoGeneratedSerializerEntryProviderForSupplementary',
+            'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'ObjectUtils',
+            'registerAutoGeneratedSerializerEntryProviderForSupplementary',
             ...requiredBuiltinSerializers
         ]);
         this.registerDecoratorsImports(result);
@@ -120,15 +121,15 @@ class SerializerGenerator {
                     this.importManager.registerCoreImports(['WithEntryContextualSerializer']);
                 }
             }
-            this.execPropertyImports(property.type.dependencies);
+            this.execPropertyImports(property.type.dependencies, !!property.decorators?.with);
         }
     }
-    execPropertyImports(dependencies) {
+    execPropertyImports(dependencies, hasWithParam) {
         dependencies.forEach((dependency) => {
-            this.processDependency(dependency);
+            this.processDependency(dependency, hasWithParam);
         });
     }
-    processDependency(dependency) {
+    processDependency(dependency, hasWithParam) {
         const source = dependency.source;
         if (source.type !== 'imported' && source.type !== 'local') {
             return;
@@ -138,14 +139,14 @@ class SerializerGenerator {
         }
         switch (dependency.typeKind) {
             case __1.TypeKind.CLASS:
-                this.processClassDependency(dependency, source);
+                this.processClassDependency(dependency, source, hasWithParam);
                 break;
             case __1.TypeKind.INTERFACE:
-                this.processInterfaceDependency(dependency);
+                this.processInterfaceDependency(dependency, hasWithParam);
                 break;
         }
     }
-    processClassDependency(dependency, source) {
+    processClassDependency(dependency, source, hasWithParam) {
         const classDetails = dependency.details;
         const tempClassAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeClass(classDetails.classDecl);
         if (!tempClassAnalysis.decorators.serializable) {
@@ -157,6 +158,9 @@ class SerializerGenerator {
             this.handleSerializableClass(dependency, source, serializerName);
         }
         else {
+            if (hasWithParam) {
+                return;
+            }
             this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
         }
     }
@@ -165,7 +169,10 @@ class SerializerGenerator {
             this.importManager.registerCustomTypeImport(source.sourceFilePath, `${dependency.typeName}${serializerName}`);
         }
     }
-    processInterfaceDependency(dependency) {
+    processInterfaceDependency(dependency, hasWithParam) {
+        if (hasWithParam) {
+            return;
+        }
         const interfaceDetails = dependency.details;
         const tempClassAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeInterface(interfaceDetails.interfaceDecl);
         TempSerializerGenerator_1.TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
@@ -173,19 +180,17 @@ class SerializerGenerator {
             __1.StringConstants.SERIALIZER;
         this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
     }
-    generateCustomSerializerRegistration(sourceFile, result) {
+    generateCustomSerializerRegistration(result) {
         this.importManager.registerCoreImports(['registerAutoGeneratedSerializerEntry']);
         const customSerializer = result.decorators.serializable.with;
-        const registrationCode = `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
-        return registrationCode;
+        return `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
     }
     generateBuiltinSerializerRegistrationForSupplementary(context, result) {
         this.importManager.registerCoreImports(['registerAutoGeneratedSerializerEntryProviderForSupplementary']);
         const serialNameConstant = this.generateSerialNameConstant(result, context);
         const customSerializer = result.decorators.serializable.with;
-        const registrationCode = `const ${result.className}_SERIAL_NAME = '${serialNameConstant}';\n
+        return `const ${result.className}_SERIAL_NAME = '${serialNameConstant}';\n
     registerAutoGeneratedSerializerEntryProviderForSupplementary(${result.className}_SERIAL_NAME, () => [${result.className}, ${customSerializer}]);`;
-        return registrationCode;
     }
     getAllRequiredSerializers(properties) {
         const requiredSerializers = new Set();

package/dist/core/template/HandlebarsTemplateEngine.js

@@ -188,6 +188,9 @@ class HandlebarsTemplateEngine {
         this.registerHelper('genericParametersESObjString', (parameters) => {
             return parameters.map(() => 'ESObject').join(', ');
         });
+        this.registerHelper('filterGenericProperties', (properties) => {
+            return properties.filter(p => p.analysis.type.kind === __1.PropertyKind.GENERIC && !p.analysis.decorators?.isTransient);
+        });
     }
     registerPropertyAnalysisHelpers() {
         this.registerHelper('getPropertyIndex', (property, properties) => {

package/dist/core/utils/DeepCopyUtil.js

@@ -8,7 +8,8 @@ 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
         };
     }
     static copyPropertyDecorators(original) {
@@ -19,6 +20,7 @@ class DeepCopyUtil {
             serialName: original.serialName,
             isRequired: original.isRequired,
             isTransient: original.isTransient,
+            isPlainValue: original.isPlainValue,
             with: original.with
         };
     }

package/dist/core/utils/GenericTypeSubstitutionUtil.d.ts

@@ -5,5 +5,6 @@ export declare class GenericTypeSubstitutionUtil {
     static substitutePropertyType(property: PropertyAnalysis, genericMapping: Map<string, TypeNode>, currentClassGenericParams?: string[]): PropertyAnalysis;
     private static substituteTypeStructure;
     private static constructTypeStructureFromTypeName;
+    private static regenerateSourceText;
     private static collectDependenciesFromChildren;
 }

package/dist/core/utils/GenericTypeSubstitutionUtil.js

@@ -4,11 +4,14 @@ exports.GenericTypeSubstitutionUtil = void 0;
 const __1 = require("..");
 const handlers_1 = require("../handlers");
 const DeepCopyUtil_1 = require("./DeepCopyUtil");
+const Logger_1 = require("../logger/Logger");
 class GenericTypeSubstitutionUtil {
     static buildGenericMapping(parentGenericParams, childTypeArguments) {
         const mapping = new Map();
         const length = Math.min(parentGenericParams.length, childTypeArguments.length);
+        Logger_1.Logger.debug(`[GenericMapping] Building mapping with ${length} parameters`);
         for (let i = 0; i < length; i++) {
+            Logger_1.Logger.debug(`[GenericMapping] ${parentGenericParams[i]} -> ${childTypeArguments[i].getText()}`);
             mapping.set(parentGenericParams[i], childTypeArguments[i]);
         }
         return mapping;
@@ -24,10 +27,17 @@ class GenericTypeSubstitutionUtil {
     static substituteTypeStructure(typeStructure, mapping, currentClassGenericParams = []) {
         if (typeStructure.kind === __1.PropertyKind.GENERIC) {
             const genericTypeName = typeStructure.sourceText;
+            Logger_1.Logger.debug(`[GenericSubstitution] Processing generic type: ${genericTypeName}`);
+            Logger_1.Logger.debug(`[GenericSubstitution] Available mappings: ${Array.from(mapping.keys()).join(', ')}`);
+            Logger_1.Logger.debug(`[GenericSubstitution] Current class generic params: ${currentClassGenericParams.join(', ')}`);
             if (mapping.has(genericTypeName)) {
                 const substitutedTypeNode = mapping.get(genericTypeName);
-                return this.constructTypeStructureFromTypeName(substitutedTypeNode, currentClassGenericParams);
+                Logger_1.Logger.debug(`[GenericSubstitution] Found mapping for ${genericTypeName} -> ${substitutedTypeNode.getText()}`);
+                const result = this.constructTypeStructureFromTypeName(substitutedTypeNode, currentClassGenericParams);
+                Logger_1.Logger.debug(`[GenericSubstitution] Result kind: ${result.kind}, sourceText: ${result.sourceText}`);
+                return result;
             }
+            Logger_1.Logger.warn(`[GenericSubstitution] No mapping found for generic type: ${genericTypeName}, keeping as-is`);
             return typeStructure;
         }
         const newStructure = DeepCopyUtil_1.DeepCopyUtil.copyTypeStructure(typeStructure);
@@ -36,6 +46,7 @@ class GenericTypeSubstitutionUtil {
         }
         if (newStructure.args) {
             newStructure.args = newStructure.args.map(arg => this.substituteTypeStructure(arg, mapping, currentClassGenericParams));
+            newStructure.sourceText = this.regenerateSourceText(newStructure);
         }
         newStructure.dependencies = this.collectDependenciesFromChildren(newStructure);
         return newStructure;
@@ -46,6 +57,21 @@ class GenericTypeSubstitutionUtil {
             genericParams: currentClassGenericParams
         });
     }
+    static regenerateSourceText(structure) {
+        if (!structure.args || structure.args.length === 0) {
+            return structure.sourceText;
+        }
+        if (structure.sourceText.endsWith('[]')) {
+            return `${structure.args[0].sourceText}[]`;
+        }
+        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;
+    }
     static collectDependenciesFromChildren(children) {
         const allDependencies = [];
         if (children.unionDetails) {

package/dist/core/utils/TsMorphUtil.js

@@ -9,6 +9,10 @@ class TsMorphUtil {
         if (!this.project) {
             Logger_1.Logger.info('创建ts-morph项目');
             this.project = new ts_morph_1.Project(options || {
+                manipulationSettings: {
+                    indentationText: ts_morph_1.IndentationText.TwoSpaces,
+                    quoteKind: ts_morph_1.QuoteKind.Single
+                },
                 compilerOptions: {
                     allowNonTsExtensions: true
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hadss/turbo-trans-json-plugin",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.1",
   "description": "TurboTransJSON Compiler Plugin for automatic serialization code generation",
   "main": "dist/index.js",
   "scripts": {

package/src/core/Types.ts

@@ -172,6 +172,13 @@ export interface PropertyAnalysis {
   decorators?: PropertyDecorators; // 装饰器信息
   isMust: boolean;                // 精确模式下反序列化时的必要性
   type: TypeStructure;       // 完整的类型分析结果（详细类型信息）
+  visibility: PropertyVisibility; // 属性可见性修饰符
+}
+
+export enum PropertyVisibility {
+  PUBLIC = 'public',
+  PRIVATE = 'private',
+  PROTECTED = 'protected',
 }
 
 /**
@@ -182,6 +189,7 @@ export interface PropertyDecorators {
   serialName?: string;            // @SerialName 自定义序列化名称
   isRequired: boolean;            // @Required 是否必需字段
   isTransient: boolean;           // @Transient 是否跳过序列化
+  isPlainValue: boolean;          // @PlainValue 是否使用原始值（跳过类型转换）
   with?: string;                  // @Serializable 自定义序列化器
 }
 
@@ -195,7 +203,7 @@ export interface TypeStructure {
   kind: PropertyKind;             // 类型种类（STRING, ARRAY, MAP等）
   depth: number;                  // 嵌套深度（用于复杂度控制）
   sourceText: string;             // 原始类型文本（如 "Array<Map<string, User>>"）
-  args: TypeStructure[]           // 泛型参数的类型
+  args: TypeStructure[];           // 泛型参数的类型
   // 类型依赖和特殊信息
   dependencies: TypeDependency[]; // 依赖信息列表（包含完整导入信息）
   enumDetails?: EnumDetails;      // 枚举类型详细信息（仅当kind=ENUM时）