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

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/generators/OriginalClassGenerator.d.ts

@@ -13,6 +13,8 @@ export declare class OriginalClassGenerator {
     private generateToJsonMethod;
     private registerImports;
     private generateConvertToSendableMethodBody;
+    private getConstructorProperties;
+    private getAssignmentProperties;
     private generateConstructorCall;
     private generatePropertyAssignment;
     private generatePropertyConversion;

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

@@ -142,6 +142,24 @@ class OriginalClassGenerator {
         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);
@@ -155,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;
 }

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

@@ -50,7 +50,7 @@ class SerializerGenerator {
         this.importManager.registerCoreImports([
             'Serializer', 'SerialDescriptor', 'buildClassSerialDescriptor',
             'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'ObjectUtils',
-            'registerAutoGeneratedSerializerEntryProviderForSupplementary',
+            'registerAutoGeneratedSerializerEntryProviderForSupplementary', 'lazy',
             ...requiredBuiltinSerializers
         ]);
         this.registerDecoratorsImports(result);

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,6 +190,17 @@ 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(', ');
         });

package/dist/core/utils/DeepCopyUtil.js

@@ -128,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/SerializationPathUtil.d.ts

@@ -1,5 +1,5 @@
 import { FileUtil } from '@ohos/hvigor';
-import * as fs from "fs";
+import * as fs from 'fs';
 import { ITaskContext } from '..';
 export default class SerializationPathUtil extends FileUtil {
     static readonly sep: string;

package/dist/core/utils/TsMorphUtil.js

@@ -4,7 +4,8 @@ exports.TsMorphUtil = void 0;
 const ts_morph_1 = require("ts-morph");
 const Logger_1 = require("../logger/Logger");
 class TsMorphUtil {
-    constructor() { }
+    constructor() {
+    }
     static getProject(options) {
         if (!this.project) {
             Logger_1.Logger.info('创建ts-morph项目');

package/dist/json-plugin/JSONExecuteController.d.ts

@@ -10,4 +10,8 @@ export declare class JSONExecuteController {
     private initTasks;
     private taskCleanUp;
     private registerHvigorTasks;
+    private runTask;
+    private handleTaskError;
+    private registerCleanTaskHook;
+    private cleanGeneratedDirectory;
 }