@hadss/hmrouter-plugin 1.0.0-rc.9 → 1.1.1-alpha.0

package/dist/framework/constants/TaskConstants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskConstants = void 0;
+class TaskConstants {
+}
+exports.TaskConstants = TaskConstants;
+TaskConstants.PRE_BUILD = '@PreBuild';
+TaskConstants.PROCESS_ROUTER_MAP = '@ProcessRouterMap';
+TaskConstants.PROCESS_RESOURCE = '@ProcessResource';
+TaskConstants.PLUGIN_TASK = '@HMRouterPluginTask';
+TaskConstants.COPY_ROUTER_MAP_TASK = '@HMRouterCopyRouterMapToRawFileTask';
+TaskConstants.GENERATE_OBFUSCATION_TASK = '@HMRouterGenerateObfuscationFileTask';

package/dist/framework/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './TaskConstants';

package/dist/framework/constants/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./TaskConstants"), exports);

package/dist/framework/core/PluginExecutionController.d.ts

@@ -0,0 +1,15 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { OhosModuleContext } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
+import { PluginExtension } from '../extension';
+export declare class PluginExecutionController {
+    private readonly node;
+    private readonly moduleContext;
+    private readonly taskManager;
+    private readonly baseContext;
+    private extensionContextCache;
+    constructor(node: HvigorNode, moduleContext: OhosModuleContext, moduleExtensions?: PluginExtension[]);
+    start(): void;
+    complete(): void;
+    private initializeContext;
+    private registerHvigorTasks;
+}

package/dist/framework/core/PluginExecutionController.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginExecutionController = void 0;
+const TaskManager_1 = require("./TaskManager");
+const TaskStage_1 = require("./TaskStage");
+const constants_1 = require("../constants");
+const extension_1 = require("../extension");
+class PluginExecutionController {
+    constructor(node, moduleContext, moduleExtensions) {
+        this.extensionContextCache = new Map();
+        this.node = node;
+        this.moduleContext = moduleContext;
+        this.baseContext = this.initializeContext();
+        this.taskManager = new TaskManager_1.TaskManager(this.baseContext, moduleExtensions);
+    }
+    start() {
+        this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_INITIALIZE);
+        this.registerHvigorTasks();
+    }
+    complete() {
+        this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_COMPLETION);
+    }
+    initializeContext() {
+        const context = new extension_1.ExtensionContextImpl(this.node, this.moduleContext);
+        context.scanFiles = [];
+        return context;
+    }
+    registerHvigorTasks() {
+        this.moduleContext.targets((target) => {
+            const targetName = target.getTargetName();
+            this.node.registerTask({
+                name: targetName + constants_1.TaskConstants.PLUGIN_TASK,
+                run: () => {
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_ANNOTATION_ANALYSIS);
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_CODE_GENERATION);
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_ROUTER_MAP_BUILDING);
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_CONFIG_UPDATE);
+                },
+                dependencies: [],
+                postDependencies: [targetName + constants_1.TaskConstants.PRE_BUILD],
+            });
+            this.node.registerTask({
+                name: targetName + constants_1.TaskConstants.GENERATE_OBFUSCATION_TASK,
+                run: () => {
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_OBFUSCATION_PROCESS);
+                },
+                dependencies: [targetName + constants_1.TaskConstants.PLUGIN_TASK],
+                postDependencies: [targetName + constants_1.TaskConstants.PRE_BUILD],
+            });
+            this.node.registerTask({
+                name: targetName + constants_1.TaskConstants.COPY_ROUTER_MAP_TASK,
+                run: () => {
+                    this.taskManager.context.currentTarget = target;
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_RESOURCE_PROCESS);
+                },
+                dependencies: [targetName + constants_1.TaskConstants.PROCESS_ROUTER_MAP],
+                postDependencies: [targetName + constants_1.TaskConstants.PROCESS_RESOURCE],
+            });
+        });
+    }
+}
+exports.PluginExecutionController = PluginExecutionController;

package/dist/framework/core/TaskManager.d.ts

@@ -0,0 +1,12 @@
+import { ExtensionContext, PluginExtension } from '../extension';
+import { TaskStage } from './TaskStage';
+export declare class TaskManager {
+    private extensionManager;
+    private readonly moduleExtensions;
+    context: ExtensionContext;
+    constructor(context: ExtensionContext, moduleExtensions?: PluginExtension[]);
+    executeStage(stage: TaskStage): void;
+    private executeAnnotationAnalysis;
+    private getExtensions;
+    private validateTemplateData;
+}

package/dist/framework/core/TaskManager.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManager = void 0;
+const extension_1 = require("../extension");
+const utils_1 = require("../utils");
+const TaskStage_1 = require("./TaskStage");
+class TaskManager {
+    constructor(context, moduleExtensions) {
+        this.extensionManager = extension_1.ExtensionManager.getInstance();
+        this.moduleExtensions = moduleExtensions || [];
+        this.context = context;
+    }
+    executeStage(stage) {
+        switch (stage) {
+            case TaskStage_1.TaskStage.AFTER_ANNOTATION_ANALYSIS:
+                this.executeAnnotationAnalysis();
+                break;
+            default:
+                this.getExtensions().forEach((extension) => {
+                    const methodName = stage.toString();
+                    extension[methodName]?.(this.context);
+                });
+                break;
+        }
+    }
+    executeAnnotationAnalysis() {
+        const analyzers = this.getExtensions()
+            .map((extension) => extension.afterAnnotationAnalysis || null);
+        this.context.scanFiles.forEach((file) => {
+            this.context.setCurrentFilePath(file);
+            const sourceFile = utils_1.TsAstUtil.getSourceFile(file);
+            for (const analyzer of analyzers) {
+                analyzer?.(sourceFile, file, this.context);
+            }
+        });
+        this.context.setCurrentFilePath('');
+        this.validateTemplateData();
+    }
+    getExtensions() {
+        const globalExtensions = this.extensionManager.getExtensions();
+        const allExtensions = globalExtensions.concat(this.moduleExtensions);
+        return allExtensions.sort((a, b) => {
+            const aIsHMRouter = a.name?.includes('HMRouter') || false;
+            const bIsHMRouter = b.name?.includes('HMRouter') || false;
+            if (aIsHMRouter && !bIsHMRouter)
+                return -1;
+            if (!aIsHMRouter && bIsHMRouter)
+                return 1;
+            return 0;
+        });
+    }
+    validateTemplateData() {
+        const componentNames = new Set();
+        this.context.getAnalyzeResults().forEach((result) => {
+            if (result.name) {
+                componentNames.add(result.name);
+            }
+        });
+        const templateComponentNames = new Set(this.context.getTemplateDataMap().keys());
+        templateComponentNames.forEach((name) => {
+            if (!componentNames.has(name)) {
+                utils_1.Logger.warn(this.context.node.getNodeName(), `Component ${name} has template data but was not found in analyze results.`);
+            }
+        });
+    }
+}
+exports.TaskManager = TaskManager;

package/dist/framework/core/TaskStage.d.ts

@@ -0,0 +1,10 @@
+export declare enum TaskStage {
+    AFTER_INITIALIZE = "afterInitialize",
+    AFTER_ANNOTATION_ANALYSIS = "afterAnnotationAnalysis",
+    AFTER_CODE_GENERATION = "afterCodeGeneration",
+    AFTER_ROUTER_MAP_BUILDING = "afterRouterMapBuilding",
+    AFTER_CONFIG_UPDATE = "afterConfigUpdate",
+    AFTER_OBFUSCATION_PROCESS = "afterObfuscationProcess",
+    AFTER_RESOURCE_PROCESS = "afterResourceProcess",
+    AFTER_COMPLETION = "afterCompletion"
+}

package/dist/framework/core/TaskStage.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStage = void 0;
+var TaskStage;
+(function (TaskStage) {
+    TaskStage["AFTER_INITIALIZE"] = "afterInitialize";
+    TaskStage["AFTER_ANNOTATION_ANALYSIS"] = "afterAnnotationAnalysis";
+    TaskStage["AFTER_CODE_GENERATION"] = "afterCodeGeneration";
+    TaskStage["AFTER_ROUTER_MAP_BUILDING"] = "afterRouterMapBuilding";
+    TaskStage["AFTER_CONFIG_UPDATE"] = "afterConfigUpdate";
+    TaskStage["AFTER_OBFUSCATION_PROCESS"] = "afterObfuscationProcess";
+    TaskStage["AFTER_RESOURCE_PROCESS"] = "afterResourceProcess";
+    TaskStage["AFTER_COMPLETION"] = "afterCompletion";
+})(TaskStage = exports.TaskStage || (exports.TaskStage = {}));

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

@@ -0,0 +1,3 @@
+export * from './TaskManager';
+export * from './TaskStage';
+export * from './PluginExecutionController';

package/dist/framework/core/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./TaskManager"), exports);
+__exportStar(require("./TaskStage"), exports);
+__exportStar(require("./PluginExecutionController"), exports);

package/dist/framework/extension/ExtensionManager.d.ts

@@ -0,0 +1,11 @@
+import { PluginExtension } from './PluginExtension';
+export declare class ExtensionManager {
+    private static instance;
+    private extensions;
+    static getInstance(): ExtensionManager;
+    static destroy(): void;
+    registerExtension(extension: PluginExtension): void;
+    getExtensions(): PluginExtension[];
+    private clear;
+}
+export declare function registerPluginExtension(extension: PluginExtension): void;

package/dist/framework/extension/ExtensionManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPluginExtension = exports.ExtensionManager = void 0;
+class ExtensionManager {
+    constructor() {
+        this.extensions = [];
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ExtensionManager();
+        }
+        return this.instance;
+    }
+    static destroy() {
+        this.instance = null;
+        this.getInstance().clear();
+    }
+    registerExtension(extension) {
+        this.extensions.push(extension);
+    }
+    getExtensions() {
+        return this.extensions;
+    }
+    clear() {
+        this.extensions = [];
+    }
+}
+exports.ExtensionManager = ExtensionManager;
+ExtensionManager.instance = null;
+function registerPluginExtension(extension) {
+    ExtensionManager.getInstance().registerExtension(extension);
+}
+exports.registerPluginExtension = registerPluginExtension;

package/dist/framework/extension/PluginExtension.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionContext } from '../extension';
+import { SourceFile } from 'ts-morph';
+export declare abstract class PluginExtension<T extends ExtensionContext = ExtensionContext> {
+    abstract get name(): string;
+    afterInitialize?(context: T): void;
+    afterAnnotationAnalysis?(sourceFile: SourceFile, filePath: string, context: T): void;
+    afterCodeGeneration?(context: T): void;
+    afterRouterMapBuilding?(context: T): void;
+    afterConfigUpdate?(context: T): void;
+    afterObfuscationProcess?(context: T): void;
+    afterResourceProcess?(context: T): void;
+    afterCompletion?(context: T): void;
+}

package/dist/framework/extension/PluginExtension.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginExtension = void 0;
+class PluginExtension {
+}
+exports.PluginExtension = PluginExtension;

package/dist/framework/extension/context/ExtensionContextImpl.d.ts

@@ -0,0 +1,23 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { OhosModuleContext, Target } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
+import { BaseAnalyzeResult, ExtensionContext } from './Interface';
+export declare class ExtensionContextImpl implements ExtensionContext {
+    node: HvigorNode;
+    moduleContext: OhosModuleContext;
+    currentTarget?: Target;
+    scanFiles: string[];
+    private templateMetadata;
+    private analyzeResults;
+    private _currentView;
+    private _currentFilePath?;
+    constructor(node: HvigorNode, moduleContext: OhosModuleContext);
+    get currentView(): ReadonlyArray<BaseAnalyzeResult>;
+    addAnalyzeResults(results: BaseAnalyzeResult | BaseAnalyzeResult[]): void;
+    getAnalyzeResults<T extends BaseAnalyzeResult = BaseAnalyzeResult>(): Set<T>;
+    getTemplateData(componentName: string): Record<string, any> | undefined;
+    getTemplateDataMap(): Map<string, Record<string, any>>;
+    addTemplateData(componentName: string, data: Record<string, any>): void;
+    private validateAnalyzeResult;
+    private syncToCurrentView;
+    setCurrentFilePath(filePath: string): void;
+}

package/dist/framework/extension/context/ExtensionContextImpl.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionContextImpl = void 0;
+const TemplateMetadataImpl_1 = require("./TemplateMetadataImpl");
+const utils_1 = require("../../utils");
+class ExtensionContextImpl {
+    constructor(node, moduleContext) {
+        this.scanFiles = [];
+        this.analyzeResults = new Set();
+        this._currentView = [];
+        this.node = node;
+        this.moduleContext = moduleContext;
+        this.templateMetadata = new TemplateMetadataImpl_1.TemplateMetadataImpl();
+    }
+    get currentView() {
+        return this._currentView;
+    }
+    addAnalyzeResults(results) {
+        if (Array.isArray(results)) {
+            results.forEach((result) => {
+                if (!this.validateAnalyzeResult(result)) {
+                    utils_1.Logger.warn(this.node.getNodeName(), `Invalid analyze result: ${JSON.stringify(result)}`);
+                    return;
+                }
+                this.analyzeResults.add(result);
+            });
+        }
+        else {
+            if (!this.validateAnalyzeResult(results)) {
+                utils_1.Logger.warn(this.node.getNodeName(), `Invalid analyze result: ${JSON.stringify(results)}`);
+                return;
+            }
+            this.analyzeResults.add(results);
+        }
+        this.syncToCurrentView(results);
+    }
+    getAnalyzeResults() {
+        return this.analyzeResults;
+    }
+    getTemplateData(componentName) {
+        return this.templateMetadata.getTemplateData(componentName);
+    }
+    getTemplateDataMap() {
+        return this.templateMetadata.templateDataMap;
+    }
+    addTemplateData(componentName, data) {
+        this.templateMetadata.addTemplateData(componentName, data);
+    }
+    validateAnalyzeResult(result) {
+        return result.name !== undefined && result.sourceFilePath !== undefined && result.annotation !== undefined;
+    }
+    syncToCurrentView(results) {
+        if (!this._currentFilePath)
+            return;
+        const resultsArray = Array.isArray(results) ? results : [results];
+        const currentFileResults = resultsArray.filter(result => result.sourceFilePath === this._currentFilePath);
+        this._currentView.push(...currentFileResults);
+    }
+    setCurrentFilePath(filePath) {
+        this._currentFilePath = filePath;
+        this._currentView = [];
+    }
+}
+exports.ExtensionContextImpl = ExtensionContextImpl;

package/dist/framework/extension/context/Interface.d.ts

@@ -0,0 +1,21 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { OhosModuleContext, Target } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
+export interface BaseAnalyzeResult {
+    name: string;
+    annotation: string;
+    sourceFilePath: string;
+}
+export interface BaseExtensionContext {
+    readonly node: HvigorNode;
+    readonly moduleContext: OhosModuleContext;
+    readonly currentView: ReadonlyArray<BaseAnalyzeResult>;
+    currentTarget?: Target;
+    scanFiles: string[];
+}
+export interface ExtensionContext extends BaseExtensionContext {
+    getAnalyzeResults<T extends BaseAnalyzeResult = BaseAnalyzeResult>(): Set<T>;
+    addAnalyzeResults(results: BaseAnalyzeResult | BaseAnalyzeResult[]): void;
+    getTemplateData(componentName: string): Record<string, any> | undefined;
+    getTemplateDataMap(): Map<string, Record<string, any>>;
+    addTemplateData(componentName: string, data: Record<string, any>): void;
+}

package/dist/framework/extension/context/Interface.js

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

package/dist/framework/extension/context/TemplateMetadataImpl.d.ts

@@ -0,0 +1,12 @@
+export interface TemplateMetadata {
+    currentFilePath: string;
+    templateDataMap: Map<string, Record<string, any>>;
+    addTemplateData(componentName: string, data: Record<string, any>): void;
+    getTemplateData(componentName: string): Record<string, any> | undefined;
+}
+export declare class TemplateMetadataImpl implements TemplateMetadata {
+    currentFilePath: string;
+    templateDataMap: Map<string, Record<string, any>>;
+    addTemplateData(componentName: string, data: Record<string, any>): void;
+    getTemplateData(componentName: string): Record<string, any> | undefined;
+}

package/dist/framework/extension/context/TemplateMetadataImpl.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateMetadataImpl = void 0;
+class TemplateMetadataImpl {
+    constructor() {
+        this.currentFilePath = '';
+        this.templateDataMap = new Map();
+    }
+    addTemplateData(componentName, data) {
+        if (this.templateDataMap.has(componentName)) {
+            const existing = this.templateDataMap.get(componentName) || {};
+            this.templateDataMap.set(componentName, { ...existing, ...data });
+        }
+        else {
+            this.templateDataMap.set(componentName, data);
+        }
+    }
+    getTemplateData(componentName) {
+        return this.templateDataMap.get(componentName);
+    }
+}
+exports.TemplateMetadataImpl = TemplateMetadataImpl;

package/dist/framework/extension/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ExtensionManager';
+export * from './PluginExtension';
+export * from './context/Interface';
+export * from './context/ExtensionContextImpl';

package/dist/framework/extension/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./ExtensionManager"), exports);
+__exportStar(require("./PluginExtension"), exports);
+__exportStar(require("./context/Interface"), exports);
+__exportStar(require("./context/ExtensionContextImpl"), exports);

package/dist/framework/index.d.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './extension';
+export * from './utils';
+export * from './constants';

package/dist/framework/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./core"), exports);
+__exportStar(require("./extension"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);

package/dist/framework/utils/FileUtil.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { FileUtil } from '@ohos/hvigor';
+import fs from 'fs';
+export declare class PluginFileUtil extends FileUtil {
+    static rmSync(path: fs.PathLike, options?: fs.RmOptions): void;
+    static unlinkSync(path: fs.PathLike): void;
+    static readdirSync(path: fs.PathLike, options?: {
+        encoding: BufferEncoding | null;
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }): string[];
+}

package/dist/framework/utils/FileUtil.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginFileUtil = void 0;
+const hvigor_1 = require("@ohos/hvigor");
+const fs_1 = __importDefault(require("fs"));
+class PluginFileUtil extends hvigor_1.FileUtil {
+    static rmSync(path, options) {
+        return fs_1.default.rmSync(path, options);
+    }
+    static unlinkSync(path) {
+        return fs_1.default.unlinkSync(path);
+    }
+    static readdirSync(path, options) {
+        return fs_1.default.readdirSync(path, options);
+    }
+}
+exports.PluginFileUtil = PluginFileUtil;

package/dist/framework/utils/Logger.d.ts

@@ -0,0 +1,12 @@
+export declare class Logger {
+    static error(module: string, msg: string, ...args: unknown[]): void;
+    static info(module: string, msg: string, ...args: unknown[]): void;
+    static warn(module: string, msg: string, ...args: unknown[]): void;
+    static debug(module: string, msg: string, ...args: unknown[]): void;
+    static withContext(module: string, operation: string): {
+        error: (msg: string, ...args: unknown[]) => void;
+        info: (msg: string, ...args: unknown[]) => void;
+        warn: (msg: string, ...args: unknown[]) => void;
+        debug: (msg: string, ...args: unknown[]) => void;
+    };
+}

package/dist/framework/utils/Logger.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const hvigor_1 = require("@ohos/hvigor");
+class Logger {
+    static error(module, msg, ...args) {
+        const prefix = `[HMRouterPlugin][${module}]:`;
+        hvigor_1.HvigorLogger.getLogger().error(`${prefix} ${msg}`, ...args);
+    }
+    static info(module, msg, ...args) {
+        const prefix = `[HMRouterPlugin][${module}]:`;
+        hvigor_1.HvigorLogger.getLogger().info(`${prefix} ${msg}`, ...args);
+    }
+    static warn(module, msg, ...args) {
+        const prefix = `[HMRouterPlugin][${module}]:`;
+        hvigor_1.HvigorLogger.getLogger().warn(`${prefix} ${msg}`, ...args);
+    }
+    static debug(module, msg, ...args) {
+        const prefix = `[HMRouterPlugin][${module}]:`;
+        hvigor_1.HvigorLogger.getLogger().debug(`${prefix} ${msg}`, ...args);
+    }
+    static withContext(module, operation) {
+        return {
+            error: (msg, ...args) => Logger.error(module, `${operation} - ${msg}`, ...args),
+            info: (msg, ...args) => Logger.info(module, `${operation} - ${msg}`, ...args),
+            warn: (msg, ...args) => Logger.warn(module, `${operation} - ${msg}`, ...args),
+            debug: (msg, ...args) => Logger.debug(module, `${operation} - ${msg}`, ...args),
+        };
+    }
+}
+exports.Logger = Logger;

package/dist/framework/utils/ModuleTypeUtil.d.ts

@@ -0,0 +1,4 @@
+import { HvigorNode } from '@ohos/hvigor';
+export declare function isHapModule(node: HvigorNode): boolean;
+export declare function isHarModule(node: HvigorNode): boolean;
+export declare function isHspModule(node: HvigorNode): boolean;

package/dist/framework/utils/ModuleTypeUtil.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHspModule = exports.isHarModule = exports.isHapModule = void 0;
+const hvigor_ohos_plugin_1 = require("@ohos/hvigor-ohos-plugin");
+function isHapModule(node) {
+    return node.getAllPluginIds().includes(hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAP_PLUGIN);
+}
+exports.isHapModule = isHapModule;
+function isHarModule(node) {
+    return node.getAllPluginIds().includes(hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAR_PLUGIN);
+}
+exports.isHarModule = isHarModule;
+function isHspModule(node) {
+    return node.getAllPluginIds().includes(hvigor_ohos_plugin_1.OhosPluginId.OHOS_HSP_PLUGIN);
+}
+exports.isHspModule = isHspModule;

package/dist/framework/utils/ObjectUtils.d.ts

@@ -0,0 +1,3 @@
+export declare class ObjectUtils {
+    static ensureNestedObject(obj: any, path: string[]): any;
+}

package/dist/framework/utils/ObjectUtils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectUtils = void 0;
+class ObjectUtils {
+    static ensureNestedObject(obj, path) {
+        return path.reduce((acc, key) => {
+            if (!acc[key]) {
+                acc[key] = {};
+            }
+            return acc[key];
+        }, obj);
+    }
+}
+exports.ObjectUtils = ObjectUtils;