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

package/dist/json-plugin/interfaces/ITargetContext.js

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

package/dist/json-plugin/interfaces/impl/ModuleContext.d.ts

@@ -0,0 +1,12 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { IModuleContext } from '../IModuleContext';
+import { OhosHapContext } from '@ohos/hvigor-ohos-plugin';
+import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile';
+export declare class ModuleContextImpl implements IModuleContext {
+    readonly node: HvigorNode;
+    readonly moduleContext: OhosHapContext;
+    readonly scanFiles: string[];
+    constructor(node: HvigorNode, moduleContext: OhosHapContext);
+    get buildProfileOpt(): ModuleBuildProfile.ModuleBuildOpt;
+    initScanFiles(scanDir: string[]): void;
+}

package/dist/json-plugin/interfaces/impl/ModuleContext.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleContextImpl = void 0;
+const SerializationPathUtil_1 = __importDefault(require("../../../core/utils/SerializationPathUtil"));
+class ModuleContextImpl {
+    constructor(node, moduleContext) {
+        this.scanFiles = [];
+        this.node = node;
+        this.moduleContext = moduleContext;
+    }
+    get buildProfileOpt() {
+        return this.moduleContext.getBuildProfileOpt();
+    }
+    initScanFiles(scanDir) {
+        scanDir.forEach(dir => {
+            const scanPath = SerializationPathUtil_1.default.pathResolve(this.moduleContext.getModulePath(), dir);
+            this.scanFiles.push(...SerializationPathUtil_1.default.scanEtsFiles(scanPath));
+        });
+    }
+}
+exports.ModuleContextImpl = ModuleContextImpl;

package/dist/json-plugin/interfaces/impl/TargetContext.d.ts

@@ -0,0 +1,23 @@
+import { Target } from '@ohos/hvigor-ohos-plugin';
+import { IModuleContext } from '../IModuleContext';
+import { ITargetContext } from '../ITargetContext';
+export declare class TargetContextImpl implements ITargetContext {
+    readonly target: Target;
+    readonly context: IModuleContext;
+    private readonly DEFAULT_SOURCE_ROOT;
+    private readonly GENERATED_ROOT;
+    constructor(target: Target, context: IModuleContext);
+    private get targetOpt();
+    getCurrentTargetScanFiles(): string[];
+    getModuleName(): string;
+    getModulePath(): string;
+    getPackageName(): string;
+    mapToOutputPath(absSourceFile: string): string;
+    getOutputRoot(): string;
+    getRelativePath(absolutePath: string): string;
+    isValidOutputPath(outputPath: string): boolean;
+    ensureOutputDirectory(outputPath: string): void;
+    calculateSourceRootToModuleRoot(absolutePath: string): string;
+    private get targetSourceRoots();
+    private getAbsoluteSourceRoots;
+}

package/dist/json-plugin/interfaces/impl/TargetContext.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetContextImpl = void 0;
+const core_1 = require("../../../core");
+const SerializationPathUtil_1 = __importDefault(require("../../../core/utils/SerializationPathUtil"));
+const CustomError_1 = require("../../../core/utils/CustomError");
+class TargetContextImpl {
+    constructor(target, context) {
+        this.DEFAULT_SOURCE_ROOT = core_1.PathConstants.DEFAULT_SOURCE_ROOT;
+        this.GENERATED_ROOT = core_1.PathConstants.GENERATED_ROOT;
+        this.target = target;
+        this.context = context;
+    }
+    get targetOpt() {
+        return this.context.buildProfileOpt.targets?.find((item) => item.name === this.target.getTargetName());
+    }
+    getCurrentTargetScanFiles() {
+        const absoluteSourceRoots = this.getAbsoluteSourceRoots();
+        return this.context.scanFiles.filter(item => {
+            const normalizedFilePath = SerializationPathUtil_1.default.normalize(item);
+            return absoluteSourceRoots.some(sourceRoot => normalizedFilePath.startsWith(sourceRoot));
+        });
+    }
+    getModuleName() {
+        return this.context.moduleContext.getModuleName();
+    }
+    getModulePath() {
+        return this.context.moduleContext.getModulePath();
+    }
+    getPackageName() {
+        const packagePath = SerializationPathUtil_1.default.pathResolve(this.getModulePath(), 'oh-package.json5');
+        const ohPackageObj = SerializationPathUtil_1.default.readJson5(packagePath);
+        return ohPackageObj.name;
+    }
+    mapToOutputPath(absSourceFile) {
+        const normalizedFilePath = SerializationPathUtil_1.default.normalize(absSourceFile);
+        const moduleRoot = this.context.moduleContext.getModulePath();
+        const srcMainAbs = SerializationPathUtil_1.default.normalize(SerializationPathUtil_1.default.pathResolve(moduleRoot, this.DEFAULT_SOURCE_ROOT));
+        const generatedRootAbs = this.getOutputRoot();
+        if (normalizedFilePath.startsWith(srcMainAbs + SerializationPathUtil_1.default.sep)) {
+            const relativeToSrcMain = SerializationPathUtil_1.default.relative(srcMainAbs, normalizedFilePath);
+            return SerializationPathUtil_1.default.join(generatedRootAbs, relativeToSrcMain);
+        }
+        const absoluteSourceRoots = this.getAbsoluteSourceRoots();
+        const matchedRoot = absoluteSourceRoots.find(root => normalizedFilePath.startsWith(root));
+        if (matchedRoot) {
+            const rel = SerializationPathUtil_1.default.relative(matchedRoot, normalizedFilePath);
+            return SerializationPathUtil_1.default.join(generatedRootAbs, rel);
+        }
+        return SerializationPathUtil_1.default.join(generatedRootAbs, SerializationPathUtil_1.default.basename(normalizedFilePath));
+    }
+    getOutputRoot() {
+        const moduleRoot = this.context.moduleContext.getModulePath();
+        const absolutePath = SerializationPathUtil_1.default.pathResolve(moduleRoot, this.GENERATED_ROOT);
+        return SerializationPathUtil_1.default.normalize(absolutePath);
+    }
+    getRelativePath(absolutePath) {
+        const outputRoot = this.getOutputRoot();
+        const moduleRoot = SerializationPathUtil_1.default.dirname(SerializationPathUtil_1.default.dirname(outputRoot));
+        try {
+            return SerializationPathUtil_1.default.relative(moduleRoot, absolutePath).replaceAll(SerializationPathUtil_1.default.sep, '/');
+        }
+        catch (error) {
+            return absolutePath;
+        }
+    }
+    isValidOutputPath(outputPath) {
+        try {
+            const outputRoot = this.getOutputRoot();
+            const resolvedOutputPath = SerializationPathUtil_1.default.pathResolve(outputPath);
+            const resolvedOutputRoot = SerializationPathUtil_1.default.pathResolve(outputRoot);
+            return resolvedOutputPath.startsWith(resolvedOutputRoot);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    ensureOutputDirectory(outputPath) {
+        SerializationPathUtil_1.default.ensureDirSync(SerializationPathUtil_1.default.dirname(outputPath));
+    }
+    calculateSourceRootToModuleRoot(absolutePath) {
+        const normalizedAbsolutePath = absolutePath.replaceAll(SerializationPathUtil_1.default.sep, '/');
+        const sourceRoots = this.getAbsoluteSourceRoots().map(root => root.replaceAll(SerializationPathUtil_1.default.sep, '/').replace(/\/$/, '') + '/');
+        const sourceRoot = sourceRoots.find(root => normalizedAbsolutePath.startsWith(root));
+        if (!sourceRoot) {
+            throw new CustomError_1.CustomError(`无法找到匹配的源根路径: ${normalizedAbsolutePath}。可用的源根路径: ${sourceRoots.join(', ')}`, CustomError_1.ErrorCodes.ROOT_DIRECTROY_NOT_FOUND);
+        }
+        const sourceRootForRelative = sourceRoot.replace(/\/$/, '');
+        const absolutePathForRelative = normalizedAbsolutePath.replace(/\/$/, '');
+        return SerializationPathUtil_1.default.relative(sourceRootForRelative, absolutePathForRelative).replaceAll(SerializationPathUtil_1.default.sep, '/');
+    }
+    get targetSourceRoots() {
+        if (!this.targetOpt.source?.sourceRoots) {
+            return [this.DEFAULT_SOURCE_ROOT];
+        }
+        if (!this.targetOpt.source.sourceRoots.includes(this.DEFAULT_SOURCE_ROOT)) {
+            return [this.DEFAULT_SOURCE_ROOT, ...this.targetOpt.source.sourceRoots];
+        }
+        return this.targetOpt.source.sourceRoots;
+    }
+    getAbsoluteSourceRoots() {
+        const moduleRoot = this.context.moduleContext.getModulePath();
+        return this.targetSourceRoots.map((sourceRoot) => {
+            const absolutePath = SerializationPathUtil_1.default.pathResolve(moduleRoot, sourceRoot);
+            const normalizedPath = SerializationPathUtil_1.default.normalize(absolutePath);
+            return normalizedPath.endsWith(SerializationPathUtil_1.default.sep) ? normalizedPath : normalizedPath + SerializationPathUtil_1.default.sep;
+        });
+    }
+}
+exports.TargetContextImpl = TargetContextImpl;

package/dist/json-plugin/tasks/BaseTask.d.ts

@@ -0,0 +1,14 @@
+import { ITask, CodeGenerationEngine } from '../../core';
+import { BuildProfileUpdaterImpl } from '../../core/import-rewrite/services/BuildProfileUpdater';
+import { ITargetContext } from '../interfaces/ITargetContext';
+export declare abstract class BaseTask implements ITask {
+    abstract readonly taskName: string;
+    abstract readonly dependencies: string[];
+    abstract readonly postDependencies: string[];
+    protected readonly engine: CodeGenerationEngine;
+    protected readonly buildProfileUpdater: BuildProfileUpdaterImpl;
+    protected getScanFiles(context: ITargetContext): string[];
+    protected processWithLogging(scanFiles: string[], context: ITargetContext, taskName: string): import("../../core").IGenerationResult;
+    protected executeImportRewrite(context: ITargetContext, taskName: string): void;
+    abstract run(context: ITargetContext): void | Promise<void>;
+}

package/dist/json-plugin/tasks/BaseTask.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTask = void 0;
+const core_1 = require("../../core");
+const BuildProfileUpdater_1 = require("../../core/import-rewrite/services/BuildProfileUpdater");
+const TaskConstants_1 = require("../constants/TaskConstants");
+const SerializationPathUtil_1 = __importDefault(require("../../core/utils/SerializationPathUtil"));
+class BaseTask {
+    constructor() {
+        this.engine = new core_1.CodeGenerationEngine();
+        this.buildProfileUpdater = new BuildProfileUpdater_1.BuildProfileUpdaterImpl();
+    }
+    getScanFiles(context) {
+        const scanFiles = context.getCurrentTargetScanFiles();
+        if (!scanFiles || scanFiles.length === 0) {
+            core_1.Logger.debug('There are no source files to be processed');
+            return [];
+        }
+        return scanFiles;
+    }
+    processWithLogging(scanFiles, context, taskName) {
+        core_1.Logger.debug(`Start executing ${taskName} and process ${scanFiles.length} files`);
+        this.buildProfileUpdater.updateSourceRoots(context);
+        const processingResult = this.engine.processFilesUnified(scanFiles, context);
+        const totalGenerated = processingResult.generatedFiles.length;
+        const totalSkipped = processingResult.skippedFiles.length;
+        core_1.Logger.info(`${taskName} completed: generate ${totalGenerated} files and skip ${totalSkipped} files`);
+        if (totalGenerated > 0 && taskName === TaskConstants_1.TaskConstants.SYNC_TASK) {
+            const config = context.context.buildProfileOpt;
+            const buildProfilePath = SerializationPathUtil_1.default.join(context.getModulePath(), 'build-profile.json5');
+            SerializationPathUtil_1.default.writeFileSync(buildProfilePath, JSON.stringify(config, null, 2));
+        }
+        this.executeImportRewrite(context, taskName);
+        return processingResult;
+    }
+    executeImportRewrite(context, taskName) {
+        const configManager = core_1.ConfigManager.getInstance();
+        core_1.Logger.debug(`Start to execute the import rewrite - ${taskName}`);
+        const generatedFileInfos = this.engine.collectGeneratedFileInfos(context);
+        if (generatedFileInfos.length === 0) {
+            core_1.Logger.debug('No file was generated. Skip the import and rewrite');
+            return;
+        }
+        const importRewriteConfig = configManager.getImportRewriteConfig();
+        const importRewriteService = new core_1.ImportRewriteServiceImpl();
+        importRewriteService.rewriteImports(context, generatedFileInfos, importRewriteConfig);
+        core_1.Logger.info(`Import and rewrite completed - ${taskName}`);
+    }
+}
+exports.BaseTask = BaseTask;

package/dist/json-plugin/tasks/CleanTask.d.ts

@@ -0,0 +1,8 @@
+import { ITask } from '../../core';
+import { ITargetContext } from '../interfaces/ITargetContext';
+export declare class CleanTask implements ITask {
+    readonly taskName: string;
+    readonly dependencies: string[];
+    readonly postDependencies: string[];
+    run(context: ITargetContext): void;
+}

package/dist/json-plugin/tasks/CleanTask.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CleanTask = void 0;
+const core_1 = require("../../core");
+const TaskConstants_1 = require("../constants/TaskConstants");
+const SerializationPathUtil_1 = __importDefault(require("../../core/utils/SerializationPathUtil"));
+class CleanTask {
+    constructor() {
+        this.taskName = TaskConstants_1.TaskConstants.CLEAN_TASK;
+        this.dependencies = [];
+        this.postDependencies = [];
+    }
+    run(context) {
+        core_1.Logger.info('Start the code cleaning task');
+        const generatedRootDir = context.getOutputRoot();
+        if (SerializationPathUtil_1.default.exist(generatedRootDir)) {
+            core_1.Logger.info(`Clean up the generated directory: ${generatedRootDir}`);
+            SerializationPathUtil_1.default.rmSync(generatedRootDir, { recursive: true, force: true });
+        }
+    }
+}
+exports.CleanTask = CleanTask;

package/dist/json-plugin/tasks/CodeProcessingTask.d.ts

@@ -0,0 +1,8 @@
+import { ITargetContext } from '../interfaces/ITargetContext';
+import { BaseTask } from './BaseTask';
+export declare class CodeProcessingTask extends BaseTask {
+    readonly taskName: string;
+    readonly dependencies: string[];
+    readonly postDependencies: string[];
+    run(context: ITargetContext): void;
+}

package/dist/json-plugin/tasks/CodeProcessingTask.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeProcessingTask = void 0;
+const core_1 = require("../../core");
+const TaskConstants_1 = require("../constants/TaskConstants");
+const BaseTask_1 = require("./BaseTask");
+class CodeProcessingTask extends BaseTask_1.BaseTask {
+    constructor() {
+        super(...arguments);
+        this.taskName = TaskConstants_1.TaskConstants.CODE_PROCESSING_TASK;
+        this.dependencies = [];
+        this.postDependencies = [TaskConstants_1.TaskConstants.PRE_BUILD_TASK];
+    }
+    run(context) {
+        const scanFiles = this.getScanFiles(context);
+        if (scanFiles.length === 0) {
+            return;
+        }
+        const processingResult = this.processWithLogging(scanFiles, context, TaskConstants_1.TaskConstants.CODE_PROCESSING_TASK);
+        const serializableClassCount = processingResult.generatedFiles.reduce((sum, file) => {
+            return sum + (file.serializerCount || 0);
+        }, 0);
+        core_1.Logger.info(`Discovered @Serializable classes: ${serializableClassCount}`);
+    }
+}
+exports.CodeProcessingTask = CodeProcessingTask;

package/dist/json-plugin/tasks/SyncTask.d.ts

@@ -0,0 +1,8 @@
+import { ITargetContext } from '../interfaces/ITargetContext';
+import { BaseTask } from './BaseTask';
+export declare class SyncTask extends BaseTask {
+    readonly taskName: string;
+    readonly dependencies: string[];
+    readonly postDependencies: string[];
+    run(context: ITargetContext): void;
+}

package/dist/json-plugin/tasks/SyncTask.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncTask = void 0;
+const TaskConstants_1 = require("../constants/TaskConstants");
+const BaseTask_1 = require("./BaseTask");
+class SyncTask extends BaseTask_1.BaseTask {
+    constructor() {
+        super(...arguments);
+        this.taskName = TaskConstants_1.TaskConstants.SYNC_TASK;
+        this.dependencies = [];
+        this.postDependencies = [];
+    }
+    run(context) {
+        const scanFiles = this.getScanFiles(context);
+        if (scanFiles.length === 0) {
+            return;
+        }
+        this.processWithLogging(scanFiles, context, TaskConstants_1.TaskConstants.SYNC_TASK);
+    }
+}
+exports.SyncTask = SyncTask;

package/dist/json-plugin/tasks/WatchTask.d.ts

@@ -0,0 +1,11 @@
+import { ITargetContext } from '../interfaces/ITargetContext';
+import { BaseTask } from './BaseTask';
+export declare class WatchTask extends BaseTask {
+    readonly taskName: string;
+    readonly dependencies: string[];
+    readonly postDependencies: string[];
+    private watcher?;
+    run(context: ITargetContext): Promise<void>;
+    private setupWatchEvents;
+    private generateCode;
+}

package/dist/json-plugin/tasks/WatchTask.js

@@ -0,0 +1,102 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchTask = void 0;
+const chokidar = __importStar(require("chokidar"));
+const core_1 = require("../../core");
+const TaskConstants_1 = require("../constants/TaskConstants");
+const BaseTask_1 = require("./BaseTask");
+class WatchTask extends BaseTask_1.BaseTask {
+    constructor() {
+        super(...arguments);
+        this.taskName = TaskConstants_1.TaskConstants.WATCH_TASK;
+        this.dependencies = [];
+        this.postDependencies = [];
+    }
+    async run(context) {
+        core_1.Logger.info('Start the file listening task');
+        const watchPaths = this.getScanFiles(context);
+        if (watchPaths.length === 0) {
+            core_1.Logger.info('There are no files to listen to');
+            return;
+        }
+        core_1.Logger.info(`Start listening for file changes: ${watchPaths.join(', ')}`);
+        this.watcher = chokidar.watch(watchPaths, {
+            persistent: true,
+            ignoreInitial: false
+        });
+        this.setupWatchEvents(context);
+        core_1.Logger.info('File monitoring has been started. Press Ctrl+C to stop the monitoring');
+        return new Promise(_resolve => {
+        });
+    }
+    setupWatchEvents(context) {
+        if (!this.watcher)
+            return;
+        let debounceTimer = null;
+        const debouncedGenerate = (filePath) => {
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
+            debounceTimer = setTimeout(() => {
+                this.generateCode(filePath, context);
+            }, 500);
+        };
+        this.watcher
+            .on('add', (filePath) => {
+            core_1.Logger.info(`New file detected: ${filePath}`);
+            debouncedGenerate(filePath);
+        })
+            .on('change', (filePath) => {
+            core_1.Logger.info(`File change detected: ${filePath}`);
+            debouncedGenerate(filePath);
+        })
+            .on('unlink', (filePath) => {
+            core_1.Logger.info(`File deletion detected: ${filePath}`);
+            debouncedGenerate(filePath);
+        })
+            .on('error', (error) => {
+            core_1.Logger.error(`File monitoring error: ${error}`);
+        })
+            .on('ready', () => {
+            core_1.Logger.info('The initial file scan is complete. Start listening for file changes...');
+        });
+    }
+    generateCode(scanFile, context) {
+        const processingResult = this.engine.processFileUnified(scanFile, context);
+        core_1.Logger.info(`The code generation is complete, and the output path is ${processingResult?.outputPath}`);
+    }
+}
+exports.WatchTask = WatchTask;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@hadss/turbo-trans-json-plugin",
+  "version": "1.0.0-rc.0",
+  "description": "TurboTransJSON Compiler Plugin for automatic serialization code generation",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "package": "rm -rf ./dist && npm i && npx tsc && npm pack",
+    "release": "rm -rf ./dist && npm i && npx tsc && npm publish --access public"
+  },
+  "keywords": [
+    "turbo-trans",
+    "serialization",
+    "json",
+    "harmonyos",
+    "openharmony"
+  ],
+  "author": "DTSE",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "ts-morph": "^26.0.0",
+    "handlebars": "^4.7.8"
+  },
+  "devDependencies": {
+    "@ohos/hvigor": "^5.17.6",
+    "@ohos/hvigor-ohos-plugin": "^5.17.6",
+    "@types/chokidar": "^2.1.7",
+    "@types/node": "^24.2.0",
+    "@types/handlebars": "^4.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "homepage": "https://gitcode.com/openharmony-sig/turbo_trans",
+  "repository": {
+    "type": "git",
+    "url": "https://gitcode.com/openharmony-sig/turbo_trans.git",
+    "directory": "TurboTransJSONPlugin"
+  }
+}