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

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

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempSerializerGenerator = void 0;
+const __1 = require("../../..");
+const ImportManager_1 = require("../shared/ImportManager");
+const SerializerGenerator_1 = require("./SerializerGenerator");
+const SerializationPathUtil_1 = __importDefault(require("../../../utils/SerializationPathUtil"));
+const TsMorphUtil_1 = require("../../../utils/TsMorphUtil");
+class TempSerializerGenerator {
+    constructor() {
+        this.TEMP_SERIALIZER_DIR_NAME = 'tempSerializer';
+        this.context = null;
+        this.serializerFiles = new Map();
+    }
+    static getInstance() {
+        return this.INSTANCE;
+    }
+    init(context) {
+        this.context = context;
+        const tempDir = this.getTempSerializerDir();
+        if (!SerializationPathUtil_1.default.exist(tempDir)) {
+            SerializationPathUtil_1.default.ensureDirSync(tempDir);
+        }
+        this.serializerFiles.clear();
+    }
+    getTempSerializerDir() {
+        return SerializationPathUtil_1.default.pathResolve(this.context.getOutputRoot(), this.TEMP_SERIALIZER_DIR_NAME);
+    }
+    generateSerializer(classAnalysis) {
+        const uniqueKey = this.getUniqueKey(classAnalysis);
+        if (this.serializerFiles.has(uniqueKey)) {
+            return;
+        }
+        const uniqueFileName = this.generateUniqueFileName(classAnalysis);
+        const filePath = SerializationPathUtil_1.default.pathResolve(this.getTempSerializerDir(), uniqueFileName);
+        const sourceFile = TsMorphUtil_1.TsMorphUtil.getProject().createSourceFile(filePath, '', { overwrite: true });
+        const importManager = new ImportManager_1.ImportManager();
+        importManager.setContext(this.context);
+        this.registerImports(classAnalysis, importManager);
+        const serializerGenerator = new SerializerGenerator_1.SerializerGenerator(importManager);
+        const serializableGeneratorContext = serializerGenerator.generate(sourceFile, classAnalysis, this.context);
+        serializerGenerator.generateRegistration(sourceFile, serializableGeneratorContext);
+        const pathPrefix = this.extractPathPrefix(classAnalysis.sourceFilePath);
+        this.serializerFiles.set(uniqueKey, {
+            className: classAnalysis.className,
+            isGeneric: classAnalysis.generics.isGeneric,
+            sourceFile,
+            importManager,
+            uniqueFileName,
+            pathPrefix
+        });
+    }
+    registerImports(classAnalysis, importManager) {
+        importManager.registerCustomTypeImport(classAnalysis.sourceFilePath, classAnalysis.className);
+        let sourceFile;
+        if (classAnalysis.originalClass) {
+            sourceFile = classAnalysis.originalClass.getSourceFile();
+        }
+        else {
+            sourceFile = classAnalysis.originalInterface.getSourceFile();
+        }
+        sourceFile.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(classAnalysis.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());
+                }
+            }
+        });
+    }
+    saveFile() {
+        for (const [_, fileInfo] of this.serializerFiles) {
+            fileInfo.importManager.getImportDeclarations().forEach((importDeclaration) => {
+                fileInfo.sourceFile.addImportDeclaration({
+                    moduleSpecifier: importDeclaration.specifier,
+                    namedImports: [...new Set(importDeclaration.names)]
+                });
+            });
+            fileInfo.importManager.getDefaultImport().forEach((importDeclaration) => {
+                fileInfo.sourceFile.addImportDeclaration({
+                    moduleSpecifier: importDeclaration.specifier,
+                    defaultImport: importDeclaration.name
+                });
+            });
+            fileInfo.sourceFile.formatText();
+            fileInfo.sourceFile.saveSync();
+        }
+        this.generateIndexFile();
+    }
+    generateIndexFile() {
+        const indexFilePath = SerializationPathUtil_1.default.pathResolve(this.getTempSerializerDir(), 'index.ets');
+        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}`;
+            if (!classNameMap.has(serializerName)) {
+                classNameMap.set(serializerName, []);
+            }
+            classNameMap.get(serializerName).push(fileInfo);
+        }
+        const exportStatements = [];
+        for (const [serializerName, fileInfos] of classNameMap) {
+            if (fileInfos.length === 1) {
+                const fileInfo = fileInfos[0];
+                const importPath = `./${fileInfo.uniqueFileName.replace('.ets', '')}`;
+                exportStatements.push(`export { ${serializerName} } from '${importPath}';`);
+            }
+            else {
+                for (const fileInfo of fileInfos) {
+                    const alias = this.generateExportAlias(fileInfo);
+                    const importPath = `./${fileInfo.uniqueFileName.replace('.ets', '')}`;
+                    exportStatements.push(`export { ${serializerName} as ${alias} } from '${importPath}';`);
+                }
+            }
+        }
+        indexSourceFile.addStatements(exportStatements.join('\n'));
+        indexSourceFile.formatText();
+        indexSourceFile.saveSync();
+    }
+    generateExportAlias(fileInfo) {
+        if (!fileInfo.pathPrefix) {
+            return `${fileInfo.className}${__1.StringConstants.SERIALIZER}`;
+        }
+        const pascalPrefix = fileInfo.pathPrefix
+            .split('_')
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join('');
+        return `${pascalPrefix}${fileInfo.className}${__1.StringConstants.SERIALIZER}`;
+    }
+    generateUniqueFileName(classAnalysis) {
+        const prefix = this.extractPathPrefix(classAnalysis.sourceFilePath);
+        if (prefix) {
+            return `${prefix}_${classAnalysis.className}${__1.StringConstants.SERIALIZER}.ets`;
+        }
+        else {
+            return `${classAnalysis.className}${__1.StringConstants.SERIALIZER}.ets`;
+        }
+    }
+    extractPathPrefix(sourceFilePath) {
+        const relativePath = this.context.calculateSourceRootToModuleRoot(sourceFilePath);
+        const dirPath = SerializationPathUtil_1.default.dirname(relativePath);
+        if (dirPath === '.' || dirPath === '' || dirPath === 'ets') {
+            return '';
+        }
+        let cleanedDirPath = dirPath;
+        if (cleanedDirPath.startsWith('ets/') || cleanedDirPath.startsWith('ets\\')) {
+            cleanedDirPath = cleanedDirPath.substring(4);
+        }
+        if (cleanedDirPath === '' || cleanedDirPath === '.') {
+            return '';
+        }
+        return cleanedDirPath.replace(/[\\/]/g, '_').replace(/[^a-zA-Z0-9_]/g, '_');
+    }
+    getUniqueKey(classAnalysis) {
+        return `${classAnalysis.sourceFilePath}#${classAnalysis.className}`;
+    }
+}
+exports.TempSerializerGenerator = TempSerializerGenerator;
+TempSerializerGenerator.INSTANCE = new TempSerializerGenerator();

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

@@ -0,0 +1 @@
+export { CodeGenerationService } from './CodeGenerationService';

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGenerationService = void 0;
+var CodeGenerationService_1 = require("./CodeGenerationService");
+Object.defineProperty(exports, "CodeGenerationService", { enumerable: true, get: function () { return CodeGenerationService_1.CodeGenerationService; } });

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

@@ -0,0 +1,27 @@
+import { ITaskContext } from '../../..';
+export declare class ImportManager {
+    private imports;
+    private defaultImports;
+    private typeToModulePath;
+    private context;
+    registerCoreImports(interfaceNames: string[]): void;
+    registerJsonImports(names: string[]): void;
+    registerArkTSImports(names: string[]): void;
+    registerCustomImport(modulePath: string, importedName: string): void;
+    registerDefaultImport(modulePath: string, importedName: string): void;
+    private isModularPath;
+    private isRelativePath;
+    private removeImportFromModule;
+    getImportDeclarations(): {
+        specifier: string;
+        names: string[];
+    }[];
+    getDefaultImport(): Array<{
+        specifier: string;
+        name: string;
+    }>;
+    clear(): void;
+    setContext(context: ITaskContext): void;
+    registerCustomTypeImport(customTypeFilePath: string, typeName: string): void;
+    registerTempSerializerImport(serializerName: string): void;
+}

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

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportManager = void 0;
+const SerializationPathUtil_1 = __importDefault(require("../../../utils/SerializationPathUtil"));
+class ImportManager {
+    constructor() {
+        this.imports = new Map();
+        this.defaultImports = new Map();
+        this.typeToModulePath = new Map();
+        this.context = null;
+    }
+    registerCoreImports(interfaceNames) {
+        const coreModule = '@hadss/turbo-trans-core';
+        for (const interfaceName of interfaceNames) {
+            this.registerCustomImport(coreModule, interfaceName);
+        }
+    }
+    registerJsonImports(names) {
+        const jsonModule = '@hadss/turbo-trans-json';
+        for (const name of names) {
+            this.registerCustomImport(jsonModule, name);
+        }
+    }
+    registerArkTSImports(names) {
+        const arkTSModule = '@kit.ArkTS';
+        for (const name of names) {
+            this.registerCustomImport(arkTSModule, name);
+        }
+    }
+    registerCustomImport(modulePath, importedName) {
+        if (this.typeToModulePath.has(importedName)) {
+            const existingModulePath = this.typeToModulePath.get(importedName);
+            if (this.isModularPath(modulePath) && this.isRelativePath(existingModulePath)) {
+                this.removeImportFromModule(existingModulePath, importedName);
+                this.typeToModulePath.set(importedName, modulePath);
+            }
+            else if (this.isRelativePath(modulePath) && this.isModularPath(existingModulePath)) {
+                return;
+            }
+        }
+        else {
+            this.typeToModulePath.set(importedName, modulePath);
+        }
+        if (this.imports.has(modulePath)) {
+            const existingInfo = this.imports.get(modulePath);
+            const names = new Set(existingInfo.importedNames);
+            names.add(importedName);
+            this.imports.set(modulePath, {
+                ...existingInfo,
+                importedNames: Array.from(names)
+            });
+        }
+        else {
+            this.imports.set(modulePath, {
+                modulePath,
+                importedNames: [importedName],
+                isDefaultImport: false,
+                isNamespaceImport: false
+            });
+        }
+    }
+    registerDefaultImport(modulePath, importedName) {
+        if (this.defaultImports.has(modulePath)) {
+            return;
+        }
+        this.defaultImports.set(modulePath, importedName);
+    }
+    isModularPath(modulePath) {
+        return !modulePath.startsWith('.') &&
+            !modulePath.startsWith('/') &&
+            !modulePath.startsWith('@') &&
+            modulePath.includes('/');
+    }
+    isRelativePath(modulePath) {
+        return modulePath.startsWith('./') || modulePath.startsWith('../');
+    }
+    removeImportFromModule(modulePath, importedName) {
+        if (this.imports.has(modulePath)) {
+            const existingInfo = this.imports.get(modulePath);
+            const filteredNames = existingInfo.importedNames.filter(name => name !== importedName);
+            if (filteredNames.length === 0) {
+                this.imports.delete(modulePath);
+            }
+            else {
+                this.imports.set(modulePath, {
+                    ...existingInfo,
+                    importedNames: filteredNames
+                });
+            }
+        }
+    }
+    getImportDeclarations() {
+        const imports = [];
+        for (const [specifier, infos] of this.imports) {
+            imports.push({ specifier: specifier, names: infos.importedNames });
+        }
+        return imports;
+    }
+    getDefaultImport() {
+        const defaultImports = [];
+        for (const [specifier, info] of this.defaultImports) {
+            defaultImports.push({ specifier: specifier, name: info });
+        }
+        return defaultImports;
+    }
+    clear() {
+        this.imports.clear();
+        this.typeToModulePath.clear();
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    registerCustomTypeImport(customTypeFilePath, typeName) {
+        const modularImportPath = SerializationPathUtil_1.default.calculateModularImportPath(customTypeFilePath, this.context);
+        this.registerCustomImport(modularImportPath, typeName);
+    }
+    registerTempSerializerImport(serializerName) {
+        const outputRoot = this.context.getOutputRoot();
+        const tempSerializerPath = SerializationPathUtil_1.default.pathResolve(outputRoot, 'tempSerializer');
+        const modularImportPath = SerializationPathUtil_1.default.calculateModularImportPath(tempSerializerPath, this.context);
+        this.registerCustomImport(modularImportPath, serializerName);
+    }
+}
+exports.ImportManager = ImportManager;

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

@@ -0,0 +1,26 @@
+import * as Handlebars from 'handlebars';
+import { GenerationContext } from '..';
+export declare class HandlebarsTemplateEngine {
+    private serializationTemplate?;
+    private serializationRegisterTemplate?;
+    private readonly registerTemplatePath;
+    private readonly performanceTemplatePath;
+    private readonly strictTemplatePath;
+    private readonly commonTemplatePath;
+    constructor();
+    render(templateName: string, context: GenerationContext): string;
+    renderRegister(context: GenerationContext): string;
+    registerTemplate(): void;
+    registerHelper(name: string, helper: Handlebars.HelperDelegate): void;
+    loadTemplateFromString(template: string): HandlebarsTemplateDelegate;
+    private registerBuiltinHelpers;
+    private registerComparisonHelpers;
+    private registerTypeCheckHelpers;
+    private hasNonSerializableClassDecorator;
+    private hasNonSerializablePropertyDecorators;
+    private isPropertyValidForDirectReturn;
+    private registerFormattingHelpers;
+    private registerPropertyAnalysisHelpers;
+    private registerConstructorHelpers;
+    private registerLogicHelpers;
+}

package/dist/core/template/HandlebarsTemplateEngine.js

@@ -0,0 +1,226 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandlebarsTemplateEngine = void 0;
+const Handlebars = __importStar(require("handlebars"));
+const __1 = require("..");
+const SerializationPathUtil_1 = __importDefault(require("../utils/SerializationPathUtil"));
+const CustomError_1 = require("../utils/CustomError");
+class HandlebarsTemplateEngine {
+    constructor() {
+        this.registerTemplatePath = SerializationPathUtil_1.default.pathResolve(__dirname, '../../../template/SerializerRegisterTemplate.hbs');
+        this.performanceTemplatePath = SerializationPathUtil_1.default.pathResolve(__dirname, '../../../template/SerializerPerformanceTemplate.hbs');
+        this.strictTemplatePath = SerializationPathUtil_1.default.pathResolve(__dirname, '../../../template/SerializerStrictTemplate.hbs');
+        this.commonTemplatePath = SerializationPathUtil_1.default.pathResolve(__dirname, '../../../template/SerializerTemplate.hbs');
+        this.registerBuiltinHelpers();
+        this.registerTemplate();
+    }
+    render(templateName, context) {
+        const template = this.serializationTemplate;
+        if (!template) {
+            throw new CustomError_1.CustomError(`Template '${templateName}' not found.`, CustomError_1.ErrorCodes.TEMPLATE_NOT_FOUND);
+        }
+        return template({ deserializeTemplate: templateName, ...context });
+    }
+    renderRegister(context) {
+        const template = this.serializationRegisterTemplate;
+        if (!template) {
+            throw new CustomError_1.CustomError(`Template not found.`, CustomError_1.ErrorCodes.TEMPLATE_NOT_FOUND);
+        }
+        return template(context);
+    }
+    registerTemplate() {
+        try {
+            const performanceTemplateContent = SerializationPathUtil_1.default.readFileSync(this.performanceTemplatePath).toString();
+            Handlebars.registerPartial(__1.DeserializationMode.PERFORMANCE, performanceTemplateContent);
+            const strictTemplateContent = SerializationPathUtil_1.default.readFileSync(this.strictTemplatePath).toString();
+            Handlebars.registerPartial(__1.DeserializationMode.STRICT, strictTemplateContent);
+            const commonTemplateContent = SerializationPathUtil_1.default.readFileSync(this.commonTemplatePath).toString();
+            this.serializationTemplate = this.loadTemplateFromString(commonTemplateContent);
+            const registerTemplateContent = SerializationPathUtil_1.default.readFileSync(this.registerTemplatePath).toString();
+            this.serializationRegisterTemplate = this.loadTemplateFromString(registerTemplateContent);
+        }
+        catch (error) {
+            throw new CustomError_1.CustomError(`Failed to register template ${error instanceof Error ? error.message : String(error)}`, CustomError_1.ErrorCodes.TEMPLATE_REGISTER_FAIL);
+        }
+    }
+    registerHelper(name, helper) {
+        Handlebars.registerHelper(name, helper);
+    }
+    loadTemplateFromString(template) {
+        return Handlebars.compile(template, { noEscape: true });
+    }
+    registerBuiltinHelpers() {
+        this.registerComparisonHelpers();
+        this.registerTypeCheckHelpers();
+        this.registerFormattingHelpers();
+        this.registerPropertyAnalysisHelpers();
+        this.registerConstructorHelpers();
+        this.registerLogicHelpers();
+    }
+    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);
+        });
+        this.registerHelper('eqEmptyType', (kind) => {
+            return ['null', 'undefined'].includes(kind);
+        });
+    }
+    registerTypeCheckHelpers() {
+        this.registerHelper('isNumericPropertyName', (propertyName) => {
+            return /^\d+$/.test(propertyName);
+        });
+        this.registerHelper('containsUndefined', (typeText) => {
+            return typeText.includes('undefined');
+        });
+        this.registerHelper('canReturnDirectly', (classAnalysis) => {
+            if (this.hasNonSerializableClassDecorator(classAnalysis)) {
+                return false;
+            }
+            if (this.hasNonSerializablePropertyDecorators(classAnalysis)) {
+                return false;
+            }
+            const properties = classAnalysis.properties;
+            if (!Array.isArray(properties)) {
+                return false;
+            }
+            return properties.every(prop => this.isPropertyValidForDirectReturn(prop));
+        });
+        this.registerHelper('isClassType', (cls) => {
+            return !!cls.originalClass;
+        });
+    }
+    hasNonSerializableClassDecorator(classAnalysis) {
+        const classDecorators = classAnalysis.originalClass?.getDecorators() || [];
+        return classDecorators.some(decorator => decorator.getName() !== 'Serializable');
+    }
+    hasNonSerializablePropertyDecorators(classAnalysis) {
+        const props = classAnalysis.originalClass?.getProperties();
+        if (!props || !Array.isArray(props)) {
+            return false;
+        }
+        for (const prop of props) {
+            const decorators = prop.getDecorators();
+            if (decorators && Array.isArray(decorators)) {
+                const hasNonSerializableDecorator = decorators.some(decorator => !__1.DecoratorConstants.SERIAL_DECORATORS.includes(decorator.getName()));
+                if (hasNonSerializableDecorator) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    isPropertyValidForDirectReturn(prop) {
+        if (prop.decorators?.isTransient) {
+            return false;
+        }
+        if (prop.decorators?.serialName && prop.decorators.serialName !== prop.name) {
+            return false;
+        }
+        if (prop.decorators?.with) {
+            return false;
+        }
+        const kind = prop.type?.kind;
+        const primitives = ['null', 'boolean', 'number', 'string', 'bigint'];
+        if (!primitives.includes(kind)) {
+            return false;
+        }
+        if (kind === 'undefined' || kind === 'null') {
+            return false;
+        }
+        if (kind === __1.PropertyKind.UNION) {
+            return false;
+        }
+        return true;
+    }
+    registerFormattingHelpers() {
+        this.registerHelper('formatGenericArgs', (args) => {
+            return Array.isArray(args) && args.length > 0 ? `<${args.join(', ')}>` : '';
+        });
+        this.registerHelper('formatPropertyName', (property) => {
+            return property.decorators?.serialName || property.name;
+        });
+        this.registerHelper('toLowerCase', (str) => {
+            return str.toLowerCase();
+        });
+        this.registerHelper('genericParametersString', (parameters) => {
+            return parameters.join(', ');
+        });
+        this.registerHelper('genericParametersESObjString', (parameters) => {
+            return parameters.map(() => 'ESObject').join(', ');
+        });
+    }
+    registerPropertyAnalysisHelpers() {
+        this.registerHelper('getPropertyIndex', (property, properties) => {
+            return properties.findIndex(p => p.analysis.name === property.analysis.name);
+        });
+        this.registerHelper('postConstructorAssignments', (constructorParam, properties) => {
+            return properties?.filter(prop => {
+                return !constructorParam?.some((cp) => cp.name === prop.analysis.name);
+            });
+        });
+    }
+    registerConstructorHelpers() {
+        this.registerHelper('getCtorProperties', (constructorParam, properties) => {
+            return constructorParam?.map(param => {
+                const prop = properties?.find(p => p.analysis.name === param.name);
+                if (!prop) {
+                    return null;
+                }
+                return prop;
+            }).filter(p => p !== null);
+        });
+    }
+    registerLogicHelpers() {
+        this.registerHelper('and', (...args) => {
+            const values = args.slice(0, -1);
+            return values.every(val => !!val);
+        });
+        this.registerHelper('not', (value) => {
+            return !value;
+        });
+        this.registerHelper('hasDecoratorWith', (decorators) => {
+            return !!(decorators?.with);
+        });
+    }
+}
+exports.HandlebarsTemplateEngine = HandlebarsTemplateEngine;

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

@@ -0,0 +1,10 @@
+import { TurboTransJsonPluginOptions, ImportRewriteOptions } from '..';
+export declare class ConfigManager {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): ConfigManager;
+    setConfig(config: TurboTransJsonPluginOptions): void;
+    getConfig(): TurboTransJsonPluginOptions;
+    getImportRewriteConfig(): ImportRewriteOptions;
+}

package/dist/core/utils/ConfigManager.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const __1 = require("..");
+class ConfigManager {
+    constructor() {
+        this.config = null;
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    getConfig() {
+        return this.config || {
+            ignoreModuleNames: [],
+            scanDir: __1.PathConstants.DEFAULT_SCAN_DIRS,
+            deserializationMode: __1.DeserializationMode.PERFORMANCE,
+        };
+    }
+    getImportRewriteConfig() {
+        return this.config?.importRewrite || {
+            scanPaths: ['src/main/ets'],
+            preserveOriginalImports: false
+        };
+    }
+}
+exports.ConfigManager = ConfigManager;

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

@@ -0,0 +1,30 @@
+export declare class CustomError extends Error {
+    name: string;
+    code: ErrorCodes;
+    constructor(message: string, code: ErrorCodes);
+}
+export declare enum ErrorCodes {
+    INTERNAL_ERROR = 3000,
+    TEMPLATE_NOT_FOUND = 3011,
+    TEMPLATE_REGISTER_FAIL = 3012,
+    ROOT_DIRECTROY_NOT_FOUND = 3021,
+    INVALID_OUTPUT_FAIL = 3022,
+    INVALID_FILE_CONTENT = 3023,
+    HANDLER_NOT_FOUND = 3031,
+    CLASS_DECLARATION_NOT_FOUND = 3032,
+    IS_NOT_ENUM = 3033,
+    ENUM_STRUCTURE_NOT_FOUND = 3034,
+    TYPE_NOT_SUPPORT = 3041,
+    LITERAL_NOT_SOPPORT = 3042,
+    TRANSIENT_ATTR_OPTIONAL = 3043,
+    ANNOTATION_CONFLICT = 3044,
+    UNEXPECTED_GENERIC = 3051,
+    GENERIC_NOT_MATCH = 3052,
+    UNION_STRUCTURE_NOT_FOUND = 3061,
+    UNION_EXPEDTED_TWO = 3062,
+    UNION_INNER_NOT_FOUND = 3063,
+    UNION_UNSUPPORTED_PATTERN = 3064,
+    UNION_EXPEDTED_THREE = 3065,
+    REWRITE_IMPORT_FAIL = 3071,
+    NOT_SENDABLE = 3072
+}