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

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

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

package/dist/core/constants/DecoratorConstants.js

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

package/dist/core/handlers/CustomClassHandler.js

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

package/dist/core/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';

package/dist/core/services/CodeAnalysisService.js

@@ -5,7 +5,8 @@ const __1 = require("..");
 const ClassAnalyzer_1 = require("../analyzers/ClassAnalyzer");
 const TsMorphUtil_1 = require("../utils/TsMorphUtil");
 class CodeAnalysisService {
-    constructor() { }
+    constructor() {
+    }
     analyzeFile(filePath) {
         __1.Logger.debug(`开始分析文件: ${filePath}`);
         const sourceFile = TsMorphUtil_1.TsMorphUtil.getProject().addSourceFileAtPath(filePath);

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

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

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

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

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

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

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

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

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

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

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

@@ -9,16 +9,38 @@ export declare class SendableClassGenerator {
     private updateInheritanceToSendable;
     private removeImplements;
     private removeAllDecorators;
+    private removeClassDecorators;
+    private removePropertyDecorators;
+    private removeMethodDecorators;
+    private logAndRemoveDecorator;
     private convertPropertyTypesToSendable;
+    private convertSinglePropertyToSendable;
+    private updatePropertyType;
+    private updatePropertyInitializer;
     private addSendableConstraints;
     private addToOriginMethod;
     private generatedToOriginMethodBody;
+    private getConstructorCall;
     private generatePropertyConversion;
     private getSendableClassName;
     private addNecessaryImports;
+    private processPropertyDependencyImports;
+    private registerDependencyImport;
+    private processBaseClassImport;
+    private processCollectionsImport;
+    private copySourceFileImports;
+    private processSingleImportDeclaration;
+    private registerModuleImports;
+    private registerPackageImports;
     private convertConstructorParameterTypes;
+    private convertSingleConstructorParameters;
+    private convertSingleParameter;
     private isObjectType;
     needsCollectionsImport(result: ClassAnalysis): boolean;
     private convertInitializerToSendable;
+    private convertArrayLiteralToSendable;
+    private replaceObjectConstructors;
+    private replaceObjectConstructorMatch;
+    private replaceCollectionTypes;
     private convertToSendableType;
 }