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

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

@@ -29,7 +29,8 @@ class SendableClassGenerator {
     }
     getOriginClassDeclaration(result) {
         const originalContent = result.originalClass?.getFullText();
-        const copiedSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile('copied-file.ts', originalContent, { overwrite: true });
+        const copiedSourceFile = TsMorphUtil_1.TsMorphUtil.getProject()
+            .createSourceFile('copied-file.ts', originalContent, { overwrite: true });
         return copiedSourceFile.getClassOrThrow(result.className);
     }
     renameSendableClass(classDecl, result) {
@@ -51,51 +52,67 @@ class SendableClassGenerator {
         });
     }
     removeAllDecorators(classDecl) {
+        this.removeClassDecorators(classDecl);
+        this.removePropertyDecorators(classDecl);
+        this.removeMethodDecorators(classDecl);
+    }
+    removeClassDecorators(classDecl) {
         classDecl.getDecorators().forEach((decorator) => {
-            __1.Logger.warn(`Remove the decorator ${decorator.getName()}, because @Sendable cannot coexist with other decorators`);
-            decorator.remove();
+            this.logAndRemoveDecorator(decorator);
         });
+    }
+    removePropertyDecorators(classDecl) {
         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();
-            });
+            property.getDecorators().forEach((decorator) => this.logAndRemoveDecorator(decorator));
         });
+    }
+    removeMethodDecorators(classDecl) {
         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();
-            });
+            method.getDecorators().forEach((decorator) => this.logAndRemoveDecorator(decorator));
         });
     }
+    logAndRemoveDecorator(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}`);
-                }
-            }
+            this.convertSinglePropertyToSendable(property, result);
         });
     }
+    convertSinglePropertyToSendable(property, result) {
+        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}`);
+        this.updatePropertyType(property, propertyAnalysis);
+        this.updatePropertyInitializer(property, propertyAnalysis.name);
+    }
+    updatePropertyType(property, propertyAnalysis) {
+        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(`属性 ${propertyAnalysis.name} 类型从 ${propertyAnalysis.type.sourceText} 转换为 ${sendableType}`);
+        }
+    }
+    updatePropertyInitializer(property, propertyName) {
+        const initializer = property.getInitializer();
+        if (!initializer) {
+            return;
+        }
+        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');
@@ -115,7 +132,24 @@ class SendableClassGenerator {
     }
     generatedToOriginMethodBody(result, returnType) {
         const statements = [];
-        let constructorCall;
+        const constructorCall = this.getConstructorCall(result, 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');
+    }
+    getConstructorCall(result, returnType) {
         if (result.constructorParams.length > 0) {
             const constructorProps = [];
             result.properties.forEach((p) => {
@@ -135,26 +169,11 @@ class SendableClassGenerator {
                 return this.generatePropertyConversion(prop, 'this.');
             })
                 .join(', ');
-            constructorCall = `new ${returnType}(${args})`;
+            return `new ${returnType}(${args})`;
         }
         else {
-            constructorCall = `new ${returnType}()`;
+            return `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}`;
@@ -175,74 +194,108 @@ class SendableClassGenerator {
         return `Sendable${result.className}`;
     }
     addNecessaryImports(result, importManager) {
+        this.processPropertyDependencyImports(result, importManager);
+        this.processBaseClassImport(result, importManager);
+        this.processCollectionsImport(result, importManager);
+        this.copySourceFileImports(result, importManager);
+    }
+    processPropertyDependencyImports(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);
-                }
+                this.registerDependencyImport(dependency, importManager);
             });
         });
+    }
+    registerDependencyImport(dependency, importManager) {
+        if (dependency.typeKind !== __1.TypeKind.CLASS) {
+            importManager.registerCustomTypeImport(dependency.source.sourceFilePath, dependency.typeName);
+            return;
+        }
+        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);
+        }
+    }
+    processBaseClassImport(result, importManager) {
         const baseClass = result.inheritance.baseClassAnalysis;
-        if (baseClass) {
-            importManager.registerCustomImport('./Sendable' + baseClass.className, 'Sendable' + baseClass.className);
+        if (!baseClass) {
+            return;
         }
+        importManager.registerCustomImport('./Sendable' + baseClass.className, 'Sendable' + baseClass.className);
+    }
+    processCollectionsImport(result, importManager) {
         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());
-                }
-            }
+        if (!needsCollections) {
+            return;
+        }
+        importManager.registerArkTSImports(['collections']);
+    }
+    copySourceFileImports(result, importManager) {
+        const importDeclarations = result.originalClass?.getSourceFile().getImportDeclarations();
+        if (!importDeclarations) {
+            return;
+        }
+        importDeclarations.forEach((importDecl) => {
+            this.processSingleImportDeclaration(importDecl, result, importManager);
         });
     }
+    processSingleImportDeclaration(importDecl, result, importManager) {
+        const specifier = importDecl.getModuleSpecifierValue();
+        const names = importDecl.getNamedImports().map((n) => n.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')) {
+            this.registerModuleImports(importOriginAbs + '.ets', names, defaultImport, importManager);
+        }
+        else {
+            this.registerPackageImports(specifier, names, defaultImport, importManager);
+        }
+    }
+    registerModuleImports(absPath, names, defaultImport, importManager) {
+        names.forEach((name) => {
+            importManager.registerCustomTypeImport(absPath, name);
+        });
+        if (defaultImport) {
+            importManager.registerDefaultImport(absPath, defaultImport.getText());
+        }
+    }
+    registerPackageImports(specifier, names, defaultImport, importManager) {
+        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}`);
-                }
-            });
+            this.convertSingleConstructorParameters(constructor, result);
+        });
+    }
+    convertSingleConstructorParameters(constructor, result) {
+        const parameters = constructor.getParameters();
+        parameters.forEach((parameter) => {
+            this.convertSingleParameter(parameter, result);
         });
     }
+    convertSingleParameter(parameter, result) {
+        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)) {
@@ -266,33 +319,45 @@ class SendableClassGenerator {
         });
     }
     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()';
-            }
+        let convertedText = this.convertArrayLiteralToSendable(initializerText);
+        convertedText = this.replaceCollectionTypes(convertedText);
+        convertedText = this.replaceObjectConstructors(convertedText);
+        __1.Logger.debug(`初始化器转换: ${initializerText} -> ${convertedText}`);
+        return convertedText;
+    }
+    convertArrayLiteralToSendable(text) {
+        if (text === '[]') {
+            return 'new collections.Array()';
+        }
+        if (!text.startsWith('[') || !text.endsWith(']')) {
+            return text;
+        }
+        const arrayContent = text.slice(1, -1);
+        if (arrayContent.trim()) {
+            return `new collections.Array(${arrayContent})`;
         }
+        return 'new collections.Array()';
+    }
+    replaceObjectConstructors(text) {
+        const objectConstructorPattern = /new\s+(\w+)\s*\(/g;
+        return text.replace(objectConstructorPattern, (match, className) => {
+            return this.replaceObjectConstructorMatch(match, className);
+        });
+    }
+    replaceObjectConstructorMatch(match, className) {
+        if (className === 'collections' || match.includes('collections.')) {
+            return match;
+        }
+        if (this.isObjectType(className)) {
+            return match.replace(className, `Sendable${className}`);
+        }
+        return match;
+    }
+    replaceCollectionTypes(text) {
+        let convertedText = text;
         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) {

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

@@ -20,7 +20,7 @@ class SerializerGenerator {
     generate(sourceFile, result, context) {
         if (result.decorators?.serializable?.with) {
             sourceFile.addStatements(this.generateBuiltinSerializerRegistrationForSupplementary(context, result));
-            return this.generateCustomSerializerRegistration(sourceFile, result);
+            return this.generateCustomSerializerRegistration(result);
         }
         this.registerImports(result);
         const templateContext = {
@@ -49,7 +49,8 @@ class SerializerGenerator {
         const requiredBuiltinSerializers = this.getAllRequiredSerializers(result.properties);
         this.importManager.registerCoreImports([
             'Serializer', 'SerialDescriptor', 'buildClassSerialDescriptor',
-            'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'registerAutoGeneratedSerializerEntryProviderForSupplementary',
+            'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'ObjectUtils',
+            'registerAutoGeneratedSerializerEntryProviderForSupplementary', 'lazy',
             ...requiredBuiltinSerializers
         ]);
         this.registerDecoratorsImports(result);
@@ -120,15 +121,15 @@ class SerializerGenerator {
                     this.importManager.registerCoreImports(['WithEntryContextualSerializer']);
                 }
             }
-            this.execPropertyImports(property.type.dependencies);
+            this.execPropertyImports(property.type.dependencies, !!property.decorators?.with);
         }
     }
-    execPropertyImports(dependencies) {
+    execPropertyImports(dependencies, hasWithParam) {
         dependencies.forEach((dependency) => {
-            this.processDependency(dependency);
+            this.processDependency(dependency, hasWithParam);
         });
     }
-    processDependency(dependency) {
+    processDependency(dependency, hasWithParam) {
         const source = dependency.source;
         if (source.type !== 'imported' && source.type !== 'local') {
             return;
@@ -138,14 +139,14 @@ class SerializerGenerator {
         }
         switch (dependency.typeKind) {
             case __1.TypeKind.CLASS:
-                this.processClassDependency(dependency, source);
+                this.processClassDependency(dependency, source, hasWithParam);
                 break;
             case __1.TypeKind.INTERFACE:
-                this.processInterfaceDependency(dependency);
+                this.processInterfaceDependency(dependency, hasWithParam);
                 break;
         }
     }
-    processClassDependency(dependency, source) {
+    processClassDependency(dependency, source, hasWithParam) {
         const classDetails = dependency.details;
         const tempClassAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeClass(classDetails.classDecl);
         if (!tempClassAnalysis.decorators.serializable) {
@@ -157,6 +158,9 @@ class SerializerGenerator {
             this.handleSerializableClass(dependency, source, serializerName);
         }
         else {
+            if (hasWithParam) {
+                return;
+            }
             this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
         }
     }
@@ -165,7 +169,10 @@ class SerializerGenerator {
             this.importManager.registerCustomTypeImport(source.sourceFilePath, `${dependency.typeName}${serializerName}`);
         }
     }
-    processInterfaceDependency(dependency) {
+    processInterfaceDependency(dependency, hasWithParam) {
+        if (hasWithParam) {
+            return;
+        }
         const interfaceDetails = dependency.details;
         const tempClassAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeInterface(interfaceDetails.interfaceDecl);
         TempSerializerGenerator_1.TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
@@ -173,19 +180,17 @@ class SerializerGenerator {
             __1.StringConstants.SERIALIZER;
         this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
     }
-    generateCustomSerializerRegistration(sourceFile, result) {
+    generateCustomSerializerRegistration(result) {
         this.importManager.registerCoreImports(['registerAutoGeneratedSerializerEntry']);
         const customSerializer = result.decorators.serializable.with;
-        const registrationCode = `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
-        return registrationCode;
+        return `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
     }
     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
+        return `const ${result.className}_SERIAL_NAME = '${serialNameConstant}';\n
     registerAutoGeneratedSerializerEntryProviderForSupplementary(${result.className}_SERIAL_NAME, () => [${result.className}, ${customSerializer}]);`;
-        return registrationCode;
     }
     getAllRequiredSerializers(properties) {
         const requiredSerializers = new Set();

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

@@ -111,7 +111,8 @@ class TempSerializerGenerator {
         const indexSourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile(indexFilePath, '', { overwrite: true });
         const classNameMap = new Map();
         for (const [_, fileInfo] of this.serializerFiles) {
-            const serializerName = `${fileInfo.className}${fileInfo.isGeneric ? __1.StringConstants.SERIALIZER_FACTORY : __1.StringConstants.SERIALIZER}`;
+            const serializerName = `${fileInfo.className}${fileInfo.isGeneric ? __1.StringConstants.SERIALIZER_FACTORY :
+                __1.StringConstants.SERIALIZER}`;
             if (!classNameMap.has(serializerName)) {
                 classNameMap.set(serializerName, []);
             }

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

@@ -12,10 +12,10 @@ export declare class ImportManager {
     private isModularPath;
     private isRelativePath;
     private removeImportFromModule;
-    getImportDeclarations(): {
+    getImportDeclarations(): Array<{
         specifier: string;
         names: string[];
-    }[];
+    }>;
     getDefaultImport(): Array<{
         specifier: string;
         name: string;

package/dist/core/template/HandlebarsTemplateEngine.d.ts

@@ -14,6 +14,8 @@ export declare class HandlebarsTemplateEngine {
     registerHelper(name: string, helper: Handlebars.HelperDelegate): void;
     loadTemplateFromString(template: string): HandlebarsTemplateDelegate;
     private registerBuiltinHelpers;
+    private isPrimitiveType;
+    private toUpperCase;
     private registerComparisonHelpers;
     private registerTypeCheckHelpers;
     private hasNonSerializableClassDecorator;

package/dist/core/template/HandlebarsTemplateEngine.js

@@ -93,13 +93,21 @@ class HandlebarsTemplateEngine {
         this.registerConstructorHelpers();
         this.registerLogicHelpers();
     }
+    isPrimitiveType(kind) {
+        return ['string', 'number', 'boolean', 'bigint', 'undefined', 'null'].includes(kind);
+    }
+    toUpperCase(name) {
+        if (!name) {
+            return '';
+        }
+        return name.charAt(0).toUpperCase() + name.substring(1);
+    }
     registerComparisonHelpers() {
         this.registerHelper('eq', (arg1, arg2) => {
             return (arg1 === arg2);
         });
         this.registerHelper('eqPrimitiveType', (kind) => {
-            const primitives = ['string', 'number', 'boolean', 'bigint', 'undefined', 'null'];
-            return primitives.includes(kind);
+            return this.isPrimitiveType(kind);
         });
         this.registerHelper('eqEmptyType', (kind) => {
             return ['null', 'undefined'].includes(kind);
@@ -182,12 +190,26 @@ class HandlebarsTemplateEngine {
         this.registerHelper('toLowerCase', (str) => {
             return str.toLowerCase();
         });
+        this.registerHelper('toUpperCase', (str) => {
+            return this.toUpperCase(str);
+        });
+        this.registerHelper('getSerializer', (analysis) => {
+            if (this.isPrimitiveType(analysis.type.kind)) {
+                return `${analysis.name}Serializer`;
+            }
+            else {
+                return `get${this.toUpperCase(analysis.name)}Serializer()`;
+            }
+        });
         this.registerHelper('genericParametersString', (parameters) => {
             return parameters.join(', ');
         });
         this.registerHelper('genericParametersESObjString', (parameters) => {
             return parameters.map(() => 'ESObject').join(', ');
         });
+        this.registerHelper('filterGenericProperties', (properties) => {
+            return properties.filter(p => p.analysis.type.kind === __1.PropertyKind.GENERIC && !p.analysis.decorators?.isTransient);
+        });
     }
     registerPropertyAnalysisHelpers() {
         this.registerHelper('getPropertyIndex', (property, properties) => {

package/dist/core/utils/DeepCopyUtil.js

@@ -8,7 +8,8 @@ class DeepCopyUtil {
             defaultValue: original.defaultValue,
             decorators: this.copyPropertyDecorators(original.decorators),
             isMust: original.isMust,
-            type: this.copyTypeStructure(original.type)
+            type: this.copyTypeStructure(original.type),
+            visibility: original.visibility
         };
     }
     static copyPropertyDecorators(original) {
@@ -19,6 +20,7 @@ class DeepCopyUtil {
             serialName: original.serialName,
             isRequired: original.isRequired,
             isTransient: original.isTransient,
+            isPlainValue: original.isPlainValue,
             with: original.with
         };
     }
@@ -126,7 +128,7 @@ class DeepCopyUtil {
         if (typeof obj === 'object') {
             const copy = {};
             for (const key in obj) {
-                if (obj.hasOwnProperty(key)) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
                     copy[key] = this.deepCopy(obj[key]);
                 }
             }

package/dist/core/utils/GenericTypeSubstitutionUtil.d.ts

@@ -5,5 +5,6 @@ export declare class GenericTypeSubstitutionUtil {
     static substitutePropertyType(property: PropertyAnalysis, genericMapping: Map<string, TypeNode>, currentClassGenericParams?: string[]): PropertyAnalysis;
     private static substituteTypeStructure;
     private static constructTypeStructureFromTypeName;
+    private static regenerateSourceText;
     private static collectDependenciesFromChildren;
 }