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

package/dist/core/services/CodeAnalysisService.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeAnalysisService = void 0;
+const __1 = require("..");
+const ClassAnalyzer_1 = require("../analyzers/ClassAnalyzer");
+const TsMorphUtil_1 = require("../utils/TsMorphUtil");
+class CodeAnalysisService {
+    constructor() { }
+    analyzeFile(filePath) {
+        __1.Logger.debug(`开始分析文件: ${filePath}`);
+        const sourceFile = TsMorphUtil_1.TsMorphUtil.getProject().addSourceFileAtPath(filePath);
+        const classes = sourceFile.getClasses();
+        const results = [];
+        for (const cls of classes) {
+            const classAnalysis = this.analyzeClass(cls);
+            if (classAnalysis) {
+                results.push(classAnalysis);
+            }
+            else {
+                __1.Logger.debug(`${cls.getName()}无@Serializable装饰器，跳过分析`);
+            }
+        }
+        __1.Logger.debug(`文件分析完成: ${filePath}, 发现 ${results.length} 个@Serializable类`);
+        return results;
+    }
+    analyzeClass(cls) {
+        const decorators = cls.getDecorators();
+        for (const decorator of decorators) {
+            if (decorator.getName() === __1.DecoratorConstants.SERIALIZABLE) {
+                return ClassAnalyzer_1.ClassAnalyzer.analyzeClass(cls);
+            }
+        }
+        return null;
+    }
+    dispose() {
+        const sourceFiles = TsMorphUtil_1.TsMorphUtil.getProject().getSourceFiles();
+        __1.Logger.info(`code analysis Clearing ${sourceFiles.length} source files...`);
+        sourceFiles.forEach((sourceFile) => {
+            TsMorphUtil_1.TsMorphUtil.getProject().removeSourceFile(sourceFile);
+        });
+    }
+}
+exports.CodeAnalysisService = CodeAnalysisService;

package/dist/core/services/CodeGenerationEngine.d.ts

@@ -0,0 +1,12 @@
+import { ClassAnalysis, IGeneratedFile, IGenerationResult, ITaskContext, GeneratedFileInfo } from '..';
+export declare class CodeGenerationEngine {
+    private readonly analysisService;
+    private readonly generationService;
+    private allClassAnalysis;
+    constructor();
+    processFilesUnified(scanFiles: string[], context: ITaskContext): IGenerationResult;
+    processFileUnified(filePath: string, context: ITaskContext): IGeneratedFile | null;
+    collectGeneratedFileInfos(context: ITaskContext): GeneratedFileInfo[];
+    getAllAnalysisResults(): ClassAnalysis[];
+    cleanup(): void;
+}

package/dist/core/services/CodeGenerationEngine.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGenerationEngine = void 0;
+const __1 = require("..");
+const CodeAnalysisService_1 = require("./CodeAnalysisService");
+const CodeGenerationService_1 = require("./CodeGenerationService");
+const SendableMergeabilityRegistry_1 = require("../analyzers/SendableMergeabilityRegistry");
+const SendableMergeChecker_1 = require("../analyzers/SendableMergeChecker");
+const CustomTypeAnalyzer_1 = require("../analyzers/CustomTypeAnalyzer");
+class CodeGenerationEngine {
+    constructor() {
+        this.allClassAnalysis = [];
+        this.analysisService = new CodeAnalysisService_1.CodeAnalysisService();
+        this.generationService = new CodeGenerationService_1.CodeGenerationService();
+    }
+    processFilesUnified(scanFiles, context) {
+        if (!scanFiles || scanFiles.length === 0) {
+            __1.Logger.info('没有待处理的源文件');
+            return {
+                generatedFiles: [],
+                skippedFiles: []
+            };
+        }
+        const generatedFiles = [];
+        const skippedFiles = [];
+        this.allClassAnalysis = [];
+        SendableMergeabilityRegistry_1.SendableMergeabilityRegistry.clear();
+        __1.Logger.info(`开始处理 ${scanFiles.length} 个源文件`);
+        __1.Logger.debug(`[阶段1] 开始分析所有文件`);
+        const fileAnalysisMap = new Map();
+        for (const filePath of scanFiles) {
+            const classAnalysis = this.analysisService.analyzeFile(filePath);
+            if (classAnalysis.length === 0) {
+                skippedFiles.push(filePath);
+                __1.Logger.debug(`跳过文件（无@Serializable类）: ${filePath}`);
+                continue;
+            }
+            fileAnalysisMap.set(filePath, classAnalysis);
+            this.allClassAnalysis.push(...classAnalysis);
+        }
+        __1.Logger.debug(`[阶段1.1] 完成基本分析，共 ${this.allClassAnalysis.length} 个类`);
+        __1.Logger.debug(`[阶段1.2] 开始检查合并性并注册`);
+        for (const analysis of this.allClassAnalysis) {
+            if (analysis.decorators.serializable?.generateSendable) {
+                analysis.canMerge = SendableMergeChecker_1.SendableMergeChecker.check(analysis);
+                SendableMergeabilityRegistry_1.SendableMergeabilityRegistry.register(analysis.className, analysis.canMerge);
+            }
+            else {
+                SendableMergeabilityRegistry_1.SendableMergeabilityRegistry.register(analysis.className, false);
+            }
+        }
+        __1.Logger.debug(`[阶段2] 开始生成所有文件`);
+        for (const [filePath, classAnalysis] of fileAnalysisMap.entries()) {
+            const generatedFile = this.generationService.generateForSourceFile(filePath, classAnalysis, context);
+            if (generatedFile) {
+                generatedFiles.push(generatedFile);
+                __1.Logger.debug(`成功处理文件: ${filePath}`);
+            }
+            else {
+                __1.Logger.warn(`文件生成失败: ${filePath}`);
+            }
+        }
+        __1.Logger.info(`处理完成，成功 ${generatedFiles.length} 个，跳过 ${skippedFiles.length} 个`);
+        return { generatedFiles, skippedFiles };
+    }
+    processFileUnified(filePath, context) {
+        const classAnalysis = this.analysisService.analyzeFile(filePath);
+        if (classAnalysis.length === 0) {
+            __1.Logger.debug(`源文件 ${filePath} 无@Serializable类，跳过生成`);
+            return null;
+        }
+        this.allClassAnalysis.push(...classAnalysis);
+        return this.generationService.generateForSourceFile(filePath, classAnalysis, context);
+    }
+    collectGeneratedFileInfos(context) {
+        const fileInfoMap = new Map();
+        for (const analysisResult of this.allClassAnalysis) {
+            const sourceFilePath = analysisResult.sourceFilePath;
+            if (!fileInfoMap.has(sourceFilePath)) {
+                const generatedFilePath = context.mapToOutputPath(sourceFilePath);
+                fileInfoMap.set(sourceFilePath, {
+                    sourceFilePath,
+                    generatedFilePath,
+                    classNames: new Set()
+                });
+            }
+            const fileInfo = fileInfoMap.get(sourceFilePath);
+            fileInfo.classNames.add(analysisResult.className);
+        }
+        return Array.from(fileInfoMap.values());
+    }
+    getAllAnalysisResults() {
+        return [...this.allClassAnalysis];
+    }
+    cleanup() {
+        this.analysisService.dispose();
+        this.allClassAnalysis = [];
+        CustomTypeAnalyzer_1.CustomTypeAnalyzer.getInstance().clearCache();
+        SendableMergeabilityRegistry_1.SendableMergeabilityRegistry.clear();
+    }
+}
+exports.CodeGenerationEngine = CodeGenerationEngine;

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

@@ -0,0 +1,13 @@
+import { ClassAnalysis, IGeneratedFile, ITaskContext } from '../..';
+export declare class CodeGenerationService {
+    private readonly importManger;
+    private readonly originalClassGenerator;
+    private readonly serializerGenerator;
+    private readonly sendableGenerator;
+    constructor();
+    generateForSourceFile(sourcePath: string, results: ClassAnalysis[], context: ITaskContext): IGeneratedFile | null;
+    private generateMainModelFile;
+    private generateSendableModelFiles;
+    private generateSendableFile;
+    private cleanup;
+}

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

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGenerationService = void 0;
+const OriginalClassGenerator_1 = require("./generators/OriginalClassGenerator");
+const SendableClassGenerator_1 = require("./generators/SendableClassGenerator");
+const SerializerGenerator_1 = require("./generators/SerializerGenerator");
+const ImportManager_1 = require("./shared/ImportManager");
+const __1 = require("../..");
+const SerializationPathUtil_1 = __importDefault(require("../../utils/SerializationPathUtil"));
+const CustomError_1 = require("../../utils/CustomError");
+const TsMorphUtil_1 = require("../../utils/TsMorphUtil");
+class CodeGenerationService {
+    constructor() {
+        this.importManger = new ImportManager_1.ImportManager();
+        this.originalClassGenerator = new OriginalClassGenerator_1.OriginalClassGenerator(this.importManger);
+        this.serializerGenerator = new SerializerGenerator_1.SerializerGenerator(this.importManger);
+        this.sendableGenerator = new SendableClassGenerator_1.SendableClassGenerator();
+    }
+    generateForSourceFile(sourcePath, results, context) {
+        __1.Logger.debug(`开始为 ${sourcePath} 文件生成代码: ${results.length} 个类`);
+        this.importManger.setContext(context);
+        this.generateSendableModelFiles(results, context);
+        return this.generateMainModelFile(sourcePath, results, context);
+    }
+    generateMainModelFile(sourceFileAbs, results, context) {
+        const originalSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().addSourceFileAtPath(sourceFileAbs);
+        const outputPath = context.mapToOutputPath(sourceFileAbs);
+        context.ensureOutputDirectory(outputPath);
+        if (!context.isValidOutputPath(outputPath)) {
+            throw new CustomError_1.CustomError(`输出路径无效: ${outputPath}`, CustomError_1.ErrorCodes.INVALID_OUTPUT_FAIL);
+        }
+        const outputSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile(outputPath, '', { overwrite: true });
+        const serializableGeneratorContext = [];
+        for (const classAnalysis of results) {
+            serializableGeneratorContext.push(this.serializerGenerator.generate(outputSourceFile, classAnalysis, context));
+        }
+        this.originalClassGenerator.generate(outputSourceFile, originalSourceFile, results, context);
+        for (const content of serializableGeneratorContext) {
+            this.serializerGenerator.generateRegistration(outputSourceFile, content);
+        }
+        this.importManger.getImportDeclarations().forEach((importDeclaration) => {
+            outputSourceFile.addImportDeclaration({
+                moduleSpecifier: importDeclaration.specifier,
+                namedImports: [...new Set(importDeclaration.names)]
+            });
+        });
+        this.importManger.getDefaultImport().forEach((importDeclaration) => {
+            outputSourceFile.addImportDeclaration({
+                moduleSpecifier: importDeclaration.specifier,
+                defaultImport: importDeclaration.name
+            });
+        });
+        outputSourceFile.formatText();
+        outputSourceFile.saveSync();
+        this.cleanup();
+        return {
+            sourcePath: sourceFileAbs,
+            outputPath,
+            contentLength: outputSourceFile.getFullText().length,
+            serializerCount: results.length,
+            generatedAt: Date.now()
+        };
+    }
+    generateSendableModelFiles(results, context) {
+        for (const classAnalysis of results) {
+            if (classAnalysis.canMerge) {
+                __1.Logger.debug(`类 ${classAnalysis.className} 采用合并策略，跳过独立Sendable文件生成`);
+                continue;
+            }
+            if (this.sendableGenerator.canHandle(classAnalysis)) {
+                this.generateSendableFile(classAnalysis, context);
+            }
+        }
+    }
+    generateSendableFile(result, context) {
+        __1.Logger.debug(`类 ${result.className} 采用独立Sendable文件生成`);
+        const sendableOutputPath = SerializationPathUtil_1.default.mapToSendableOutputPath(result.className, context);
+        context.ensureOutputDirectory(sendableOutputPath);
+        const sendableImportManager = new ImportManager_1.ImportManager();
+        sendableImportManager.setContext(context);
+        sendableImportManager.registerArkTSImports(['lang']);
+        const sendableSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile(sendableOutputPath, '', { overwrite: true });
+        this.sendableGenerator.generate(sendableSourceFile, result, sendableImportManager);
+        if (this.sendableGenerator.needsCollectionsImport(result)) {
+            this.importManger.registerArkTSImports(['collections']);
+        }
+        this.importManger.registerCustomTypeImport(sendableOutputPath, `Sendable${result.className}`);
+        sendableImportManager.getImportDeclarations().forEach((importDeclaration) => {
+            sendableSourceFile.addImportDeclaration({
+                moduleSpecifier: importDeclaration.specifier,
+                namedImports: [...new Set(importDeclaration.names)]
+            });
+        });
+        sendableImportManager.getDefaultImport().forEach((importDeclaration) => {
+            sendableSourceFile.addImportDeclaration({
+                moduleSpecifier: importDeclaration.specifier,
+                defaultImport: importDeclaration.name
+            });
+        });
+        sendableSourceFile.formatText();
+        sendableSourceFile.saveSync();
+    }
+    cleanup() {
+        this.importManger.clear();
+    }
+}
+exports.CodeGenerationService = CodeGenerationService;

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

@@ -0,0 +1,13 @@
+import { ClassDeclaration } from 'ts-morph';
+import { ClassAnalysis } from '../../..';
+export declare class MergedSendableClassGenerator {
+    private static readonly TURBO_TRANS_DECORATORS;
+    generate(classDecl: ClassDeclaration, classAnalysis: ClassAnalysis): void;
+    private removeTurboTransDecorators;
+    private addSendableDecorator;
+    private addITSerializableInterface;
+    private generateGetTypeMethod;
+    private generateConvertToSendableMethod;
+    private generateToOriginMethod;
+    private generateToJsonMethod;
+}

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergedSendableClassGenerator = void 0;
+const __1 = require("../../..");
+const constants_1 = require("../../../constants");
+class MergedSendableClassGenerator {
+    generate(classDecl, classAnalysis) {
+        this.removeTurboTransDecorators(classDecl);
+        this.addSendableDecorator(classDecl);
+        this.addITSerializableInterface(classDecl);
+        this.generateConvertToSendableMethod(classDecl, classAnalysis);
+        this.generateToOriginMethod(classDecl, classAnalysis);
+        this.generateToJsonMethod(classDecl, classAnalysis);
+        __1.Logger.debug(`成功生成合并版Sendable类: ${classAnalysis.className}`);
+    }
+    removeTurboTransDecorators(classDecl) {
+        const classDecorators = classDecl.getDecorators();
+        classDecorators.forEach(decorator => {
+            const decoratorName = decorator.getName();
+            if (MergedSendableClassGenerator.TURBO_TRANS_DECORATORS.has(decoratorName)) {
+                decorator.remove();
+                __1.Logger.debug(`移除类 ${classDecl.getName()} 的装饰器: @${decoratorName}`);
+            }
+        });
+        const properties = classDecl.getProperties();
+        properties.forEach(property => {
+            const propDecorators = property.getDecorators();
+            propDecorators.forEach(decorator => {
+                const decoratorName = decorator.getName();
+                if (MergedSendableClassGenerator.TURBO_TRANS_DECORATORS.has(decoratorName)) {
+                    decorator.remove();
+                    __1.Logger.debug(`移除属性 ${property.getName()} 的装饰器: @${decoratorName}`);
+                }
+            });
+        });
+    }
+    addSendableDecorator(classDecl) {
+        classDecl.addDecorator({ name: 'Sendable' });
+    }
+    addITSerializableInterface(classDecl) {
+        const existingImplements = classDecl.getImplements().map(impl => impl.getText());
+        if (existingImplements.some(impl => impl.includes('ITSerializable'))) {
+            __1.Logger.warn(`类 ${classDecl.getName()} 已经实现了ITSerializable接口, 跳过接口添加`);
+            return;
+        }
+        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方法，跳过生成`);
+            return;
+        }
+        let returnType = classAnalysis.className;
+        if (classAnalysis.generics.parameters.length > 0) {
+            returnType += `<${classAnalysis.generics.parameters.join(', ')}>`;
+        }
+        classDecl.addMethod({
+            name: 'toSendable',
+            returnType: returnType,
+            statements: ['return this;']
+        });
+        __1.Logger.debug(`为合并版Sendable类 ${classAnalysis.className} 生成toSendable方法（返回自身）`);
+    }
+    generateToOriginMethod(classDecl, classAnalysis) {
+        if (classDecl.getMethod('toOrigin')) {
+            __1.Logger.warn(`类 ${classAnalysis.className} 已存在toOrigin方法，跳过生成`);
+            return;
+        }
+        let returnType = classAnalysis.className;
+        if (classAnalysis.generics.parameters.length > 0) {
+            returnType += `<${classAnalysis.generics.parameters.join(', ')}>`;
+        }
+        classDecl.addMethod({
+            name: 'toOrigin',
+            returnType: returnType,
+            statements: ['return this;']
+        });
+        __1.Logger.debug(`为合并版Sendable类 ${classAnalysis.className} 生成toOrigin方法（返回自身）`);
+    }
+    generateToJsonMethod(classDecl, classAnalysis) {
+        if (classDecl.getMethod('toJson')) {
+            __1.Logger.warn(`类 ${classAnalysis.className} 已存在toJson方法，跳过生成`);
+            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',
+            parameters: [{
+                    name: 'typeKey',
+                    type: 'TypeKey',
+                    hasQuestionToken: true
+                }],
+            statements: [methodBody]
+        });
+    }
+}
+exports.MergedSendableClassGenerator = MergedSendableClassGenerator;
+MergedSendableClassGenerator.TURBO_TRANS_DECORATORS = new Set(constants_1.DecoratorConstants.SERIAL_DECORATORS);

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

@@ -0,0 +1,21 @@
+import { SourceFile } from 'ts-morph';
+import { ClassAnalysis, ITaskContext } 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;
+    private copySourceFileContentWithoutImports;
+    private addITSerializableInterface;
+    private generateSerialNameConstant;
+    private addStaticSerialName;
+    private generateGetTypeMethod;
+    private generateConvertToSendableMethod;
+    private generateToJsonMethod;
+    private registerImports;
+    private generateConvertToSendableMethodBody;
+    private generateConstructorCall;
+    private generatePropertyAssignment;
+    private generatePropertyConversion;
+}

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

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OriginalClassGenerator = void 0;
+const __1 = require("../../..");
+const SerializationPathUtil_1 = __importDefault(require("../../../utils/SerializationPathUtil"));
+const ITypeHandler_1 = require("../../../handlers/ITypeHandler");
+const handlers_1 = require("../../../handlers");
+const MergedSendableClassGenerator_1 = require("./MergedSendableClassGenerator");
+const CustomError_1 = require("../../../utils/CustomError");
+const TsMorphUtil_1 = require("../../../utils/TsMorphUtil");
+class OriginalClassGenerator {
+    constructor(importManager) {
+        this.importManager = importManager;
+        this.mergedSendableGenerator = new MergedSendableClassGenerator_1.MergedSendableClassGenerator();
+    }
+    generate(outputSourceFile, originalSourceFile, results, context) {
+        this.registerImports();
+        const contentWithoutImports = this.copySourceFileContentWithoutImports(originalSourceFile);
+        const tempSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile('temp.ts', contentWithoutImports, {
+            overwrite: true
+        });
+        for (const result of results) {
+            const className = result.className;
+            const targetClass = tempSourceFile.getClassOrThrow(className);
+            if (result.canMerge && result.decorators.serializable?.generateSendable) {
+                this.importManager.registerArkTSImports(['lang']);
+                this.mergedSendableGenerator.generate(targetClass, result);
+            }
+            else {
+                this.addITSerializableInterface(targetClass);
+                this.addStaticSerialName(targetClass, result, context);
+                this.generateConvertToSendableMethod(targetClass, result);
+                this.generateToJsonMethod(targetClass, result);
+            }
+        }
+        outputSourceFile.addStatements(tempSourceFile.getFullText());
+    }
+    copySourceFileContentWithoutImports(originalSourceFile) {
+        const originalFilePath = originalSourceFile.getFilePath();
+        const originalDir = SerializationPathUtil_1.default.dirname(originalFilePath);
+        const tempSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile('temp-original.ts', originalSourceFile.getFullText(), {
+            overwrite: true
+        });
+        const importDeclarations = tempSourceFile.getImportDeclarations();
+        importDeclarations.forEach((importDecl) => {
+            const specifier = importDecl.getModuleSpecifierValue();
+            const names = importDecl.getNamedImports().map((names) => names.getName());
+            const defaultImport = importDecl.getDefaultImport();
+            const importOriginAbs = SerializationPathUtil_1.default.pathResolve(originalDir, specifier);
+            if (SerializationPathUtil_1.default.exist(importOriginAbs + '.ets')) {
+                const importOriginAbsWithExt = importOriginAbs + '.ets';
+                names.forEach((name) => {
+                    this.importManager.registerCustomTypeImport(importOriginAbsWithExt, name);
+                });
+                if (defaultImport) {
+                    this.importManager.registerDefaultImport(importOriginAbsWithExt, defaultImport.getText());
+                }
+            }
+            else {
+                names.forEach((name) => {
+                    this.importManager.registerCustomImport(specifier, name);
+                });
+                if (defaultImport) {
+                    this.importManager.registerDefaultImport(specifier, defaultImport.getText());
+                }
+            }
+            importDecl.remove();
+        });
+        const contentWithoutImports = tempSourceFile.getFullText();
+        if (!contentWithoutImports || contentWithoutImports.trim().length === 0) {
+            throw new CustomError_1.CustomError(`Source file content is empty for ${originalFilePath}`, CustomError_1.ErrorCodes.INVALID_FILE_CONTENT);
+        }
+        __1.Logger.debug(`成功拷贝 ${originalFilePath} 文件内容并替换import语句`);
+        return contentWithoutImports;
+    }
+    addITSerializableInterface(classDecl) {
+        const existingImplements = classDecl.getImplements().map((impl) => impl.getText());
+        if (existingImplements.some((impl) => impl.includes('ITSerializable'))) {
+            __1.Logger.warn(`类 ${classDecl.getName()} 已经实现了ITSerializable接口, 跳过接口添加`);
+            return;
+        }
+        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) {
+        classDecl.addProperty({
+            name: 'SERIAL_NAME',
+            type: 'string',
+            initializer: `${result.className}_SERIAL_NAME`,
+            isStatic: true,
+            isReadonly: true,
+        });
+        __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方法，跳过生成`);
+            return;
+        }
+        const isSendable = result.decorators.serializable?.generateSendable;
+        if (!isSendable) {
+            classDecl.addMethod({
+                name: 'toSendable',
+                returnType: 'undefined',
+                statements: ['return undefined']
+            });
+            return;
+        }
+        let returnType = `Sendable${result.className}`;
+        if (result.generics.parameters.length > 0) {
+            returnType += `<${result.generics.parameters.join(', ')}>`;
+        }
+        const methodBody = this.generateConvertToSendableMethodBody(result, returnType);
+        classDecl.addMethod({
+            name: 'toSendable',
+            returnType: returnType,
+            statements: [methodBody]
+        });
+    }
+    generateToJsonMethod(classDecl, result) {
+        if (classDecl.getMethod('toJson')) {
+            __1.Logger.warn(`类 ${result.className} 已存在toJson方法，跳过生成`);
+            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',
+            parameters: [{
+                    name: 'typeKey',
+                    type: 'TypeKey',
+                    hasQuestionToken: true
+                }],
+            statements: [methodBody]
+        });
+    }
+    registerImports() {
+        this.importManager.registerJsonImports(['ITSerializable', 'TJSON']);
+        this.importManager.registerCoreImports(['TypeKey', 'Serializable']);
+    }
+    generateConvertToSendableMethodBody(classAnalysis, returnType) {
+        const constructorProps = [];
+        classAnalysis.constructorParams.forEach((cp) => {
+            const matchingProperty = classAnalysis.properties.find((p) => p.name === cp.name);
+            if (matchingProperty) {
+                constructorProps.push({
+                    ...matchingProperty,
+                    type: {
+                        ...matchingProperty.type,
+                        isOptional: cp.isOptional,
+                    }
+                });
+            }
+        });
+        const assignmentProps = classAnalysis.properties.filter((p) => {
+            return classAnalysis.constructorParams.every((cp) => cp.name !== p.name);
+        });
+        const statements = [];
+        const constructorCall = this.generateConstructorCall(constructorProps, returnType);
+        statements.push(`const sendable = ${constructorCall};`);
+        if (assignmentProps.length > 0) {
+            statements.push('');
+            statements.push('// 非构造函数属性赋值');
+            assignmentProps.forEach((prop) => {
+                const assignment = this.generatePropertyAssignment(prop);
+                statements.push(`sendable.${prop.name} = ${assignment};`);
+            });
+        }
+        statements.push('');
+        statements.push('return sendable;');
+        return statements.join('\n');
+    }
+    generateConstructorCall(constructorProps, returnType) {
+        if (constructorProps.length === 0) {
+            return `new ${returnType}()`;
+        }
+        const args = constructorProps.map(prop => {
+            return this.generatePropertyConversion(prop, 'this.');
+        }).join(', ');
+        return `new ${returnType}(${args})`;
+    }
+    generatePropertyAssignment(prop) {
+        return this.generatePropertyConversion(prop, 'this.');
+    }
+    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);
+        return handler.generatePropertyConversion(prop.type, sourceValue, ITypeHandler_1.ConversionDirection.TO_SENDABLE);
+    }
+}
+exports.OriginalClassGenerator = OriginalClassGenerator;