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

package/dist/core/utils/CustomError.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCodes = exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = 'CustomError';
+        this.code = code;
+    }
+}
+exports.CustomError = CustomError;
+var ErrorCodes;
+(function (ErrorCodes) {
+    ErrorCodes[ErrorCodes["INTERNAL_ERROR"] = 3000] = "INTERNAL_ERROR";
+    ErrorCodes[ErrorCodes["TEMPLATE_NOT_FOUND"] = 3011] = "TEMPLATE_NOT_FOUND";
+    ErrorCodes[ErrorCodes["TEMPLATE_REGISTER_FAIL"] = 3012] = "TEMPLATE_REGISTER_FAIL";
+    ErrorCodes[ErrorCodes["ROOT_DIRECTROY_NOT_FOUND"] = 3021] = "ROOT_DIRECTROY_NOT_FOUND";
+    ErrorCodes[ErrorCodes["INVALID_OUTPUT_FAIL"] = 3022] = "INVALID_OUTPUT_FAIL";
+    ErrorCodes[ErrorCodes["INVALID_FILE_CONTENT"] = 3023] = "INVALID_FILE_CONTENT";
+    ErrorCodes[ErrorCodes["HANDLER_NOT_FOUND"] = 3031] = "HANDLER_NOT_FOUND";
+    ErrorCodes[ErrorCodes["CLASS_DECLARATION_NOT_FOUND"] = 3032] = "CLASS_DECLARATION_NOT_FOUND";
+    ErrorCodes[ErrorCodes["IS_NOT_ENUM"] = 3033] = "IS_NOT_ENUM";
+    ErrorCodes[ErrorCodes["ENUM_STRUCTURE_NOT_FOUND"] = 3034] = "ENUM_STRUCTURE_NOT_FOUND";
+    ErrorCodes[ErrorCodes["TYPE_NOT_SUPPORT"] = 3041] = "TYPE_NOT_SUPPORT";
+    ErrorCodes[ErrorCodes["LITERAL_NOT_SOPPORT"] = 3042] = "LITERAL_NOT_SOPPORT";
+    ErrorCodes[ErrorCodes["TRANSIENT_ATTR_OPTIONAL"] = 3043] = "TRANSIENT_ATTR_OPTIONAL";
+    ErrorCodes[ErrorCodes["ANNOTATION_CONFLICT"] = 3044] = "ANNOTATION_CONFLICT";
+    ErrorCodes[ErrorCodes["UNEXPECTED_GENERIC"] = 3051] = "UNEXPECTED_GENERIC";
+    ErrorCodes[ErrorCodes["GENERIC_NOT_MATCH"] = 3052] = "GENERIC_NOT_MATCH";
+    ErrorCodes[ErrorCodes["UNION_STRUCTURE_NOT_FOUND"] = 3061] = "UNION_STRUCTURE_NOT_FOUND";
+    ErrorCodes[ErrorCodes["UNION_EXPEDTED_TWO"] = 3062] = "UNION_EXPEDTED_TWO";
+    ErrorCodes[ErrorCodes["UNION_INNER_NOT_FOUND"] = 3063] = "UNION_INNER_NOT_FOUND";
+    ErrorCodes[ErrorCodes["UNION_UNSUPPORTED_PATTERN"] = 3064] = "UNION_UNSUPPORTED_PATTERN";
+    ErrorCodes[ErrorCodes["UNION_EXPEDTED_THREE"] = 3065] = "UNION_EXPEDTED_THREE";
+    ErrorCodes[ErrorCodes["REWRITE_IMPORT_FAIL"] = 3071] = "REWRITE_IMPORT_FAIL";
+    ErrorCodes[ErrorCodes["NOT_SENDABLE"] = 3072] = "NOT_SENDABLE";
+})(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));

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

@@ -0,0 +1,15 @@
+import { PropertyAnalysis, TypeStructure, TypeDependency } from '..';
+export declare class DeepCopyUtil {
+    static copyPropertyAnalysis(original: PropertyAnalysis): PropertyAnalysis;
+    private static copyPropertyDecorators;
+    static copyTypeStructure(original: TypeStructure): TypeStructure;
+    static copyTypeDependencies(original: TypeDependency[]): TypeDependency[];
+    private static copyTypeDependency;
+    private static copyDependencySource;
+    private static copyTypeDetails;
+    private static copyEnumDetails;
+    private static copyClassDetails;
+    private static copyInterfaceDetails;
+    private static copyTypeAliasDetails;
+    static deepCopy<T>(obj: T): T;
+}

package/dist/core/utils/DeepCopyUtil.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepCopyUtil = void 0;
+class DeepCopyUtil {
+    static copyPropertyAnalysis(original) {
+        return {
+            name: original.name,
+            defaultValue: original.defaultValue,
+            decorators: this.copyPropertyDecorators(original.decorators),
+            isMust: original.isMust,
+            type: this.copyTypeStructure(original.type)
+        };
+    }
+    static copyPropertyDecorators(original) {
+        if (!original) {
+            return undefined;
+        }
+        return {
+            serialName: original.serialName,
+            isRequired: original.isRequired,
+            isTransient: original.isTransient,
+            with: original.with
+        };
+    }
+    static copyTypeStructure(original) {
+        const copy = {
+            kind: original.kind,
+            depth: original.depth,
+            sourceText: original.sourceText,
+            args: [],
+            dependencies: this.copyTypeDependencies(original.dependencies)
+        };
+        if (original.enumDetails) {
+            copy.enumDetails = this.copyEnumDetails(original.enumDetails);
+        }
+        if (original.classDetails) {
+            copy.classDetails = this.copyClassDetails(original.classDetails);
+        }
+        if (original.unionDetails) {
+            copy.unionDetails = original.unionDetails.map(member => this.copyTypeStructure(member));
+        }
+        if (original.args && original.args.length > 0) {
+            copy.args = original.args.map(arg => this.copyTypeStructure(arg));
+        }
+        return copy;
+    }
+    static copyTypeDependencies(original) {
+        return original.map(dependency => this.copyTypeDependency(dependency));
+    }
+    static copyTypeDependency(original) {
+        const copy = {
+            typeName: original.typeName,
+            typeKind: original.typeKind,
+            importPath: original.importPath,
+            source: this.copyDependencySource(original.source)
+        };
+        if (original.details) {
+            copy.details = this.copyTypeDetails(original.details);
+        }
+        return copy;
+    }
+    static copyDependencySource(original) {
+        return {
+            type: original.type,
+            sourceFilePath: original.sourceFilePath,
+            originalImport: original.originalImport,
+            packageName: original.packageName
+        };
+    }
+    static copyTypeDetails(original) {
+        switch (original.kind) {
+            case 'enum':
+                return this.copyEnumDetails(original);
+            case 'class':
+                return this.copyClassDetails(original);
+            case 'interface':
+                return this.copyInterfaceDetails(original);
+            case 'type':
+                return this.copyTypeAliasDetails(original);
+            default:
+                return { ...original };
+        }
+    }
+    static copyEnumDetails(original) {
+        return {
+            kind: original.kind,
+            members: original.members ? original.members.map((member) => ({
+                name: member.name,
+                value: member.value,
+                literalValue: member.literalValue
+            })) : [],
+            valueType: original.valueType
+        };
+    }
+    static copyClassDetails(original) {
+        return {
+            kind: original.kind,
+            classDecl: original.classDecl,
+            isGeneric: original.isGeneric
+        };
+    }
+    static copyInterfaceDetails(original) {
+        return {
+            kind: original.kind,
+            interfaceDecl: original.interfaceDecl,
+            isGeneric: original.isGeneric
+        };
+    }
+    static copyTypeAliasDetails(original) {
+        return {
+            kind: original.kind,
+            aliasedType: original.aliasedType,
+            resolvedType: this.copyTypeStructure(original.resolvedType)
+        };
+    }
+    static deepCopy(obj) {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+        if (obj instanceof Date) {
+            return new Date(obj.getTime());
+        }
+        if (obj instanceof Array) {
+            return obj.map(item => this.deepCopy(item));
+        }
+        if (typeof obj === 'object') {
+            const copy = {};
+            for (const key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                    copy[key] = this.deepCopy(obj[key]);
+                }
+            }
+            return copy;
+        }
+        return obj;
+    }
+}
+exports.DeepCopyUtil = DeepCopyUtil;

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

@@ -0,0 +1,9 @@
+import { TypeNode } from 'ts-morph';
+import { PropertyAnalysis } from '..';
+export declare class GenericTypeSubstitutionUtil {
+    static buildGenericMapping(parentGenericParams: string[], childTypeArguments: TypeNode[]): Map<string, TypeNode>;
+    static substitutePropertyType(property: PropertyAnalysis, genericMapping: Map<string, TypeNode>, currentClassGenericParams?: string[]): PropertyAnalysis;
+    private static substituteTypeStructure;
+    private static constructTypeStructureFromTypeName;
+    private static collectDependenciesFromChildren;
+}

package/dist/core/utils/GenericTypeSubstitutionUtil.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericTypeSubstitutionUtil = void 0;
+const __1 = require("..");
+const handlers_1 = require("../handlers");
+const DeepCopyUtil_1 = require("./DeepCopyUtil");
+class GenericTypeSubstitutionUtil {
+    static buildGenericMapping(parentGenericParams, childTypeArguments) {
+        const mapping = new Map();
+        const length = Math.min(parentGenericParams.length, childTypeArguments.length);
+        for (let i = 0; i < length; i++) {
+            mapping.set(parentGenericParams[i], childTypeArguments[i]);
+        }
+        return mapping;
+    }
+    static substitutePropertyType(property, genericMapping, currentClassGenericParams = []) {
+        if (genericMapping.size === 0) {
+            return property;
+        }
+        const newProperty = DeepCopyUtil_1.DeepCopyUtil.copyPropertyAnalysis(property);
+        newProperty.type = this.substituteTypeStructure(newProperty.type, genericMapping, currentClassGenericParams);
+        return newProperty;
+    }
+    static substituteTypeStructure(typeStructure, mapping, currentClassGenericParams = []) {
+        if (typeStructure.kind === __1.PropertyKind.GENERIC) {
+            const genericTypeName = typeStructure.sourceText;
+            if (mapping.has(genericTypeName)) {
+                const substitutedTypeNode = mapping.get(genericTypeName);
+                return this.constructTypeStructureFromTypeName(substitutedTypeNode, currentClassGenericParams);
+            }
+            return typeStructure;
+        }
+        const newStructure = DeepCopyUtil_1.DeepCopyUtil.copyTypeStructure(typeStructure);
+        if (newStructure.unionDetails) {
+            newStructure.unionDetails = newStructure.unionDetails.map(member => this.substituteTypeStructure(member, mapping, currentClassGenericParams));
+        }
+        if (newStructure.args) {
+            newStructure.args = newStructure.args.map(arg => this.substituteTypeStructure(arg, mapping, currentClassGenericParams));
+        }
+        newStructure.dependencies = this.collectDependenciesFromChildren(newStructure);
+        return newStructure;
+    }
+    static constructTypeStructureFromTypeName(typeNode, currentClassGenericParams = []) {
+        return handlers_1.TypeHandlerRegistry.getInstance().parseType(typeNode, {
+            depth: 0,
+            genericParams: currentClassGenericParams
+        });
+    }
+    static collectDependenciesFromChildren(children) {
+        const allDependencies = [];
+        if (children.unionDetails) {
+            for (const member of children.unionDetails) {
+                if (member.dependencies) {
+                    allDependencies.push(...member.dependencies);
+                }
+            }
+        }
+        if (children.args) {
+            for (const arg of children.args) {
+                if (arg.dependencies) {
+                    allDependencies.push(...arg.dependencies);
+                }
+            }
+        }
+        return allDependencies;
+    }
+}
+exports.GenericTypeSubstitutionUtil = GenericTypeSubstitutionUtil;

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

@@ -0,0 +1,18 @@
+import { FileUtil } from '@ohos/hvigor';
+import * as fs from "fs";
+import { ITaskContext } from '..';
+export default class SerializationPathUtil extends FileUtil {
+    static readonly sep: string;
+    static dirname(p: string): string;
+    static basename(p: string, suffix?: string): string;
+    static extname(p: string): string;
+    static isAbsolute(p: string): boolean;
+    static normalize(p: string): string;
+    static relative(from: string, to: string): string;
+    static join(...paths: string[]): string;
+    static rmSync(path: fs.PathLike, options?: fs.RmOptions): void;
+    static calculateModularImportPath(absolutePath: string, context: ITaskContext): string;
+    static mapToSendableOutputPath(className: string, context: ITaskContext): string;
+    static scanEtsFiles(directory: string): string[];
+    private static removeFileExtension;
+}

package/dist/core/utils/SerializationPathUtil.js

@@ -0,0 +1,107 @@
+"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 });
+const hvigor_1 = require("@ohos/hvigor");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const __1 = require("..");
+class SerializationPathUtil extends hvigor_1.FileUtil {
+    static dirname(p) {
+        return path.dirname(p);
+    }
+    static basename(p, suffix) {
+        return path.basename(p, suffix);
+    }
+    static extname(p) {
+        return path.extname(p);
+    }
+    static isAbsolute(p) {
+        return path.isAbsolute(p);
+    }
+    static normalize(p) {
+        return path.normalize(p);
+    }
+    static relative(from, to) {
+        return path.relative(from, to);
+    }
+    static join(...paths) {
+        return path.join(...paths);
+    }
+    static rmSync(path, options) {
+        return fs.rmSync(path, options);
+    }
+    static calculateModularImportPath(absolutePath, context) {
+        const packageName = context.getPackageName();
+        const moduleRelativePath = context.calculateSourceRootToModuleRoot(absolutePath);
+        const pathWithoutExtension = this.removeFileExtension(moduleRelativePath);
+        return `${packageName}/${pathWithoutExtension}`;
+    }
+    static mapToSendableOutputPath(className, context) {
+        const baseOutputDir = context.getOutputRoot();
+        const sendableModelDir = this.join(baseOutputDir, 'ets/sendableModel');
+        return this.join(sendableModelDir, `Sendable${className}.ets`);
+    }
+    static scanEtsFiles(directory) {
+        const etsFiles = [];
+        const deepScanEtsFiles = (scanPath, relativePath) => {
+            let resolvePath = this.pathResolve(scanPath, relativePath);
+            if (!this.exist(resolvePath)) {
+                return;
+            }
+            if (this.isDictionary(resolvePath)) {
+                const files = fs.readdirSync(resolvePath);
+                files.forEach(file => {
+                    deepScanEtsFiles(resolvePath, file);
+                });
+            }
+            else {
+                if (path.extname(relativePath) === __1.PathConstants.ETS_EXTENSIONS) {
+                    etsFiles.push(resolvePath);
+                }
+            }
+        };
+        deepScanEtsFiles(directory, '');
+        return etsFiles;
+    }
+    static removeFileExtension(filePath) {
+        const lastDotIndex = filePath.lastIndexOf('.');
+        if (lastDotIndex > 0) {
+            return filePath.substring(0, lastDotIndex);
+        }
+        return filePath;
+    }
+}
+SerializationPathUtil.sep = path.sep;
+exports.default = SerializationPathUtil;

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

@@ -0,0 +1,8 @@
+import { Project, ProjectOptions, TypeChecker } from 'ts-morph';
+export declare class TsMorphUtil {
+    static project: Project | null;
+    private constructor();
+    static getProject(options?: ProjectOptions): Project;
+    static getTypeChecker(): TypeChecker;
+    static clearProject(): void;
+}

package/dist/core/utils/TsMorphUtil.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsMorphUtil = void 0;
+const ts_morph_1 = require("ts-morph");
+const Logger_1 = require("../logger/Logger");
+class TsMorphUtil {
+    constructor() { }
+    static getProject(options) {
+        if (!this.project) {
+            Logger_1.Logger.info('创建ts-morph项目');
+            this.project = new ts_morph_1.Project(options || {
+                compilerOptions: {
+                    allowNonTsExtensions: true
+                }
+            });
+        }
+        return this.project;
+    }
+    static getTypeChecker() {
+        return this.getProject().getTypeChecker();
+    }
+    static clearProject() {
+        const sourceFiles = TsMorphUtil.getProject().getSourceFiles();
+        Logger_1.Logger.info(`Clearing ${sourceFiles.length} source files...`);
+        if (sourceFiles && sourceFiles.length > 0) {
+            sourceFiles.forEach((sourceFile) => {
+                TsMorphUtil.getProject().removeSourceFile(sourceFile);
+            });
+        }
+        TsMorphUtil.project = null;
+    }
+}
+exports.TsMorphUtil = TsMorphUtil;
+TsMorphUtil.project = null;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { HvigorPlugin } from '@ohos/hvigor';
+import { Hvigor } from '@ohos/hvigor/src/base/external/core/hvigor';
+import { TurboTransJsonPluginOptions } from './core';
+export declare function turboTransJsonPlugin(hvigor: Hvigor, options?: TurboTransJsonPluginOptions): HvigorPlugin;

package/dist/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.turboTransJsonPlugin = turboTransJsonPlugin;
+const core_1 = require("./core");
+const HandlerBootstrap_1 = require("./core/handlers/HandlerBootstrap");
+const JSONExecuteController_1 = require("./json-plugin/JSONExecuteController");
+const PLUGIN_ID = core_1.StringConstants.PLUGIN_ID;
+const DEFAULT_OPTIONS = {
+    ignoreModuleNames: [],
+    scanDir: core_1.PathConstants.DEFAULT_SCAN_DIRS,
+    deserializationMode: core_1.DeserializationMode.PERFORMANCE,
+};
+function turboTransJsonPlugin(hvigor, options = DEFAULT_OPTIONS) {
+    return {
+        pluginId: PLUGIN_ID,
+        apply(node) {
+            TurboTransJSONPluginManager.getInstance(hvigor).initialization(node, options);
+        }
+    };
+}
+class TurboTransJSONPluginManager {
+    constructor(hvigor) {
+        this.moduleExecuteControllers = new Set();
+        this.setupHvigorHooks(hvigor);
+    }
+    static getInstance(hvigor) {
+        if (!TurboTransJSONPluginManager.instance) {
+            TurboTransJSONPluginManager.instance = new TurboTransJSONPluginManager(hvigor);
+        }
+        return TurboTransJSONPluginManager.instance;
+    }
+    initialization(node, options) {
+        (0, HandlerBootstrap_1.initializeTypeHandlers)();
+        node.subNodes(subNode => {
+            const subNodeName = subNode.getNodeName();
+            if (options.ignoreModuleNames.includes(subNodeName)) {
+                return;
+            }
+            const executeController = new JSONExecuteController_1.JSONExecuteController(subNode, options);
+            this.moduleExecuteControllers.add(executeController);
+        });
+    }
+    setupHvigorHooks(hvigor) {
+        hvigor.nodesEvaluated(() => {
+            this.moduleExecuteControllers.forEach(controller => {
+                controller.execute();
+            });
+        });
+        hvigor.buildFinished(() => {
+            this.moduleExecuteControllers.forEach(controller => {
+                controller.compile();
+            });
+            this.moduleExecuteControllers.clear();
+            TurboTransJSONPluginManager.instance = null;
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { ITask, TurboTransJsonPluginOptions } from '../core';
+export declare class JSONExecuteController {
+    private readonly node;
+    private readonly options;
+    tasks: Set<ITask>;
+    constructor(node: HvigorNode, options: TurboTransJsonPluginOptions);
+    execute(): void;
+    compile(): void;
+    private initTasks;
+    private taskCleanUp;
+    private registerHvigorTasks;
+}

package/dist/json-plugin/JSONExecuteController.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONExecuteController = void 0;
+const core_1 = require("../core");
+const TargetContext_1 = require("./interfaces/impl/TargetContext");
+const ModuleContext_1 = require("./interfaces/impl/ModuleContext");
+const CodeProcessingTask_1 = require("./tasks/CodeProcessingTask");
+const CleanTask_1 = require("./tasks/CleanTask");
+const SyncTask_1 = require("./tasks/SyncTask");
+const WatchTask_1 = require("./tasks/WatchTask");
+const SerializationPathUtil_1 = __importDefault(require("../core/utils/SerializationPathUtil"));
+const CustomError_1 = require("../core/utils/CustomError");
+const TaskConstants_1 = require("./constants/TaskConstants");
+const TsMorphUtil_1 = require("../core/utils/TsMorphUtil");
+const CustomTypeAnalyzer_1 = require("../core/analyzers/CustomTypeAnalyzer");
+const SendableMergeabilityRegistry_1 = require("../core/analyzers/SendableMergeabilityRegistry");
+class JSONExecuteController {
+    constructor(node, options) {
+        this.tasks = new Set();
+        this.node = node;
+        this.options = options;
+    }
+    execute() {
+        const configManager = core_1.ConfigManager.getInstance();
+        configManager.setConfig(this.options);
+        const moduleContext = this.node.getContext(this.node.getAllPluginIds()[0]);
+        const context = new ModuleContext_1.ModuleContextImpl(this.node, moduleContext);
+        context.initScanFiles(this.options.scanDir);
+        this.initTasks();
+        moduleContext.targets((target) => {
+            this.registerHvigorTasks(target, context);
+        });
+    }
+    compile() {
+    }
+    initTasks() {
+        this.tasks.add(new CodeProcessingTask_1.CodeProcessingTask());
+        this.tasks.add(new CleanTask_1.CleanTask());
+        this.tasks.add(new SyncTask_1.SyncTask());
+        this.tasks.add(new WatchTask_1.WatchTask());
+    }
+    taskCleanUp() {
+        const sourceFiles = TsMorphUtil_1.TsMorphUtil.getProject().getSourceFiles();
+        core_1.Logger.info(`code analysis Clearing ${sourceFiles.length} source files...`);
+        sourceFiles.forEach((sourceFile) => {
+            TsMorphUtil_1.TsMorphUtil.getProject().removeSourceFile(sourceFile);
+        });
+        CustomTypeAnalyzer_1.CustomTypeAnalyzer.getInstance().clearCache();
+        SendableMergeabilityRegistry_1.SendableMergeabilityRegistry.clear();
+    }
+    registerHvigorTasks(target, context) {
+        const targetContext = new TargetContext_1.TargetContextImpl(target, context);
+        this.tasks.forEach((task) => {
+            this.node.registerTask({
+                name: task.taskName,
+                run: async () => {
+                    try {
+                        core_1.Logger.info(`${task.taskName} run`);
+                        core_1.TempSerializerGenerator.getInstance().init(targetContext);
+                        const result = task.run(targetContext);
+                        if (task.taskName !== TaskConstants_1.TaskConstants.CLEAN_TASK) {
+                            core_1.TempSerializerGenerator.getInstance().saveFile();
+                        }
+                        if (result instanceof Promise) {
+                            await result;
+                        }
+                        if (task.taskName === TaskConstants_1.TaskConstants.SYNC_TASK || task.taskName === TaskConstants_1.TaskConstants.CODE_PROCESSING_TASK) {
+                            this.taskCleanUp();
+                        }
+                        core_1.Logger.info(`${task.taskName} end`);
+                    }
+                    catch (error) {
+                        if (error instanceof CustomError_1.CustomError) {
+                            core_1.Logger.error(`Error: ${error.constructor.name}: ${error.code} ${error.message}\n${error.stack}`);
+                        }
+                        else {
+                            const err = error;
+                            core_1.Logger.error(`Error: ${err.constructor.name}: ${CustomError_1.ErrorCodes.INTERNAL_ERROR} ${err.message}\n${err.stack}`);
+                        }
+                        this.taskCleanUp();
+                        throw new Error('serialization execute failed');
+                    }
+                },
+                dependencies: task.dependencies.map((dep) => `${target.getTargetName()}@${dep}`),
+                postDependencies: task.postDependencies.map((dep) => `${target.getTargetName()}@${dep}`)
+            });
+        });
+        const cleanTask = this.node.getTaskByName('clean');
+        if (cleanTask) {
+            cleanTask.beforeRun(() => {
+                const generatedRootDir = targetContext.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.JSONExecuteController = JSONExecuteController;

package/dist/json-plugin/constants/TaskConstants.d.ts

@@ -0,0 +1,7 @@
+export declare class TaskConstants {
+    static readonly SYNC_TASK = "jsonSync";
+    static readonly CLEAN_TASK = "jsonClean";
+    static readonly WATCH_TASK = "jsonWatch";
+    static readonly CODE_PROCESSING_TASK = "SerializationTask";
+    static readonly PRE_BUILD_TASK = "PreBuild";
+}

package/dist/json-plugin/constants/TaskConstants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskConstants = void 0;
+class TaskConstants {
+}
+exports.TaskConstants = TaskConstants;
+TaskConstants.SYNC_TASK = 'jsonSync';
+TaskConstants.CLEAN_TASK = 'jsonClean';
+TaskConstants.WATCH_TASK = 'jsonWatch';
+TaskConstants.CODE_PROCESSING_TASK = 'SerializationTask';
+TaskConstants.PRE_BUILD_TASK = 'PreBuild';

package/dist/json-plugin/interfaces/IModuleContext.d.ts

@@ -0,0 +1,10 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile';
+import { OhosModuleContext } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
+export interface IModuleContext {
+    readonly node: HvigorNode;
+    readonly moduleContext: OhosModuleContext;
+    readonly buildProfileOpt: ModuleBuildProfile.ModuleBuildOpt;
+    readonly scanFiles: string[];
+    initScanFiles(scanDir: string[]): void;
+}

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

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

package/dist/json-plugin/interfaces/ITargetContext.d.ts

@@ -0,0 +1,8 @@
+import { Target } from '@ohos/hvigor-ohos-plugin';
+import { IModuleContext } from './IModuleContext';
+import { ITaskContext } from '../../core';
+export interface ITargetContext extends ITaskContext {
+    readonly target: Target;
+    readonly context: IModuleContext;
+    getCurrentTargetScanFiles(): string[];
+}