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

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

@@ -0,0 +1,24 @@
+import { SourceFile } from 'ts-morph';
+import { ClassAnalysis } from '../../..';
+import { ImportManager } from '../shared/ImportManager';
+export declare class SendableClassGenerator {
+    canHandle(result: ClassAnalysis): boolean;
+    generate(sourceFile: SourceFile, result: ClassAnalysis, importManager: ImportManager): void;
+    private getOriginClassDeclaration;
+    private renameSendableClass;
+    private updateInheritanceToSendable;
+    private removeImplements;
+    private removeAllDecorators;
+    private convertPropertyTypesToSendable;
+    private addSendableConstraints;
+    private addToOriginMethod;
+    private generatedToOriginMethodBody;
+    private generatePropertyConversion;
+    private getSendableClassName;
+    private addNecessaryImports;
+    private convertConstructorParameterTypes;
+    private isObjectType;
+    needsCollectionsImport(result: ClassAnalysis): boolean;
+    private convertInitializerToSendable;
+    private convertToSendableType;
+}

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

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendableClassGenerator = void 0;
+const __1 = require("../../..");
+const ClassAnalyzer_1 = require("../../../analyzers/ClassAnalyzer");
+const handlers_1 = require("../../../handlers");
+const ITypeHandler_1 = require("../../../handlers/ITypeHandler");
+const TsMorphUtil_1 = require("../../../utils/TsMorphUtil");
+const SerializationPathUtil_1 = __importDefault(require("../../../utils/SerializationPathUtil"));
+class SendableClassGenerator {
+    canHandle(result) {
+        return !!result.decorators.serializable?.generateSendable;
+    }
+    generate(sourceFile, result, importManager) {
+        const sendableClass = this.getOriginClassDeclaration(result);
+        this.renameSendableClass(sendableClass, result);
+        this.updateInheritanceToSendable(sendableClass, result);
+        this.removeImplements(sendableClass);
+        this.removeAllDecorators(sendableClass);
+        this.convertPropertyTypesToSendable(sendableClass, result);
+        this.convertConstructorParameterTypes(sendableClass, result);
+        this.addSendableConstraints(sendableClass);
+        this.addToOriginMethod(sendableClass, result, importManager);
+        this.addNecessaryImports(result, importManager);
+        sourceFile.addClasses([sendableClass.getStructure()]);
+    }
+    getOriginClassDeclaration(result) {
+        const originalContent = result.originalClass?.getFullText();
+        const copiedSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile('copied-file.ts', originalContent, { overwrite: true });
+        return copiedSourceFile.getClassOrThrow(result.className);
+    }
+    renameSendableClass(classDecl, result) {
+        const sendableClassName = this.getSendableClassName(result);
+        classDecl.set({ name: sendableClassName });
+    }
+    updateInheritanceToSendable(classDecl, result) {
+        if (!result.inheritance.isInherited) {
+            return;
+        }
+        const extendsClause = classDecl.getExtendsOrThrow();
+        const sendableBaseClassName = `Sendable${result.inheritance.baseClassAnalysis?.className}`;
+        extendsClause.setExpression(sendableBaseClassName);
+    }
+    removeImplements(classDecl) {
+        const implementsClauses = classDecl.getImplements();
+        implementsClauses.forEach(imple => {
+            classDecl.removeImplements(imple);
+        });
+    }
+    removeAllDecorators(classDecl) {
+        classDecl.getDecorators().forEach((decorator) => {
+            __1.Logger.warn(`Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`);
+            decorator.remove();
+        });
+        classDecl.getProperties().forEach((property) => {
+            property.getDecorators().forEach((decorator) => {
+                __1.Logger.warn(`Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`);
+                decorator.remove();
+            });
+        });
+        classDecl.getMethods().forEach((method) => {
+            method.getDecorators().forEach((decorator) => {
+                __1.Logger.warn(`Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`);
+                decorator.remove();
+            });
+        });
+    }
+    convertPropertyTypesToSendable(classDecl, result) {
+        const properties = classDecl.getProperties();
+        properties.forEach((property) => {
+            const propertyName = property.getName();
+            __1.Logger.debug(`Converting property ${propertyName} to sendable`);
+            const propertyAnalysis = result.properties.find((p) => p.name === propertyName);
+            if (!propertyAnalysis) {
+                __1.Logger.warn(`未找到属性 ${propertyName} 的分析信息`);
+                return;
+            }
+            __1.Logger.debug(`Found property ${propertyName} analysis info: ${propertyAnalysis.name} ${propertyAnalysis.type.sourceText}`);
+            const sendableType = this.convertToSendableType(propertyAnalysis.type);
+            __1.Logger.debug(`Converted type ${propertyAnalysis.type.sourceText} to ${sendableType}`);
+            if (sendableType !== propertyAnalysis.type.sourceText) {
+                property.setType(sendableType);
+                __1.Logger.debug(`属性 ${propertyName} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
+            }
+            const initializer = property.getInitializer();
+            if (initializer) {
+                const initializerText = initializer.getText();
+                const convertedInitializer = this.convertInitializerToSendable(initializerText);
+                if (convertedInitializer !== initializerText) {
+                    property.setInitializer(convertedInitializer);
+                    __1.Logger.debug(`属性 ${propertyName} 默认值从 ${initializerText} 转换为 ${convertedInitializer}`);
+                }
+            }
+        });
+    }
+    addSendableConstraints(classDecl) {
+        classDecl.addDecorator({ name: 'Sendable' });
+        classDecl.addImplements('lang.ISendable');
+    }
+    addToOriginMethod(classDecl, result, importManger) {
+        let returnType = result.className;
+        if (result.generics.isGeneric) {
+            returnType += `<${result.generics.parameters.join(', ')}>`;
+        }
+        const methodBody = this.generatedToOriginMethodBody(result, returnType);
+        classDecl.addMethod({
+            name: 'toOrigin',
+            returnType,
+            statements: [methodBody]
+        });
+        importManger.registerCustomTypeImport(result.sourceFilePath, result.className);
+    }
+    generatedToOriginMethodBody(result, returnType) {
+        const statements = [];
+        let constructorCall;
+        if (result.constructorParams.length > 0) {
+            const constructorProps = [];
+            result.properties.forEach((p) => {
+                const isConstructorProp = result.constructorParams.find((cp) => cp.name === p.name);
+                if (isConstructorProp) {
+                    constructorProps.push({
+                        ...p,
+                        type: {
+                            ...p.type,
+                            isOptional: isConstructorProp.isOptional
+                        }
+                    });
+                }
+            });
+            const args = constructorProps
+                .map((prop) => {
+                return this.generatePropertyConversion(prop, 'this.');
+            })
+                .join(', ');
+            constructorCall = `new ${returnType}(${args})`;
+        }
+        else {
+            constructorCall = `new ${returnType}()`;
+        }
+        statements.push(`const origin = ${constructorCall};`);
+        const assignmentProps = result.properties.filter((p) => {
+            return result.constructorParams.every((cp) => cp.name !== p.name);
+        });
+        if (assignmentProps.length > 0) {
+            statements.push('');
+            statements.push('// 非构造函数属性赋值');
+            assignmentProps.forEach((prop) => {
+                const assignment = this.generatePropertyConversion(prop, 'this.');
+                statements.push(`origin.${prop.name} = ${assignment};`);
+            });
+        }
+        statements.push('');
+        statements.push('return origin;');
+        return statements.join('\n');
+    }
+    generatePropertyConversion(prop, prefix) {
+        const sourceValue = `${prefix}${prop.name}`;
+        if (prop.type.kind === __1.PropertyKind.UNKNOWN) {
+            return sourceValue;
+        }
+        const registry = handlers_1.TypeHandlerRegistry.getInstance();
+        const handler = registry.getHandlerForKind(prop.type.kind);
+        try {
+            return handler.generatePropertyConversion(prop.type, sourceValue, ITypeHandler_1.ConversionDirection.TO_ORIGIN);
+        }
+        catch (error) {
+            __1.Logger.error(`生成属性转换代码失败: ${error}`);
+            return sourceValue;
+        }
+    }
+    getSendableClassName(result) {
+        return `Sendable${result.className}`;
+    }
+    addNecessaryImports(result, importManager) {
+        result.properties.forEach((property) => {
+            property.type.dependencies.forEach((dependency) => {
+                if (dependency.typeKind === __1.TypeKind.CLASS) {
+                    const classAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeClass(dependency.details.classDecl);
+                    if (classAnalysis.decorators.serializable?.generateSendable) {
+                        importManager.registerCustomImport('./Sendable' + dependency.typeName, 'Sendable' + dependency.typeName);
+                    }
+                    else {
+                        importManager.registerCustomTypeImport(dependency.source.sourceFilePath, dependency.typeName);
+                    }
+                }
+                else {
+                    importManager.registerCustomTypeImport(dependency.source.sourceFilePath, dependency.typeName);
+                }
+            });
+        });
+        const baseClass = result.inheritance.baseClassAnalysis;
+        if (baseClass) {
+            importManager.registerCustomImport('./Sendable' + baseClass.className, 'Sendable' + baseClass.className);
+        }
+        const needsCollections = this.needsCollectionsImport(result);
+        if (needsCollections) {
+            importManager.registerArkTSImports(['collections']);
+        }
+        result.originalClass?.getSourceFile().getImportDeclarations().forEach(importDecl => {
+            const specifier = importDecl.getModuleSpecifierValue();
+            const names = importDecl.getNamedImports().map((names) => names.getName());
+            const defaultImport = importDecl.getDefaultImport();
+            const originalDir = SerializationPathUtil_1.default.dirname(result.sourceFilePath);
+            const importOriginAbs = SerializationPathUtil_1.default.pathResolve(originalDir, specifier);
+            if (SerializationPathUtil_1.default.exist(importOriginAbs + '.ets')) {
+                const importOriginAbsWithExt = importOriginAbs + '.ets';
+                names.forEach((name) => {
+                    importManager.registerCustomTypeImport(importOriginAbsWithExt, name);
+                });
+                if (defaultImport) {
+                    importManager.registerDefaultImport(importOriginAbsWithExt, defaultImport.getText());
+                }
+            }
+            else {
+                names.forEach((name) => {
+                    importManager.registerCustomImport(specifier, name);
+                });
+                if (defaultImport) {
+                    importManager.registerDefaultImport(specifier, defaultImport.getText());
+                }
+            }
+        });
+    }
+    convertConstructorParameterTypes(classDecl, result) {
+        const constructors = classDecl.getConstructors();
+        constructors.forEach((constructor) => {
+            const parameters = constructor.getParameters();
+            parameters.forEach((parameter) => {
+                const paramName = parameter.getName();
+                const propertyAnalysis = result.properties.find((p) => p.name === paramName);
+                if (!propertyAnalysis) {
+                    __1.Logger.warn(`未找到构造函数参数 ${paramName} 的分析信息`);
+                    return;
+                }
+                const sendableType = this.convertToSendableType(propertyAnalysis.type);
+                if (sendableType !== propertyAnalysis.type.sourceText) {
+                    parameter.setType(sendableType);
+                    __1.Logger.debug(`构造函数参数 ${paramName} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
+                }
+            });
+        });
+    }
+    isObjectType(typeName) {
+        const primitiveTypes = ['string', 'number', 'boolean', 'bigint', 'null', 'undefined'];
+        if (primitiveTypes.includes(typeName)) {
+            return false;
+        }
+        if (typeName.startsWith('collections.') ||
+            typeName.startsWith('Array<') ||
+            typeName.startsWith('Map<') ||
+            typeName.startsWith('Set<')) {
+            return false;
+        }
+        if (typeName.startsWith('Sendable')) {
+            return false;
+        }
+        return true;
+    }
+    needsCollectionsImport(result) {
+        return result.properties.some((prop) => {
+            const typeText = this.convertToSendableType(prop.type);
+            return typeText.includes('collections');
+        });
+    }
+    convertInitializerToSendable(initializerText) {
+        let convertedText = initializerText;
+        if (convertedText === '[]') {
+            convertedText = 'new collections.Array()';
+        }
+        else if (convertedText.startsWith('[') && convertedText.endsWith(']')) {
+            const arrayContent = convertedText.slice(1, -1);
+            if (arrayContent.trim()) {
+                convertedText = `new collections.Array(${arrayContent})`;
+            }
+            else {
+                convertedText = 'new collections.Array()';
+            }
+        }
+        convertedText = convertedText.replace(/new\s+Set\s*\(/g, 'new collections.Set(');
+        convertedText = convertedText.replace(/new\s+Map\s*\(/g, 'new collections.Map(');
+        convertedText = convertedText.replace(/new\s+Array\s*\(/g, 'new collections.Array(');
+        const objectConstructorPattern = /new\s+(\w+)\s*\(/g;
+        convertedText = convertedText.replace(objectConstructorPattern, (match, className) => {
+            if (className === 'collections' || match.includes('collections.')) {
+                return match;
+            }
+            if (this.isObjectType(className)) {
+                return match.replace(className, `Sendable${className}`);
+            }
+            return match;
+        });
+        __1.Logger.debug(`初始化器转换: ${initializerText} -> ${convertedText}`);
+        return convertedText;
+    }
+    convertToSendableType(structure) {
+        if (structure.kind === __1.PropertyKind.UNKNOWN) {
+            return structure.sourceText;
+        }
+        const registry = handlers_1.TypeHandlerRegistry.getInstance();
+        const handler = registry.getHandlerForKind(structure.kind);
+        return handler.generateSendableTypeDeclaration(structure);
+    }
+}
+exports.SendableClassGenerator = SendableClassGenerator;

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

@@ -0,0 +1,28 @@
+import { SourceFile } from 'ts-morph';
+import { ImportManager } from '../shared/ImportManager';
+import { ClassAnalysis, GenerationContext, InterfaceAnalysis, ITaskContext } from '../../..';
+export declare class SerializerGenerator {
+    private readonly importManager;
+    private readonly templateEngine;
+    private readonly registry;
+    constructor(importManager: ImportManager);
+    generate(sourceFile: SourceFile, result: ClassAnalysis | InterfaceAnalysis, context: ITaskContext): GenerationContext | string;
+    generateRegistration(sourceFile: SourceFile, content: GenerationContext | string): void;
+    private registerImports;
+    private registerDecoratorsImports;
+    private registerInheritancePropertyImports;
+    private execInheritancePropertyImports;
+    private registerPropertyImports;
+    private execPropertyImports;
+    private processDependency;
+    private processClassDependency;
+    private handleSerializableClass;
+    private processInterfaceDependency;
+    private generateCustomSerializerRegistration;
+    private generateBuiltinSerializerRegistrationForSupplementary;
+    private getAllRequiredSerializers;
+    private analyzeNestedSerializers;
+    private containsGenericType;
+    private propertyAnalysisToPropertyGenerationInfo;
+    private generateSerialNameConstant;
+}

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

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializerGenerator = void 0;
+const __1 = require("../../..");
+const HandlebarsTemplateEngine_1 = require("../../../template/HandlebarsTemplateEngine");
+const ConfigManager_1 = require("../../../utils/ConfigManager");
+const ClassAnalyzer_1 = require("../../../analyzers/ClassAnalyzer");
+const TempSerializerGenerator_1 = require("./TempSerializerGenerator");
+const handlers_1 = require("../../../handlers");
+const SerializationPathUtil_1 = __importDefault(require("../../../utils/SerializationPathUtil"));
+class SerializerGenerator {
+    constructor(importManager) {
+        this.registry = handlers_1.TypeHandlerRegistry.getInstance();
+        this.importManager = importManager;
+        this.templateEngine = new HandlebarsTemplateEngine_1.HandlebarsTemplateEngine();
+    }
+    generate(sourceFile, result, context) {
+        if (result.decorators?.serializable?.with) {
+            sourceFile.addStatements(this.generateBuiltinSerializerRegistrationForSupplementary(context, result));
+            return this.generateCustomSerializerRegistration(sourceFile, result);
+        }
+        this.registerImports(result);
+        const templateContext = {
+            class: result,
+            properties: this.propertyAnalysisToPropertyGenerationInfo(result.properties),
+            serialNameConstant: this.generateSerialNameConstant(result, context)
+        };
+        const templateMode = result.decorators?.serializable?.deserializationMode
+            ? result.decorators.serializable?.deserializationMode
+            : ConfigManager_1.ConfigManager.getInstance().getConfig().deserializationMode;
+        const generatedCode = this.templateEngine.render(templateMode, templateContext);
+        sourceFile.addStatements(generatedCode);
+        return templateContext;
+    }
+    generateRegistration(sourceFile, content) {
+        if (typeof content === 'string') {
+            sourceFile.addStatements(content);
+        }
+        else {
+            const generatedCode = this.templateEngine.renderRegister(content);
+            sourceFile.addStatements(generatedCode);
+        }
+    }
+    registerImports(result) {
+        __1.Logger.debug('SerializerGenerator', 'registerImports', `注册导入: ${result.className}`);
+        const requiredBuiltinSerializers = this.getAllRequiredSerializers(result.properties);
+        this.importManager.registerCoreImports([
+            'Serializer', 'SerialDescriptor', 'buildClassSerialDescriptor',
+            'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'registerAutoGeneratedSerializerEntryProviderForSupplementary',
+            ...requiredBuiltinSerializers
+        ]);
+        this.registerDecoratorsImports(result);
+        const deserializationMode = result.decorators?.serializable?.deserializationMode ||
+            ConfigManager_1.ConfigManager.getInstance().getConfig().deserializationMode;
+        if (deserializationMode === __1.DeserializationMode.STRICT) {
+            this.importManager.registerCoreImports([
+                'SerializationError', 'SerializationErrorCodes',
+                'TypeUtils', 'DecodedElementIndex', 'TurboTransLogger'
+            ]);
+        }
+        if (result.generics.isGeneric) {
+            this.importManager.registerCoreImports(['BaseSerializerFactory']);
+        }
+        this.registerPropertyImports(result);
+        this.registerInheritancePropertyImports(result);
+    }
+    registerDecoratorsImports(result) {
+        result.ownProperties.forEach(property => {
+            if (property.decorators?.serialName) {
+                this.importManager.registerCoreImports(['SerialName']);
+            }
+            if (property.decorators?.isRequired) {
+                this.importManager.registerCoreImports(['Required']);
+            }
+            if (property.decorators?.isTransient) {
+                this.importManager.registerCoreImports(['Transient']);
+            }
+        });
+    }
+    registerInheritancePropertyImports(result) {
+        const baseClass = result.inheritance.baseClassAnalysis;
+        if (baseClass && baseClass.sourceFilePath !== result.sourceFilePath) {
+            this.importManager.registerCustomTypeImport(baseClass.sourceFilePath, baseClass.className);
+            baseClass.ownProperties.forEach(property => {
+                this.execInheritancePropertyImports(property.type.dependencies);
+            });
+        }
+    }
+    execInheritancePropertyImports(dependencies) {
+        dependencies.forEach((dependency) => {
+            const source = dependency.source;
+            if (source.type === 'local') {
+                this.importManager.registerCustomTypeImport(source.sourceFilePath, dependency.typeName);
+                const classDetails = dependency.details;
+                const tempClassAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeClass(classDetails.classDecl);
+                if (!tempClassAnalysis.decorators.serializable) {
+                    TempSerializerGenerator_1.TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
+                }
+                const serializerName = classDetails.isGeneric ? __1.StringConstants.SERIALIZER_FACTORY :
+                    __1.StringConstants.SERIALIZER;
+                if (tempClassAnalysis.decorators.serializable) {
+                    this.importManager.registerCustomTypeImport(source.sourceFilePath, `${dependency.typeName}${serializerName}`);
+                }
+            }
+        });
+    }
+    registerPropertyImports(result) {
+        for (const property of result.properties) {
+            if (property.decorators?.isTransient) {
+                continue;
+            }
+            if (property.decorators?.with) {
+                if (this.containsGenericType(property.type)) {
+                    this.importManager.registerCoreImports(['WithEntrySerializer']);
+                }
+                else {
+                    this.importManager.registerCoreImports(['WithEntryContextualSerializer']);
+                }
+            }
+            this.execPropertyImports(property.type.dependencies);
+        }
+    }
+    execPropertyImports(dependencies) {
+        dependencies.forEach((dependency) => {
+            this.processDependency(dependency);
+        });
+    }
+    processDependency(dependency) {
+        const source = dependency.source;
+        if (source.type !== 'imported' && source.type !== 'local') {
+            return;
+        }
+        if (source.type === 'imported') {
+            this.importManager.registerCustomTypeImport(source.sourceFilePath, dependency.typeName);
+        }
+        switch (dependency.typeKind) {
+            case __1.TypeKind.CLASS:
+                this.processClassDependency(dependency, source);
+                break;
+            case __1.TypeKind.INTERFACE:
+                this.processInterfaceDependency(dependency);
+                break;
+        }
+    }
+    processClassDependency(dependency, source) {
+        const classDetails = dependency.details;
+        const tempClassAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeClass(classDetails.classDecl);
+        if (!tempClassAnalysis.decorators.serializable) {
+            TempSerializerGenerator_1.TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
+        }
+        const serializerName = classDetails.isGeneric ? __1.StringConstants.SERIALIZER_FACTORY :
+            __1.StringConstants.SERIALIZER;
+        if (tempClassAnalysis.decorators.serializable) {
+            this.handleSerializableClass(dependency, source, serializerName);
+        }
+        else {
+            this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
+        }
+    }
+    handleSerializableClass(dependency, source, serializerName) {
+        if (source.type === 'imported') {
+            this.importManager.registerCustomTypeImport(source.sourceFilePath, `${dependency.typeName}${serializerName}`);
+        }
+    }
+    processInterfaceDependency(dependency) {
+        const interfaceDetails = dependency.details;
+        const tempClassAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeInterface(interfaceDetails.interfaceDecl);
+        TempSerializerGenerator_1.TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
+        const serializerName = dependency.details.isGeneric ? __1.StringConstants.SERIALIZER_FACTORY :
+            __1.StringConstants.SERIALIZER;
+        this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
+    }
+    generateCustomSerializerRegistration(sourceFile, result) {
+        this.importManager.registerCoreImports(['registerAutoGeneratedSerializerEntry']);
+        const customSerializer = result.decorators.serializable.with;
+        const registrationCode = `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
+        return registrationCode;
+    }
+    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
+    registerAutoGeneratedSerializerEntryProviderForSupplementary(${result.className}_SERIAL_NAME, () => [${result.className}, ${customSerializer}]);`;
+        return registrationCode;
+    }
+    getAllRequiredSerializers(properties) {
+        const requiredSerializers = new Set();
+        properties.forEach(property => {
+            const nestedSerializers = this.analyzeNestedSerializers(property.type);
+            nestedSerializers.forEach(serializer => requiredSerializers.add(serializer));
+        });
+        return Array.from(requiredSerializers);
+    }
+    analyzeNestedSerializers(structure) {
+        const requiredSerializers = new Set();
+        const analyzeType = (type) => {
+            if (type.kind === __1.PropertyKind.UNKNOWN) {
+                return;
+            }
+            if (type.kind === __1.PropertyKind.GENERIC) {
+                return;
+            }
+            const handler = this.registry.getHandlerForKind(type.kind);
+            const metadata = handler.getSerializerMetadata(type);
+            __1.Logger.debug(`Analyzing type ${type.sourceText}, metadata ${metadata.name}`);
+            if (type.kind !== __1.PropertyKind.OBJECT) {
+                requiredSerializers.add(metadata.name);
+            }
+            if (type.args && type.args.length > 0) {
+                type.args.forEach(arg => analyzeType(arg));
+            }
+            if (type.unionDetails && type.unionDetails.length > 0) {
+                type.unionDetails.forEach(member => analyzeType(member));
+            }
+        };
+        analyzeType(structure);
+        return Array.from(requiredSerializers);
+    }
+    containsGenericType(structure) {
+        if (structure.kind === __1.PropertyKind.GENERIC) {
+            return true;
+        }
+        if (structure.args) {
+            return structure.args.some(arg => this.containsGenericType(arg));
+        }
+        if (structure.unionDetails) {
+            return structure.unionDetails.some(member => this.containsGenericType(member));
+        }
+        return false;
+    }
+    propertyAnalysisToPropertyGenerationInfo(properties) {
+        return properties.filter((prop) => {
+            if (prop.decorators?.isTransient) {
+                return false;
+            }
+            if (prop.type.kind === __1.PropertyKind.UNKNOWN) {
+                __1.Logger.warn(`属性 ${prop.name} 类型为 UNKNOWN，已自动跳过序列化生成`);
+                return false;
+            }
+            return true;
+        }).map((prop) => {
+            const handler = this.registry.getHandlerForKind(prop.type.kind);
+            const serializer = handler.getSerializerMetadata(prop.type, prop.decorators?.with);
+            return { analysis: prop, serializer };
+        });
+    }
+    ;
+    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;
+    }
+}
+exports.SerializerGenerator = SerializerGenerator;

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

@@ -0,0 +1,19 @@
+import { ITaskContext, ClassAnalysis, InterfaceAnalysis } from '../../..';
+export declare class TempSerializerGenerator {
+    private static INSTANCE;
+    private readonly TEMP_SERIALIZER_DIR_NAME;
+    private context;
+    private serializerFiles;
+    private constructor();
+    static getInstance(): TempSerializerGenerator;
+    init(context: ITaskContext): void;
+    getTempSerializerDir(): string;
+    generateSerializer(classAnalysis: ClassAnalysis | InterfaceAnalysis): void;
+    private registerImports;
+    saveFile(): void;
+    private generateIndexFile;
+    private generateExportAlias;
+    private generateUniqueFileName;
+    private extractPathPrefix;
+    private getUniqueKey;
+}