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

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,24 +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 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);
-        }
+        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()) {
@@ -271,49 +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 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 ||
-                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,
-            visibility
-        };
     }
     static analyzePropertyType(prop) {
         const name = prop.getName();
@@ -472,33 +513,11 @@ class ClassAnalyzer {
                     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 (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);
-        }
+        this.checkTransientConflicts(prop.getName(), isTransient, isRequired, !!serialName, !!_with, isPlainValue);
+        this.checkPlainValueConflicts(prop.getName(), isPlainValue, !!_with);
         return {
             isRequired,
             isTransient,
@@ -507,5 +526,35 @@ class ClassAnalyzer {
             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;

package/dist/core/analyzers/CustomTypeAnalyzer.js

@@ -80,36 +80,44 @@ class CustomTypeAnalyzer {
         const imports = sourceFile.getImportDeclarations();
         for (const importDecl of imports) {
             const namedImports = importDecl.getNamedImports();
+            const matchedImport = namedImports.find(ni => ni.getName() === targetName);
+            if (!matchedImport) {
+                continue;
+            }
             const specifierValue = importDecl.getModuleSpecifierValue();
-            for (const namedImport of namedImports) {
-                const importName = namedImport.getName();
-                if (importName === targetName) {
-                    const moduleSpecifier = importDecl.getModuleSpecifierValue();
-                    const resolvedPath = this.resolveImportPath(moduleSpecifier, sourceFile);
-                    if (resolvedPath && SerializationPathUtil_1.default.exist(resolvedPath)) {
-                        const externalSourceFile = this.getOrLoadSourceFile(resolvedPath);
-                        if (externalSourceFile) {
-                            const typeDetail = this.searchInSourceFile(targetName, externalSourceFile);
-                            if (typeDetail) {
-                                return {
-                                    typeName: targetName,
-                                    typeKind: typeDetail.kind,
-                                    importPath: specifierValue,
-                                    source: {
-                                        type: 'imported',
-                                        sourceFilePath: externalSourceFile.getFilePath(),
-                                        originalImport: specifierValue
-                                    },
-                                    details: typeDetail
-                                };
-                            }
-                        }
-                    }
-                }
+            const result = this.processImportMatch(importDecl, targetName, sourceFile, specifierValue);
+            if (result) {
+                return result;
             }
         }
         return null;
     }
+    processImportMatch(importDecl, targetName, sourceFile, specifierValue) {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+        const resolvedPath = this.resolveImportPath(moduleSpecifier, sourceFile);
+        if (!resolvedPath || !SerializationPathUtil_1.default.exist(resolvedPath)) {
+            return null;
+        }
+        const externalSourceFile = this.getOrLoadSourceFile(resolvedPath);
+        if (!externalSourceFile) {
+            return null;
+        }
+        const typeDetail = this.searchInSourceFile(targetName, externalSourceFile);
+        if (!typeDetail) {
+            return null;
+        }
+        return {
+            typeName: targetName,
+            typeKind: typeDetail.kind,
+            importPath: specifierValue,
+            source: {
+                type: 'imported',
+                sourceFilePath: externalSourceFile.getFilePath(),
+                originalImport: specifierValue
+            },
+            details: typeDetail
+        };
+    }
     findInCrossModule(targetName, sourceFile) {
         return null;
     }
@@ -146,49 +154,46 @@ class CustomTypeAnalyzer {
         let numericValue = 0;
         const enumMembers = enumDecl.getMembers();
         for (const member of enumMembers) {
-            const memberName = member.getName();
-            let memberValue;
-            let literalValue;
-            const initializer = member.getInitializer();
-            if (initializer) {
-                const initText = initializer.getText().trim();
-                if (initText.startsWith('"') && initText.endsWith('"')) {
-                    memberValue = initText.slice(1, -1);
-                    literalValue = initText;
-                    valueType = 'string';
-                }
-                else if (initText.startsWith("'") && initText.endsWith("'")) {
-                    memberValue = initText.slice(1, -1);
-                    literalValue = `"${memberValue}"`;
-                    valueType = 'string';
-                }
-                else {
-                    const numValue = parseInt(initText, 10);
-                    if (!isNaN(numValue)) {
-                        memberValue = numValue;
-                        literalValue = numValue.toString();
-                        numericValue = numValue + 1;
-                    }
-                    else {
-                        memberValue = initText;
-                        literalValue = `"${initText}"`;
-                        valueType = 'string';
-                    }
-                }
-            }
-            else {
-                memberValue = numericValue;
-                literalValue = numericValue.toString();
-                numericValue++;
+            const { memberValue, literalValue, type, nextValue } = this.parseEnumMember(member, numericValue);
+            numericValue = nextValue;
+            if (type === 'string') {
+                valueType = 'string';
             }
             members.push({
-                name: memberName,
+                name: member.getName(),
                 value: memberValue,
                 literalValue
             });
         }
         return { kind: __1.TypeKind.ENUM, valueType, members };
     }
+    parseEnumMember(member, numericValue) {
+        const initializer = member.getInitializer();
+        if (!initializer) {
+            return {
+                memberValue: numericValue,
+                literalValue: numericValue.toString(),
+                type: 'number',
+                nextValue: numericValue + 1
+            };
+        }
+        const initText = initializer.getText().trim();
+        if (initText.startsWith('"') && initText.endsWith('"')) {
+            return this.createStringEnumResult(initText.slice(1, -1), initText, numericValue);
+        }
+        if (initText.startsWith("'") && initText.endsWith("'")) {
+            const val = initText.slice(1, -1);
+            return this.createStringEnumResult(val, `"${val}"`, numericValue);
+        }
+        const numValue = parseInt(initText, 10);
+        if (!isNaN(numValue)) {
+            return { memberValue: numValue, literalValue: numValue.toString(), type: 'number', nextValue: numValue + 1 };
+        }
+        return this.createStringEnumResult(initText, `"${initText}"`, numericValue);
+    }
+    createStringEnumResult(memberValue, literalValue, numericValue) {
+        return { memberValue, literalValue, type: 'string', nextValue: numericValue };
+    }
     parseClassDetails(classDecl) {
         return {
             kind: __1.TypeKind.CLASS,

package/dist/core/constants/DecoratorConstants.js

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

package/dist/core/import-rewrite/services/BuildProfileUpdater.js

@@ -64,7 +64,7 @@ class BuildProfileUpdaterImpl {
     }
     updateSourceRootsConfig(config) {
         let updated = false;
-        const generatedSourceRoot = "./src/generated";
+        const generatedSourceRoot = './src/generated';
         __1.Logger.info(`target.source.sourceRoots start`);
         if (config.targets && Array.isArray(config.targets)) {
             for (const target of config.targets) {

package/dist/core/import-rewrite/services/ImportRewriteService.js

@@ -25,7 +25,7 @@ class ImportRewriteServiceImpl {
                 this.transformService.rewriteFileImports(filePath, context, generatedFileInfos, options.preserveOriginalImports);
                 successCount++;
             }
-            catch (error) {
+            catch {
                 errorCount++;
             }
         }

package/dist/core/interfaces/index.d.ts

@@ -1,2 +1,2 @@
-export { ITask } from './ITask';
-export { ITaskContext } from './ITaskContext';
+export type { ITask } from './ITask';
+export type { ITaskContext } from './ITaskContext';