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

package/dist/core/import-rewrite/services/BuildProfileUpdater.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildProfileUpdaterImpl = void 0;
+const __1 = require("../..");
+const SerializationPathUtil_1 = __importDefault(require("../../utils/SerializationPathUtil"));
+class BuildProfileUpdaterImpl {
+    updateSourceRoots(targetContext) {
+        try {
+            const moduleRoot = this.getModuleRootFromContext(targetContext);
+            const buildProfilePath = SerializationPathUtil_1.default.join(moduleRoot, 'build-profile.json5');
+            __1.Logger.debug(`准备更新 build-profile.json5: ${buildProfilePath}`);
+            if (!SerializationPathUtil_1.default.exist(buildProfilePath)) {
+                __1.Logger.warn(`build-profile.json5 文件不存在: ${buildProfilePath}`);
+                return;
+            }
+            const config = targetContext.context.buildProfileOpt;
+            __1.Logger.debug(`当前配置: ${JSON.stringify(config, null, 2)}`);
+            const updated = this.updateSourceRootsConfig(config);
+            if (updated) {
+                this.writeBuildProfile(targetContext, buildProfilePath, config);
+                __1.Logger.info(`已更新 build-profile.json5 的 sourceRoots 配置: ${buildProfilePath}`);
+            }
+            else {
+                __1.Logger.debug('sourceRoots 配置无需更新');
+            }
+        }
+        catch (error) {
+            __1.Logger.error(`更新 build-profile.json5 失败: ${error}`);
+            throw error;
+        }
+    }
+    getModuleRootFromContext(context) {
+        const outputRoot = context.getOutputRoot();
+        let currentDir = SerializationPathUtil_1.default.dirname(outputRoot);
+        while (currentDir && currentDir !== SerializationPathUtil_1.default.dirname(currentDir)) {
+            const buildProfilePath = SerializationPathUtil_1.default.join(currentDir, 'build-profile.json5');
+            if (SerializationPathUtil_1.default.exist(buildProfilePath)) {
+                return currentDir;
+            }
+            currentDir = SerializationPathUtil_1.default.dirname(currentDir);
+        }
+        return SerializationPathUtil_1.default.dirname(SerializationPathUtil_1.default.dirname(outputRoot));
+    }
+    readBuildProfile(buildProfilePath) {
+        try {
+            return SerializationPathUtil_1.default.readJson5(buildProfilePath);
+        }
+        catch (error) {
+            __1.Logger.error(`读取 build-profile.json5 失败: ${buildProfilePath}, 错误: ${error}`);
+            throw new Error(`无法读取配置文件: ${buildProfilePath}`);
+        }
+    }
+    writeBuildProfile(targetContext, buildProfilePath, config) {
+        try {
+            targetContext.context.moduleContext.setBuildProfileOpt(config);
+        }
+        catch (error) {
+            __1.Logger.error(`写入 build-profile.json5 失败: ${buildProfilePath}, 错误: ${error}`);
+            throw new Error(`无法写入配置文件: ${buildProfilePath}`);
+        }
+    }
+    updateSourceRootsConfig(config) {
+        let updated = false;
+        const generatedSourceRoot = "./src/generated";
+        __1.Logger.info(`target.source.sourceRoots start`);
+        if (config.targets && Array.isArray(config.targets)) {
+            for (const target of config.targets) {
+                __1.Logger.info(`target.source.sourceRoots is target: ${target}`);
+                if (!target.source) {
+                    target.source = {};
+                }
+                if (!target.source.sourceRoots) {
+                    target.source.sourceRoots = [];
+                }
+                if (!Array.isArray(target.source.sourceRoots)) {
+                    __1.Logger.warn('target.source.sourceRoots 不是数组，将重置为数组');
+                    target.source.sourceRoots = [];
+                }
+                if (!target.source.sourceRoots.includes(generatedSourceRoot)) {
+                    target.source.sourceRoots.unshift(generatedSourceRoot);
+                    __1.Logger.info(`添加 target.source.sourceRoots: ${generatedSourceRoot}`);
+                    updated = true;
+                }
+            }
+        }
+        return updated;
+    }
+}
+exports.BuildProfileUpdaterImpl = BuildProfileUpdaterImpl;

package/dist/core/import-rewrite/services/ImportRewriteService.d.ts

@@ -0,0 +1,9 @@
+import { ITaskContext, ImportRewriteOptions } from '../..';
+import { GeneratedFileInfo, ImportRewriteService as IImportRewriteService } from '../types/ImportRewriteTypes';
+export declare class ImportRewriteServiceImpl implements IImportRewriteService {
+    private readonly transformService;
+    constructor();
+    rewriteImports(context: ITaskContext, generatedFileInfos: GeneratedFileInfo[], options: ImportRewriteOptions): void;
+    private scanFilesWithModelImports;
+    private shouldCheckFile;
+}

package/dist/core/import-rewrite/services/ImportRewriteService.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportRewriteServiceImpl = void 0;
+const __1 = require("../..");
+const ImportTransformService_1 = require("./ImportTransformService");
+const SerializationPathUtil_1 = __importDefault(require("../../utils/SerializationPathUtil"));
+class ImportRewriteServiceImpl {
+    constructor() {
+        this.transformService = new ImportTransformService_1.ImportTransformServiceImpl();
+    }
+    rewriteImports(context, generatedFileInfos, options) {
+        const filesToUpdate = this.scanFilesWithModelImports(options.scanPaths, generatedFileInfos, context);
+        if (filesToUpdate.length === 0) {
+            __1.Logger.info('未找到需要重写导入的文件');
+            return;
+        }
+        __1.Logger.info(`找到 ${filesToUpdate.length} 个文件需要重写导入`);
+        let successCount = 0;
+        let errorCount = 0;
+        for (const filePath of filesToUpdate) {
+            try {
+                this.transformService.rewriteFileImports(filePath, context, generatedFileInfos, options.preserveOriginalImports);
+                successCount++;
+            }
+            catch (error) {
+                errorCount++;
+            }
+        }
+        __1.Logger.info(`导入重写完成: 成功 ${successCount} 个，失败 ${errorCount} 个`);
+    }
+    scanFilesWithModelImports(scanPaths, generatedFileInfos, context) {
+        const filesToUpdate = [];
+        for (const scanPath of scanPaths) {
+            const absoluteScanPath = SerializationPathUtil_1.default.isAbsolute(scanPath)
+                ? scanPath
+                : SerializationPathUtil_1.default.pathResolve(context.getModulePath(), scanPath);
+            if (!SerializationPathUtil_1.default.exist(absoluteScanPath)) {
+                __1.Logger.warn(`扫描路径不存在: ${absoluteScanPath}`);
+                continue;
+            }
+            const files = SerializationPathUtil_1.default.scanEtsFiles(absoluteScanPath);
+            for (const filePath of files) {
+                if (this.shouldCheckFile(filePath, generatedFileInfos)) {
+                    filesToUpdate.push(filePath);
+                }
+            }
+        }
+        const IndexFilePath = SerializationPathUtil_1.default.pathResolve(context.getModulePath(), 'Index.ets');
+        if (SerializationPathUtil_1.default.exist(IndexFilePath)) {
+            filesToUpdate.push(IndexFilePath);
+        }
+        return filesToUpdate;
+    }
+    shouldCheckFile(filePath, generatedFileInfos) {
+        return !generatedFileInfos.some(info => filePath.startsWith(SerializationPathUtil_1.default.dirname(info.generatedFilePath)));
+    }
+}
+exports.ImportRewriteServiceImpl = ImportRewriteServiceImpl;

package/dist/core/import-rewrite/services/ImportTransformService.d.ts

@@ -0,0 +1,15 @@
+import { ITaskContext } from '../..';
+import { GeneratedFileInfo, ImportTransformService } from '../types/ImportRewriteTypes';
+export declare class ImportTransformServiceImpl implements ImportTransformService {
+    private readonly scanStrategy;
+    constructor();
+    rewriteFileImports(filePath: string, context: ITaskContext, generatedFileInfos: GeneratedFileInfo[], preserveOriginalImports?: boolean): void;
+    private processImportDeclarations;
+    private processExportDeclarations;
+    private rewriteSingleExport;
+    private rewriteSingleImport;
+    private replaceWithCommentedOriginal;
+    private handleRewriteResult;
+    private handleRewriteError;
+    private escapeRegExp;
+}

package/dist/core/import-rewrite/services/ImportTransformService.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportTransformServiceImpl = void 0;
+const __1 = require("../..");
+const ImportScanStrategy_1 = require("../strategies/ImportScanStrategy");
+const SerializationPathUtil_1 = __importDefault(require("../../utils/SerializationPathUtil"));
+const CustomError_1 = require("../../utils/CustomError");
+const TsMorphUtil_1 = require("../../utils/TsMorphUtil");
+class ImportTransformServiceImpl {
+    constructor() {
+        this.scanStrategy = new ImportScanStrategy_1.ImportScanStrategyImpl();
+    }
+    rewriteFileImports(filePath, context, generatedFileInfos, preserveOriginalImports = false) {
+        try {
+            const sourceFile = TsMorphUtil_1.TsMorphUtil.getProject().addSourceFileAtPath(filePath);
+            const importRewriteCount = this.processImportDeclarations(sourceFile, context, generatedFileInfos, preserveOriginalImports);
+            const exportRewriteCount = this.processExportDeclarations(sourceFile, context, generatedFileInfos, preserveOriginalImports);
+            const totalRewriteCount = importRewriteCount + exportRewriteCount;
+            this.handleRewriteResult(sourceFile, filePath, totalRewriteCount);
+        }
+        catch (error) {
+            this.handleRewriteError(error, filePath);
+            throw error;
+        }
+    }
+    processImportDeclarations(sourceFile, context, generatedFileInfos, preserveOriginalImports) {
+        const importDeclarations = sourceFile.getImportDeclarations();
+        let rewriteCount = 0;
+        for (const importDecl of importDeclarations) {
+            const matchedInfo = this.scanStrategy.shouldRewriteImport(importDecl, sourceFile.getFilePath(), generatedFileInfos, context);
+            if (matchedInfo) {
+                this.rewriteSingleImport(importDecl, context, matchedInfo, preserveOriginalImports);
+                rewriteCount++;
+            }
+        }
+        return rewriteCount;
+    }
+    processExportDeclarations(sourceFile, context, generatedFileInfos, preserveOriginalImports) {
+        const exportDeclarations = sourceFile.getExportDeclarations();
+        let rewriteCount = 0;
+        for (const exportDecl of exportDeclarations) {
+            const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+            if (!moduleSpecifier) {
+                continue;
+            }
+            const matchedInfo = this.scanStrategy.shouldRewriteExport(moduleSpecifier, sourceFile.getFilePath(), generatedFileInfos, context);
+            if (matchedInfo) {
+                this.rewriteSingleExport(exportDecl, context, matchedInfo, preserveOriginalImports);
+                rewriteCount++;
+            }
+        }
+        return rewriteCount;
+    }
+    rewriteSingleExport(exportDecl, context, matchedInfo, preserveOriginalImports) {
+        const originalModuleSpecifier = exportDecl.getModuleSpecifierValue();
+        if (!originalModuleSpecifier) {
+            return;
+        }
+        const newModuleSpecifier = SerializationPathUtil_1.default.calculateModularImportPath(matchedInfo.generatedFilePath, context);
+        if (preserveOriginalImports) {
+            this.replaceWithCommentedOriginal(exportDecl, originalModuleSpecifier, newModuleSpecifier);
+        }
+        else {
+            exportDecl.setModuleSpecifier(newModuleSpecifier);
+        }
+    }
+    rewriteSingleImport(importDecl, context, matchedInfo, preserveOriginalImports) {
+        const originalModuleSpecifier = importDecl.getModuleSpecifierValue();
+        const newModuleSpecifier = SerializationPathUtil_1.default.calculateModularImportPath(matchedInfo.generatedFilePath, context);
+        if (preserveOriginalImports) {
+            this.replaceWithCommentedOriginal(importDecl, originalModuleSpecifier, newModuleSpecifier);
+        }
+        else {
+            importDecl.setModuleSpecifier(newModuleSpecifier);
+        }
+    }
+    replaceWithCommentedOriginal(importDecl, originalModuleSpecifier, newModuleSpecifier) {
+        const originalImportText = importDecl.getFullText().trim();
+        const commentedOriginal = `// ${originalImportText}`;
+        const newImportText = importDecl
+            .getFullText()
+            .replace(new RegExp(`(['"]?)${this.escapeRegExp(originalModuleSpecifier)}\\1`, 'g'), `'${newModuleSpecifier}'`);
+        importDecl.replaceWithText(`${commentedOriginal}\n${newImportText.trim()}`);
+    }
+    handleRewriteResult(sourceFile, filePath, rewriteCount) {
+        if (rewriteCount > 0) {
+            sourceFile.saveSync();
+            __1.Logger.info(`文件 ${filePath} 重写了 ${rewriteCount} 个导入语句`);
+        }
+        sourceFile.forget();
+    }
+    handleRewriteError(error, filePath) {
+        if (error instanceof Error) {
+            __1.Logger.error(`Error: ${error.constructor.name}: ${CustomError_1.ErrorCodes.REWRITE_IMPORT_FAIL}`);
+            __1.Logger.error(`Error Message: 重写文件导入失败: ${filePath}`);
+            __1.Logger.error(`错误信息: ${error.message}\n${error.stack}`);
+        }
+        else {
+            __1.Logger.error(`重写文件导入失败: ${filePath}, 未知错误: ${error}`);
+        }
+    }
+    escapeRegExp(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+exports.ImportTransformServiceImpl = ImportTransformServiceImpl;

package/dist/core/import-rewrite/strategies/ImportScanStrategy.d.ts

@@ -0,0 +1,17 @@
+import { ImportDeclaration } from 'ts-morph';
+import { ITaskContext } from '../..';
+import { GeneratedFileInfo, ImportScanStrategy } from '../types/ImportRewriteTypes';
+export declare class ImportScanStrategyImpl implements ImportScanStrategy {
+    shouldRewriteImport(importDeclaration: ImportDeclaration, currentFilePath: string, generatedFileInfos: GeneratedFileInfo[], context: ITaskContext): GeneratedFileInfo | null;
+    shouldRewriteExport(moduleSpecifier: string, currentFilePath: string, generatedFileInfos: GeneratedFileInfo[], context: ITaskContext): GeneratedFileInfo | null;
+    private resolveModuleSpecifier;
+    private resolveModularImportToSourceFile;
+    private extractFilePathFromModularImport;
+    private isPathSuffix;
+    private removeFileExtension;
+    private isTypeDefinitionFile;
+    private isRelativeImport;
+    private resolveImportPath;
+    private pathMatches;
+    private extractImportedTypes;
+}

package/dist/core/import-rewrite/strategies/ImportScanStrategy.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportScanStrategyImpl = void 0;
+const Logger_1 = require("../../logger/Logger");
+const constants_1 = require("../../constants");
+const SerializationPathUtil_1 = __importDefault(require("../../utils/SerializationPathUtil"));
+class ImportScanStrategyImpl {
+    shouldRewriteImport(importDeclaration, currentFilePath, generatedFileInfos, context) {
+        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+        const importedTypes = this.extractImportedTypes(importDeclaration);
+        if (this.isTypeDefinitionFile(currentFilePath, generatedFileInfos)) {
+            return null;
+        }
+        const matchedInfo = this.resolveModuleSpecifier(moduleSpecifier, currentFilePath, generatedFileInfos, context);
+        if (matchedInfo) {
+            const matchedTypes = importedTypes.filter(typeName => matchedInfo.classNames.has(typeName));
+            if (matchedTypes.length > 0) {
+                return matchedInfo;
+            }
+        }
+        return null;
+    }
+    shouldRewriteExport(moduleSpecifier, currentFilePath, generatedFileInfos, context) {
+        if (!moduleSpecifier) {
+            return null;
+        }
+        if (this.isTypeDefinitionFile(currentFilePath, generatedFileInfos)) {
+            return null;
+        }
+        return this.resolveModuleSpecifier(moduleSpecifier, currentFilePath, generatedFileInfos, context);
+    }
+    resolveModuleSpecifier(moduleSpecifier, currentFilePath, generatedFileInfos, context) {
+        if (this.isRelativeImport(moduleSpecifier)) {
+            const resolvedSourcePath = this.resolveImportPath(moduleSpecifier, currentFilePath);
+            for (const generatedInfo of generatedFileInfos) {
+                if (this.pathMatches(resolvedSourcePath, generatedInfo.sourceFilePath)) {
+                    return generatedInfo;
+                }
+            }
+            return null;
+        }
+        return this.resolveModularImportToSourceFile(moduleSpecifier, generatedFileInfos, context);
+    }
+    resolveModularImportToSourceFile(moduleSpecifier, generatedFileInfos, context) {
+        const filePath = this.extractFilePathFromModularImport(moduleSpecifier);
+        if (!filePath) {
+            return null;
+        }
+        for (const info of generatedFileInfos) {
+            const sourceFileRelativePath = context.calculateSourceRootToModuleRoot(info.sourceFilePath);
+            const pathWithoutExtension = this.removeFileExtension(sourceFileRelativePath);
+            const normalizedSourcePath = pathWithoutExtension.replaceAll(SerializationPathUtil_1.default.sep, '/');
+            if (this.isPathSuffix(filePath, normalizedSourcePath)) {
+                Logger_1.Logger.debug(`模块化导入 '${moduleSpecifier}' 匹配源文件: ${info.sourceFilePath}`);
+                return info;
+            }
+        }
+        return null;
+    }
+    extractFilePathFromModularImport(moduleSpecifier) {
+        const parts = moduleSpecifier.split('/');
+        if (parts.length < 2) {
+            return null;
+        }
+        let filePathStartIndex = 1;
+        if (parts[0].startsWith('@')) {
+            filePathStartIndex = 2;
+        }
+        if (filePathStartIndex >= parts.length) {
+            return null;
+        }
+        return parts.slice(filePathStartIndex).join('/');
+    }
+    isPathSuffix(shortPath, fullPath) {
+        const shortParts = shortPath.split('/').filter(p => p.length > 0);
+        const fullParts = fullPath.split('/').filter(p => p.length > 0);
+        if (shortParts.length > fullParts.length) {
+            return false;
+        }
+        const offset = fullParts.length - shortParts.length;
+        for (let i = 0; i < shortParts.length; i++) {
+            if (shortParts[i] !== fullParts[offset + i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    removeFileExtension(filePath) {
+        const lastDotIndex = filePath.lastIndexOf('.');
+        if (lastDotIndex > 0) {
+            return filePath.substring(0, lastDotIndex);
+        }
+        return filePath;
+    }
+    isTypeDefinitionFile(filePath, generatedFileInfos) {
+        return generatedFileInfos.some(info => info.sourceFilePath === filePath);
+    }
+    isRelativeImport(moduleSpecifier) {
+        return moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../');
+    }
+    resolveImportPath(moduleSpecifier, currentFilePath) {
+        if (this.isRelativeImport(moduleSpecifier)) {
+            const currentDir = SerializationPathUtil_1.default.dirname(currentFilePath);
+            const resolvedPath = SerializationPathUtil_1.default.pathResolve(currentDir, moduleSpecifier);
+            if (!SerializationPathUtil_1.default.extname(resolvedPath)) {
+                return resolvedPath + constants_1.PathConstants.ETS_EXTENSIONS;
+            }
+            return resolvedPath;
+        }
+        return moduleSpecifier;
+    }
+    pathMatches(resolvedPath, sourcePath) {
+        const normalizedResolved = SerializationPathUtil_1.default.pathResolve(resolvedPath);
+        const normalizedSource = SerializationPathUtil_1.default.pathResolve(sourcePath);
+        return normalizedResolved === normalizedSource;
+    }
+    extractImportedTypes(importDeclaration) {
+        const importedTypes = [];
+        const namedImports = importDeclaration.getNamedImports();
+        for (const namedImport of namedImports) {
+            importedTypes.push(namedImport.getName());
+        }
+        const defaultImport = importDeclaration.getDefaultImport();
+        if (defaultImport) {
+            importedTypes.push(defaultImport.getText());
+        }
+        const namespaceImport = importDeclaration.getNamespaceImport();
+        if (namespaceImport) {
+            Logger_1.Logger.warn(`跳过命名空间导入: ${namespaceImport.getText()}`);
+        }
+        return importedTypes;
+    }
+}
+exports.ImportScanStrategyImpl = ImportScanStrategyImpl;

package/dist/core/import-rewrite/types/ImportRewriteTypes.d.ts

@@ -0,0 +1,17 @@
+import { ImportDeclaration } from 'ts-morph';
+import { ITaskContext, ImportRewriteOptions } from '../..';
+export interface GeneratedFileInfo {
+    sourceFilePath: string;
+    generatedFilePath: string;
+    classNames: Set<string>;
+}
+export interface ImportRewriteService {
+    rewriteImports(context: ITaskContext, generatedFileInfos: GeneratedFileInfo[], options: ImportRewriteOptions): void;
+}
+export interface ImportScanStrategy {
+    shouldRewriteImport(importDeclaration: ImportDeclaration, currentFilePath: string, generatedFileInfos: GeneratedFileInfo[], context: ITaskContext): GeneratedFileInfo | null;
+    shouldRewriteExport(moduleSpecifier: string, currentFilePath: string, generatedFileInfos: GeneratedFileInfo[], context: ITaskContext): GeneratedFileInfo | null;
+}
+export interface ImportTransformService {
+    rewriteFileImports(filePath: string, context: ITaskContext, generatedFileInfos: GeneratedFileInfo[], preserveOriginalImports?: boolean): void;
+}

package/dist/core/import-rewrite/types/ImportRewriteTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+export * from './interfaces';
+export * from './logger/Logger';
+export * from './constants';
+export * from './Types';
+export * from './services/CodeGenerationEngine';
+export * from './import-rewrite/types/ImportRewriteTypes';
+export * from './import-rewrite/services/ImportRewriteService';
+export * from './utils/ConfigManager';
+export { TempSerializerGenerator } from './services/CodeGenerationService/generators/TempSerializerGenerator';

package/dist/core/index.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempSerializerGenerator = void 0;
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./logger/Logger"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./Types"), exports);
+__exportStar(require("./services/CodeGenerationEngine"), exports);
+__exportStar(require("./import-rewrite/types/ImportRewriteTypes"), exports);
+__exportStar(require("./import-rewrite/services/ImportRewriteService"), exports);
+__exportStar(require("./utils/ConfigManager"), exports);
+var TempSerializerGenerator_1 = require("./services/CodeGenerationService/generators/TempSerializerGenerator");
+Object.defineProperty(exports, "TempSerializerGenerator", { enumerable: true, get: function () { return TempSerializerGenerator_1.TempSerializerGenerator; } });

package/dist/core/interfaces/ITask.d.ts

@@ -0,0 +1,7 @@
+import { ITaskContext } from './ITaskContext';
+export interface ITask {
+    readonly taskName: string;
+    readonly dependencies: string[];
+    readonly postDependencies: string[];
+    run(context: ITaskContext): void | Promise<void>;
+}

package/dist/core/interfaces/ITask.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/interfaces/ITaskContext.d.ts

@@ -0,0 +1,11 @@
+export interface ITaskContext {
+    mapToOutputPath(absSourceFile: string): string;
+    getOutputRoot(): string;
+    getModuleName(): string;
+    getModulePath(): string;
+    getPackageName(): string;
+    getRelativePath(absolutePath: string): string;
+    isValidOutputPath(outputPath: string): boolean;
+    ensureOutputDirectory(outputPath: string): void;
+    calculateSourceRootToModuleRoot(absolutePath: string): string;
+}

package/dist/core/interfaces/ITaskContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export { ITask } from './ITask';
+export { ITaskContext } from './ITaskContext';

package/dist/core/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/logger/Logger.d.ts

@@ -0,0 +1,13 @@
+export declare class Logger {
+    private static currentModule;
+    static setModuleContext(moduleName: string): void;
+    static clearModuleContext(): void;
+    static getCurrentModule(): string;
+    private static formatMessage;
+    static error(msg: string, ...args: unknown[]): void;
+    static info(msg: string, ...args: unknown[]): void;
+    static warn(msg: string, ...args: unknown[]): void;
+    static debug(msg: string, ...args: unknown[]): void;
+    static withModuleContext<T>(moduleName: string, fn: () => T): T;
+    static withModuleContextAsync<T>(moduleName: string, fn: () => Promise<T>): Promise<T>;
+}

package/dist/core/logger/Logger.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const hvigor_1 = require("@ohos/hvigor");
+const PREFIX = '[TSerialization]';
+class Logger {
+    static setModuleContext(moduleName) {
+        this.currentModule = moduleName;
+    }
+    static clearModuleContext() {
+        this.currentModule = '';
+    }
+    static getCurrentModule() {
+        return this.currentModule;
+    }
+    static formatMessage(msg) {
+        const modulePrefix = this.currentModule ? `[${this.currentModule}]` : '';
+        return `${PREFIX}${modulePrefix} ${msg}`;
+    }
+    static error(msg, ...args) {
+        const formattedMsg = this.formatMessage(msg);
+        if (args.length > 0) {
+            hvigor_1.HvigorLogger.getLogger().error(formattedMsg, ...args);
+        }
+        else {
+            hvigor_1.HvigorLogger.getLogger().error(formattedMsg);
+        }
+    }
+    static info(msg, ...args) {
+        const formattedMsg = this.formatMessage(msg);
+        if (args.length > 0) {
+            hvigor_1.HvigorLogger.getLogger().info(formattedMsg, ...args);
+        }
+        else {
+            hvigor_1.HvigorLogger.getLogger().info(formattedMsg);
+        }
+    }
+    static warn(msg, ...args) {
+        const formattedMsg = this.formatMessage(msg);
+        if (args.length > 0) {
+            hvigor_1.HvigorLogger.getLogger().warn(formattedMsg, ...args);
+        }
+        else {
+            hvigor_1.HvigorLogger.getLogger().warn(formattedMsg);
+        }
+    }
+    static debug(msg, ...args) {
+        const formattedMsg = this.formatMessage(msg);
+        if (args.length > 0) {
+            hvigor_1.HvigorLogger.getLogger().debug(formattedMsg, ...args);
+        }
+        else {
+            hvigor_1.HvigorLogger.getLogger().debug(formattedMsg);
+        }
+    }
+    static withModuleContext(moduleName, fn) {
+        const previousModule = this.currentModule;
+        try {
+            this.setModuleContext(moduleName);
+            return fn();
+        }
+        finally {
+            this.currentModule = previousModule;
+        }
+    }
+    static async withModuleContextAsync(moduleName, fn) {
+        const previousModule = this.currentModule;
+        try {
+            this.setModuleContext(moduleName);
+            return await fn();
+        }
+        finally {
+            this.currentModule = previousModule;
+        }
+    }
+}
+exports.Logger = Logger;
+Logger.currentModule = '';

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

@@ -0,0 +1,7 @@
+import { ClassAnalysis } from '..';
+export declare class CodeAnalysisService {
+    constructor();
+    analyzeFile(filePath: string): ClassAnalysis[];
+    private analyzeClass;
+    dispose(): void;
+}