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

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.d.ts

@@ -6,12 +6,25 @@ export declare class ClassAnalyzer {
     private static analyzeInheritanceInfo;
     private static analyzeConstructorParameters;
     private static parseSerializableOptions;
+    private static extractOptionsFromObjectLiteral;
+    private static extractSingleOption;
+    private static parseBooleanInitializer;
+    private static parseDeserializationMode;
     private static parseSerialNameOptions;
+    private static extractNameFromProperties;
     private static analyzeOwnProperties;
+    private static checkUnknownType;
     private static classifyProperties;
+    private static buildPropertyClassification;
     private static collectAllAncestorProperties;
+    private static collectAncestorPropertiesRecursively;
+    private static resolveGenericTypeArgs;
     private static extractConstructorParams;
     private static createPropertyAnalysis;
+    private static getTypeNode;
+    private static getPropertyVisibility;
+    private static calculateIsMust;
+    private static validateTransientConstructorParam;
     private static analyzePropertyType;
     private static simplifyImportType;
     private static getTypeFromInitializer;
@@ -20,4 +33,6 @@ export declare class ClassAnalyzer {
     private static hasUndefinedInUnion;
     private static splitUnionType;
     private static analyzePropertyDecorators;
+    private static checkTransientConflicts;
+    private static checkPlainValueConflicts;
 }

package/dist/core/analyzers/ClassAnalyzer.js

@@ -118,41 +118,54 @@ class ClassAnalyzer {
             return undefined;
         }
         const args = decorator.getArguments();
-        let generateSendable;
-        let _with;
-        let deserializationMode;
         const firstArg = args[0];
-        if (!firstArg) {
+        if (!firstArg || firstArg.getKind() !== ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
             return {};
         }
-        if (firstArg.getKind() === ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
-            const properties = firstArg.asKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression).getProperties();
-            for (const prop of properties) {
-                if (prop.getKind() === ts_morph_1.SyntaxKind.PropertyAssignment) {
-                    const propAssignment = prop.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAssignment);
-                    const propertyName = propAssignment.getName();
-                    const initializer = propAssignment.getInitializer();
-                    if (propertyName === 'generateSendable' && initializer) {
-                        if (initializer.getKind() === ts_morph_1.SyntaxKind.TrueKeyword) {
-                            generateSendable = true;
-                        }
-                        else if (initializer.getKind() === ts_morph_1.SyntaxKind.FalseKeyword) {
-                            generateSendable = false;
-                        }
-                    }
-                    else if (propertyName === 'with' && initializer) {
-                        _with = initializer.getText();
-                    }
-                    else if (propertyName === 'deserializationMode' && initializer) {
-                        const modeText = initializer.getText().replace(/['"]/g, '');
-                        if (modeText === Types_1.DeserializationMode.PERFORMANCE || modeText === Types_1.DeserializationMode.STRICT) {
-                            deserializationMode = modeText;
-                        }
-                    }
-                }
+        return this.extractOptionsFromObjectLiteral(firstArg.asKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression));
+    }
+    static extractOptionsFromObjectLiteral(objectLiteral) {
+        const options = {};
+        const properties = objectLiteral.getProperties();
+        for (const prop of properties) {
+            if (prop.getKind() !== ts_morph_1.SyntaxKind.PropertyAssignment) {
+                continue;
+            }
+            const propAssignment = prop.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAssignment);
+            const initializer = propAssignment.getInitializer();
+            if (!initializer) {
+                continue;
             }
+            this.extractSingleOption(options, propAssignment.getName(), initializer);
+        }
+        return options;
+    }
+    static extractSingleOption(options, propertyName, initializer) {
+        if (propertyName === 'generateSendable') {
+            options.generateSendable = this.parseBooleanInitializer(initializer);
+        }
+        else if (propertyName === 'with') {
+            options.with = initializer.getText();
+        }
+        else if (propertyName === 'deserializationMode') {
+            this.parseDeserializationMode(options, initializer);
+        }
+    }
+    static parseBooleanInitializer(initializer) {
+        const kind = initializer.getKind();
+        if (kind === ts_morph_1.SyntaxKind.TrueKeyword) {
+            return true;
+        }
+        if (kind === ts_morph_1.SyntaxKind.FalseKeyword) {
+            return false;
+        }
+        return undefined;
+    }
+    static parseDeserializationMode(options, initializer) {
+        const modeText = initializer.getText().replace(/['"]/g, '');
+        if (modeText === Types_1.DeserializationMode.PERFORMANCE || modeText === Types_1.DeserializationMode.STRICT) {
+            options.deserializationMode = modeText;
         }
-        return { with: _with, generateSendable, deserializationMode };
     }
     static parseSerialNameOptions(decorator) {
         if (!decorator) {
@@ -163,21 +176,26 @@ class ClassAnalyzer {
             return undefined;
         }
         const firstArg = args[0];
-        if (firstArg.getKind() === ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
-            const properties = firstArg.asKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression).getProperties();
-            for (const prop of properties) {
-                if (prop.getKind() === ts_morph_1.SyntaxKind.PropertyAssignment) {
-                    const propAssignment = prop.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAssignment);
-                    const name = propAssignment.getName();
-                    if (name === 'name') {
-                        const initializer = propAssignment.getInitializer();
-                        if (initializer && initializer.getKind() === ts_morph_1.SyntaxKind.StringLiteral) {
-                            const stringLiteral = initializer.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
-                            return stringLiteral.getLiteralValue();
-                        }
-                    }
-                }
+        if (firstArg.getKind() !== ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
+            return undefined;
+        }
+        const properties = firstArg.asKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression).getProperties();
+        return this.extractNameFromProperties(properties);
+    }
+    static extractNameFromProperties(properties) {
+        for (const prop of properties) {
+            if (prop.getKind() !== ts_morph_1.SyntaxKind.PropertyAssignment) {
+                continue;
             }
+            const propAssignment = prop.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAssignment);
+            if (propAssignment.getName() !== 'name') {
+                continue;
+            }
+            const initializer = propAssignment.getInitializer();
+            if (!initializer || initializer.getKind() !== ts_morph_1.SyntaxKind.StringLiteral) {
+                continue;
+            }
+            return initializer.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral).getLiteralValue();
         }
         return undefined;
     }
@@ -186,29 +204,34 @@ class ClassAnalyzer {
         const props = cls.getProperties();
         for (const prop of props) {
             const propertyAnalysis = this.createPropertyAnalysis(prop, constructorParams, genericParameters);
-            if (propertyAnalysis.type.kind === Types_1.PropertyKind.UNKNOWN) {
-                const hasTransient = propertyAnalysis.decorators?.isTransient;
-                const hasCustomSerializer = !!propertyAnalysis.decorators?.with;
-                if (!hasTransient && !hasCustomSerializer) {
-                    if (prop instanceof ts_morph_1.PropertyDeclaration) {
-                        throw new CustomError_1.CustomError(`不支持的类型 '${propertyAnalysis.type.sourceText}' 用于属性 '${propertyAnalysis.name}' (类: ${cls.getName()})。\n` +
-                            `请选择以下任一解决方案：\n` +
-                            `  1. 添加 @Transient() 跳过序列化（属性仍会参与 Sendable 转换和对象拷贝）：\n` +
-                            `     @Transient()\n` +
-                            `     ${propertyAnalysis.name}: ${propertyAnalysis.type.sourceText};\n\n` +
-                            `  2. 添加 @Serializable({with: CustomSerializer}) 指定自定义序列化器：\n` +
-                            `     @Serializable({with: DateSerializer.INSTANCE})\n` +
-                            `     ${propertyAnalysis.name}: ${propertyAnalysis.type.sourceText};`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
-                    }
-                    else {
-                        throw new CustomError_1.CustomError(`不支持的类型 '${propertyAnalysis.type.sourceText}' 用于属性 '${propertyAnalysis.name}' (接口: ${cls.getName()})`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
-                    }
-                }
-            }
+            this.checkUnknownType(cls, prop, propertyAnalysis);
             ownProperties.push(propertyAnalysis);
         }
         return ownProperties;
     }
+    static checkUnknownType(cls, prop, propertyAnalysis) {
+        if (propertyAnalysis.type.kind !== Types_1.PropertyKind.UNKNOWN) {
+            return;
+        }
+        const hasTransient = propertyAnalysis.decorators?.isTransient;
+        const hasCustomSerializer = !!propertyAnalysis.decorators?.with;
+        if (hasTransient || hasCustomSerializer) {
+            return;
+        }
+        if (prop instanceof ts_morph_1.PropertyDeclaration) {
+            throw new CustomError_1.CustomError(`不支持的类型 '${propertyAnalysis.type.sourceText}' 用于属性 '${propertyAnalysis.name}' (类: ${cls.getName()})。\n` +
+                `请选择以下任一解决方案：\n` +
+                `  1. 添加 @Transient() 跳过序列化（属性仍会参与 Sendable 转换和对象拷贝）：\n` +
+                `     @Transient()\n` +
+                `     ${propertyAnalysis.name}: ${propertyAnalysis.type.sourceText};\n\n` +
+                `  2. 添加 @Serializable({with: CustomSerializer}) 指定自定义序列化器：\n` +
+                `     @Serializable({with: DateSerializer.INSTANCE})\n` +
+                `     ${propertyAnalysis.name}: ${propertyAnalysis.type.sourceText};`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+        }
+        else {
+            throw new CustomError_1.CustomError(`不支持的类型 '${propertyAnalysis.type.sourceText}' 用于属性 '${propertyAnalysis.name}' (接口: ${cls.getName()})`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+        }
+    }
     static classifyProperties(ownProperties, inheritance, currentClassGenericParams = []) {
         if (!inheritance.isInherited || !inheritance.baseClassAnalysis) {
             return {
@@ -218,20 +241,14 @@ class ClassAnalyzer {
             };
         }
         const allAncestorProperties = this.collectAllAncestorProperties(inheritance.baseClassAnalysis, inheritance.genericTypeArguments || [], currentClassGenericParams);
+        return this.buildPropertyClassification(ownProperties, allAncestorProperties);
+    }
+    static buildPropertyClassification(ownProperties, allAncestorProperties) {
         const ownPropertyNames = new Set(ownProperties.map((prop) => prop.name));
-        const inheritedProperties = [];
-        for (const ancestorProp of allAncestorProperties) {
-            if (!ownPropertyNames.has(ancestorProp.name)) {
-                inheritedProperties.push(ancestorProp);
-            }
-        }
+        const inheritedProperties = allAncestorProperties.filter((ancestorProp) => !ownPropertyNames.has(ancestorProp.name));
         const overriddenProperties = ownProperties.filter((prop) => allAncestorProperties.some((ancestorProp) => ancestorProp.name === prop.name));
         const properties = [...inheritedProperties, ...ownProperties];
-        return {
-            inheritedProperties,
-            overriddenProperties,
-            properties
-        };
+        return { inheritedProperties, overriddenProperties, properties };
     }
     static collectAllAncestorProperties(classAnalysis, childGenericArguments = [], currentClassGenericParams = []) {
         const allProperties = [];
@@ -239,12 +256,31 @@ class ClassAnalyzer {
         const genericMapping = GenericTypeSubstitutionUtil_1.GenericTypeSubstitutionUtil.buildGenericMapping(parentGenericParams, childGenericArguments);
         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);
-            allProperties.push(...ancestorProperties);
-        }
+        this.collectAncestorPropertiesRecursively(classAnalysis, parentGenericParams, genericMapping, currentClassGenericParams, allProperties);
         return allProperties;
     }
+    static collectAncestorPropertiesRecursively(classAnalysis, parentGenericParams, genericMapping, currentClassGenericParams, allProperties) {
+        if (!classAnalysis.inheritance.isInherited || !classAnalysis.inheritance.baseClassAnalysis) {
+            return;
+        }
+        const parentGenericTypeArgs = classAnalysis.inheritance.genericTypeArguments || [];
+        const resolvedParentGenericArgs = this.resolveGenericTypeArgs(parentGenericTypeArgs, parentGenericParams, genericMapping);
+        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);
+    }
+    static resolveGenericTypeArgs(typeArgs, parentGenericParams, genericMapping) {
+        return typeArgs.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;
+        });
+    }
     static extractConstructorParams(constructor) {
         const parameters = [];
         for (const param of constructor.getParameters()) {
@@ -259,44 +295,66 @@ class ClassAnalyzer {
     }
     static createPropertyAnalysis(prop, constructorParams, genericParameters) {
         const name = prop.getName();
+        const typeNode = this.getTypeNode(prop);
+        const type = handlers_1.TypeHandlerRegistry.getInstance().parseType(typeNode, { genericParams: genericParameters, depth: 0 });
+        type.isOptional = prop.hasQuestionToken();
+        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 visibility = this.getPropertyVisibility(prop);
+        const constructorParam = constructorParams.find((param) => param.name === name);
+        const isMust = this.calculateIsMust(prop, type, constructorParam, decorators, defaultValue);
+        if (decorators?.isTransient && constructorParam) {
+            this.validateTransientConstructorParam(name, constructorParam);
+        }
+        return {
+            name,
+            defaultValue,
+            decorators,
+            type,
+            isMust,
+            visibility
+        };
+    }
+    static getTypeNode(prop) {
         let typeNode = prop.getTypeNode();
         if (!typeNode) {
             typeNode = this.analyzePropertyType(prop);
         }
         if (!typeNode) {
-            throw new CustomError_1.CustomError(`无法分析属性 '${name}' 的类型。请检查属性声明。`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+            throw new CustomError_1.CustomError(`无法分析属性 '${prop.getName()}' 的类型。请检查属性声明。`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
         }
-        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 constructorParam = constructorParams.find((param) => param.name === name);
-        const isParamOptional = constructorParam
-            ? constructorParam.isOptional ||
-                constructorParam.defaultValue !== undefined ||
-                this.hasUndefinedInUnion(constructorParam.type)
-            : true;
-        let isMust;
-        if (constructorParam) {
-            isMust = !isParamOptional;
+        return typeNode;
+    }
+    static getPropertyVisibility(prop) {
+        if (prop.hasModifier(ts_morph_1.SyntaxKind.PrivateKeyword)) {
+            return Types_1.PropertyVisibility.PRIVATE;
         }
-        else {
-            isMust = decorators?.isRequired || !this.isOptional(prop, defaultValue, type);
+        if (prop.hasModifier(ts_morph_1.SyntaxKind.ProtectedKeyword)) {
+            return Types_1.PropertyVisibility.PROTECTED;
         }
-        if (decorators?.isTransient && constructorParam && !isParamOptional) {
+        return Types_1.PropertyVisibility.PUBLIC;
+    }
+    static calculateIsMust(prop, type, constructorParam, decorators, defaultValue) {
+        if (constructorParam) {
+            const isParamOptional = constructorParam.isOptional ||
+                constructorParam.defaultValue !== undefined ||
+                this.hasUndefinedInUnion(constructorParam.type);
+            return !isParamOptional;
+        }
+        return decorators?.isRequired || !this.isOptional(prop, defaultValue, type);
+    }
+    static validateTransientConstructorParam(name, constructorParam) {
+        const isParamOptional = constructorParam.isOptional ||
+            constructorParam.defaultValue !== undefined ||
+            this.hasUndefinedInUnion(constructorParam.type);
+        if (!isParamOptional) {
             throw new CustomError_1.CustomError(`@Transient 属性 '${name}' 的构造函数参数必须是可选的或有默认值。\n` +
                 `因为 @Transient 属性不参与序列化，反序列化时无法从外部数据获取值。\n` +
                 `请修改构造函数参数为以下任一形式：\n` +
                 `  1. 可选参数: constructor(..., ${name}?: ${constructorParam.type})\n` +
                 `  2. 带默认值: constructor(..., ${name}: ${constructorParam.type} = defaultValue)`, CustomError_1.ErrorCodes.TRANSIENT_ATTR_OPTIONAL);
         }
-        return {
-            name,
-            defaultValue,
-            decorators,
-            type,
-            isMust
-        };
     }
     static analyzePropertyType(prop) {
         const name = prop.getName();
@@ -352,7 +410,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 +493,7 @@ class ClassAnalyzer {
         const decorators = prop.getDecorators();
         let isRequired = false;
         let isTransient = false;
+        let isPlainValue = false;
         let serialName;
         let _with;
         decorators.forEach((decorator) => {
@@ -448,33 +508,53 @@ 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;
+                    break;
             }
         });
-        if (isTransient) {
-            const conflictingDecorators = [];
-            if (isRequired) {
-                conflictingDecorators.push('@Required');
-            }
-            if (serialName) {
-                conflictingDecorators.push('@SerialName');
-            }
-            if (_with) {
-                conflictingDecorators.push('@Serializable');
-            }
-            if (conflictingDecorators.length > 0) {
-                throw new CustomError_1.CustomError(`属性 '${prop.getName()}' 的注解冲突：@Transient 与 ${conflictingDecorators.join(', ')} 不能同时使用。\n` +
-                    `@Transient 表示跳过序列化，与其他序列化配置注解互斥。\n` +
-                    `请移除 @Transient 或移除其他序列化注解。`, CustomError_1.ErrorCodes.ANNOTATION_CONFLICT);
-            }
-        }
+        this.checkTransientConflicts(prop.getName(), isTransient, isRequired, !!serialName, !!_with, isPlainValue);
+        this.checkPlainValueConflicts(prop.getName(), isPlainValue, !!_with);
         return {
             isRequired,
             isTransient,
+            isPlainValue,
             serialName,
             with: _with
         };
     }
+    static checkTransientConflicts(propName, isTransient, isRequired, hasSerialName, hasWith, isPlainValue) {
+        if (!isTransient) {
+            return;
+        }
+        const conflictingDecorators = [];
+        if (isRequired) {
+            conflictingDecorators.push('@Required');
+        }
+        if (hasSerialName) {
+            conflictingDecorators.push('@SerialName');
+        }
+        if (hasWith) {
+            conflictingDecorators.push('@Serializable');
+        }
+        if (isPlainValue) {
+            conflictingDecorators.push('@PlainValue');
+        }
+        if (conflictingDecorators.length > 0) {
+            throw new CustomError_1.CustomError(`属性 '${propName}' 的注解冲突：@Transient 与 ${conflictingDecorators.join(', ')} 不能同时使用。\n` +
+                `@Transient 表示跳过序列化，与其他序列化配置注解互斥。\n` +
+                `请移除 @Transient 或移除其他序列化注解。`, CustomError_1.ErrorCodes.ANNOTATION_CONFLICT);
+        }
+    }
+    static checkPlainValueConflicts(propName, isPlainValue, hasWith) {
+        if (isPlainValue && hasWith) {
+            throw new CustomError_1.CustomError(`属性 '${propName}' 的注解冲突：@PlainValue 与 @Serializable(with:) 不能同时使用。\n` +
+                `@PlainValue 跳过类型转换直接使用原始值，与自定义序列化器冲突。\n` +
+                `请移除 @PlainValue 或移除自定义序列化器。`, CustomError_1.ErrorCodes.ANNOTATION_CONFLICT);
+        }
+    }
 }
 exports.ClassAnalyzer = ClassAnalyzer;

package/dist/core/analyzers/CustomTypeAnalyzer.d.ts

@@ -10,9 +10,12 @@ export declare class CustomTypeAnalyzer {
     clearCache(): void;
     private findInCurrentFile;
     private findInImports;
+    private processImportMatch;
     private findInCrossModule;
     private searchInSourceFile;
     private parseEnumDetails;
+    private parseEnumMember;
+    private createStringEnumResult;
     private parseClassDetails;
     private parseInterfaceDetails;
     private parseTypeAliasDetails;