@hadss/hmrouter-plugin 1.1.1-alpha.0 → 1.2.0-beta.2

package/README.md

@@ -8,9 +8,9 @@ HMRouter编译插件是一个基于hvigor的编译插件，用于：
 
 1. 扫描代码中的`@HMRouter`、`@HMInterceptor`、`@HMLifecycle`、`@HMAnimator`、`@HMService`等注解
 2. 生成路由表和NavDestination页面代码
-3. 生成混淆规则
-4. 支持自定义模板
-5. 编译时自定义扩展
+3. **自动生成混淆规则**
+4. **支持自定义模板**，开发者可以自定义特殊页面的生成
+5. **支持插件扩展**，开发者可以在HMRouterPlugin的编译中进行自定义解析
 
 ## 插件安装与配置
 
@@ -21,50 +21,40 @@ HMRouter编译插件是一个基于hvigor的编译插件，用于：
 ```json5
 {
   "dependencies": {
-    "@hadss/hmrouter-plugin": "^1.1.0-beta.0"  // 使用最新版本
+    "@hadss/hmrouter-plugin": "^1.2.0-beta.0"  // 使用最新版本
   },
   // ...其余配置
 }
 ```
 
-### 模块级配置
-
-在使用HMRouter的模块中引入路由编译插件，修改`hvigorfile.ts`：
+修改工程根目录下的`hvigorfile.ts`，使用路由编译插件
 
-```extendtypescript
-// entry/hvigorfile.ts  entry模块的hvigorfile.ts
-import { hapTasks } from '@ohos/hvigor-ohos-plugin';
-import { hapPlugin } from '@hadss/hmrouter-plugin';
+```typescript
+// 工程根目录/hvigorfile.ts
+import { appTasks } from '@ohos/hvigor-ohos-plugin';
+import { appPlugin } from "@hadss/hmrouter-plugin";
 
 export default {
-  system: hapTasks,
-  plugins: [hapPlugin()] // 使用HMRouter标签的模块均需要配置，与模块类型保持一致
-}
+  system: appTasks,
+  plugins: [appPlugin({ ignoreModuleNames: [ /** 不需要扫描的模块 **/ ] })]
+};
+```
 
-// libHar/hvigorfile.ts  libHar模块的hvigorfile.ts
-import { harTasks } from '@ohos/hvigor-ohos-plugin';
-import { harPlugin } from '@hadss/hmrouter-plugin';
+### 模块级配置
 
-export default {
-  system: harTasks,
-  plugins:[harPlugin()]  // 使用HMRouter标签的模块均需要配置，与模块类型保持一致
-}
+在使用HMRouter的模块中单独配置路由编译插件，修改模块目录下的`hvigorfile.ts`：
 
-// libHsp/hvigorfile.ts  libHsp模块的hvigorfile.ts
-import { hspTasks } from '@ohos/hvigor-ohos-plugin';
-import { hspPlugin } from '@hadss/hmrouter-plugin';
+```typescript
+// entry/hvigorfile.ts  entry模块的hvigorfile.ts
+import { hapTasks } from '@ohos/hvigor-ohos-plugin';
+import { modulePlugin } from '@hadss/hmrouter-plugin';
 
 export default {
-  system: hspTasks,
-  plugins: [hspPlugin()]  // 使用HMRouter标签的模块均需要配置，与模块类型保持一致
+  system: hapTasks,
+  plugins: [modulePlugin()] // 使用HMRouter标签的模块均需要配置，与模块类型保持一致
 }
 ```
 
-> 注意：模块类型与插件类型必须匹配：
-> - Har模块使用`harPlugin()`
-> - Hsp模块使用`hspPlugin()`
-> - Hap模块使用`hapPlugin()`
-
 ## 配置文件详解
 
 在项目根目录或模块目录创建`hmrouter_config.json`文件，配置插件行为：
@@ -106,17 +96,17 @@ export default {
 
 ### 配置选项说明
 
-| 配置项                | 类型      | 是否必填 | 说明                                                                                                                                     |
-|---------------------|---------|------|----------------------------------------------------------------------------------------------------------------------------------------|
-| scanDir             | array   | 否    | 指定扫描当前模块路径，默认值为`src/main/ets`                                                                                                          |
-| saveGeneratedFile   | boolean | 否    | 默认为 false，不保留插件自动生成的代码，如果需要保留，需要设置为 true                                                                                               |
+| 配置项                 | 类型      | 是否必填 | 说明                                                                                                                                                                      |
+|---------------------|---------|------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| scanDir             | array   | 否    | 指定扫描当前模块路径，默认值为`src/main/ets`                                                                                                                                           |
+| saveGeneratedFile   | boolean | 否    | 默认为 false，不保留插件自动生成的代码，如果需要保留，需要设置为 true                                                                                                                                |
 | autoObfuscation     | boolean | 否    | 默认为 false，不自动配置混淆规则，只会生成`hmrouter_obfuscation_rules.txt`文件帮助开发者配置混淆规则；如果设置为 true，会自动配置混淆规则，并在编译完成后删除`hmrouter_obfuscation_rules.txt`文件，详细说明请参考[混淆配置](Obfuscation.md)文档。 |
-| defaultPageTemplate | string  | 否    | 默认模版路径，相对于hmrouter_config.json文件，例如：`./templates/defaultTemplate.ejs`                                                                  |
-| customPageTemplate  | object  | 否    | srcPath为匹配的代码文件路径，支持通配符，templatePath为模版路径，可以实现不同的代码使用不同的模版来生成                                                                          |
+| defaultPageTemplate | string  | 否    | 默认模版路径，相对于hmrouter_config.json文件，例如：`./templates/defaultTemplate.ejs`                                                                                                   |
+| customPageTemplate  | object  | 否    | srcPath为匹配的代码文件路径，支持通配符，templatePath为模版路径，可以实现不同的代码使用不同的模版来生成                                                                                                           |
 
 ### 配置文件读取规则
 
-> 配置文件读取规则为 模块 > 工程 > 默认
+> 配置文件会自动合并，读取优先级为 模块 > 工程 > 默认
 > 
 > 优先使用本模块内的配置，如果没有配置，则使用工程根目录配置，若都找不到则使用默认配置
 
@@ -124,22 +114,6 @@ export default {
 > 
 > 1.0.0-rc.9 版本开始，支持自定义模版配置`customPageTemplate`
 
-## 多模块配置
-
-在多模块项目中，每个使用HMRouter的模块都需要配置插件。 
-
-### 方式一：每个模块单独配置
-
-在每个模块的根目录下创建`hmrouter_config.json`文件，分别配置。
-
-### 方式二：共享配置
-
-在项目根目录创建`hmrouter_config.json`文件，所有模块共享配置。
-
-如果需要为不同模块指定不同的配置，可以在模块根目录创建`hmrouter_config.json`文件，覆盖共享配置。
-
-> 注意：当前多模块配置时不会做字段合并，即模块配置会直接覆盖工程配置
-
 ## 自定义模板使用
 
 在 `HMRouterPlugin` 中，EJS模板用于生成动态页面或组件，可以在模板文件中使用 EJS 的语法
@@ -356,9 +330,78 @@ export struct <%= componentName %>Generated {
 - customPageTemplate > defaultPageTemplate > 库中携带的模板
 - 如遇到customPageTemplate中的多个srcPath都能匹配上，优先取前面的模板文件
 
-## 插件自定义扩展
+## 插件扩展
+
+HMRouterPlugin提供了完善的扩展机制，允许开发者在插件执行的不同阶段注入自定义逻辑。通过继承`PluginExtension`抽象类并实现特定方法来扩展功能。
+
+### 编写扩展类
+
+创建一个继承自`PluginExtension`的类，并实现需要的生命周期方法：
+
+```typescript
+// MyCustomExtension.ts
+import { PluginExtension, ExtensionContext } from '@hadss/hmrouter-plugin';
+import { SourceFile } from 'ts-morph';
+
+export class MyCustomExtension extends PluginExtension {
+  // 可选：扩展名称，主要用于调试日志
+  get name(): string {
+    return 'MyCustomExtension';
+  }
+  
+  // hmrouter_extension初始化阶段后执行
+  afterInitialize(context: ExtensionContext): void {
+    console.log('Extension initialization');
+    // 初始化设置逻辑
+  }
+  
+  // 注解分析阶段后执行
+  afterAnnotationAnalysis(sourceFile: SourceFile, filePath: string, context: ExtensionContext): void {
+    // 在源文件上执行分析逻辑
+    console.log(`Analyzing file: ${filePath}`);
+    // 可以提取信息并添加到上下文
+    const results = [
+      // 分析结果...
+    ];
+    
+    // 将结果添加到上下文
+    context.addAnalyzeResults(results);
+  }
+  
+  // 代码生成阶段后执行
+  afterCodeGeneration(context: ExtensionContext): void {
+    // 自定义代码生成逻辑
+    console.log('Custom code generation');
+  }
+  
+  // 其它阶段方法...
+  // afterRouterMapBuilding
+  // afterConfigUpdate
+  // afterObfuscationProcess
+  // afterResourceProcess
+  // afterCompletion
+}
+```
+
+> 如需要进行自定义解析，请将`ts-morph`加入到`hvigor-config.json`依赖中
 
-见[插件扩展指南](https://gitcode.com/openharmony-sig/ohrouter/blob/master/docs/PluginExtension.md)
+### 注册扩展
+```typescript
+import { appTasks } from '@ohos/hvigor-ohos-plugin';
+import { registerPluginExtension } from '@hadss/hmrouter-plugin';
+import { MyCustomExtension } from './MyCustomExtension';
+import { appPlugin } from "@hadss/hmrouter-plugin";
+
+// 注册扩展实例
+registerPluginExtension(new MyCustomExtension());
+
+export default {
+  system: appTasks,
+  plugins: [appPlugin({ ignoreModuleNames: [] })]
+};
+```
+
+> 更多使用介绍请访问[插件扩展](https://gitcode.com/openharmony-sig/ohrouter/blob/master/docs/PluginExtension.md)
 
 ## 编译产物
 
@@ -393,6 +436,33 @@ hvigor 5.7.3及以上
 > [HMRouterPlugin] Your DevEco Studio version less than 5.0.3.800, may cause remote hsp dependencies get failed
 > ```
 
+## 更新日志
+
+### 1.2.0-beta.1 (2025.07.29)
+
+- 修复相同组件名称冲突的问题
+- 修复默认模版的问题
+- 修复ohosTest编译错误
+- 修复oh-package.json5含注解的编译错误
+- 修复自动混淆问题
+
+### 1.2.0-beta.0 (2025.06.17)
+
+- 新增插件扩展能力
+- 修复了路由表生成与hvigor编译流程冲突的问题
+
+### 1.1.0-beta.0 (2025.04.11)
+
+- 更新了自定义模版，支持原生组件接入
+
+### 1.0.0-rc.9 (2024.10.09)
+
+- 支持自定义页面模版配置`customPageTemplate`
+
+### 1.0.0-rc.6 (2024.09.27)
+
+- 新增自动混淆配置参数`autoObfuscation`，开启可以自动配置HMRouter混淆白名单
+
 ## 常见问题
 
 ### 编译失败，提示重复的routerMap对象名称

package/dist/HMRouterPluginManager.d.ts

@@ -2,8 +2,10 @@ import { HvigorNode } from '@ohos/hvigor';
 import { PluginParam } from './Index';
 export declare class HMRouterPluginManager {
     private static instance;
-    private controllerSet;
+    private controllerMap;
+    private moduleNodes;
     private constructor();
     static getInstance(): HMRouterPluginManager;
     registerPlugin(node: HvigorNode, pluginId: string, options: PluginParam): void;
+    addModuleNode(node: HvigorNode): void;
 }

package/dist/HMRouterPluginManager.js

@@ -7,22 +7,30 @@ const HMRouterExtension_1 = require("./hmrouter_extension/HMRouterExtension");
 const framework_1 = require("./framework");
 class HMRouterPluginManager {
     constructor() {
-        this.controllerSet = new Set();
+        this.controllerMap = new Map();
+        this.moduleNodes = [];
         framework_1.Logger.info('', 'HMRouterPlugin starting...');
         (0, framework_1.registerPluginExtension)(new HMRouterExtension_1.HMRouterDefaultExtension());
         hvigor_1.hvigor.nodesEvaluated(() => {
-            this.controllerSet.forEach((controller) => {
-                controller.start();
+            this.moduleNodes.forEach((node) => {
+                if (this.controllerMap.has(node.getNodeName()))
+                    return;
+                node.getAllPluginIds().forEach((pluginId) => {
+                    this.registerPlugin(node, pluginId, {});
+                });
             });
+            for (const [_key, controller] of this.controllerMap) {
+                controller.start();
+            }
         });
         hvigor_1.hvigor.buildFinished(() => {
-            this.controllerSet.forEach((controller) => {
+            this.controllerMap.forEach((controller) => {
                 controller.complete();
             });
             HMRouterPluginManager.instance = null;
             framework_1.PluginStore.destroy();
             framework_1.ExtensionManager.destroy();
-            this.controllerSet.clear();
+            this.controllerMap.clear();
             framework_1.TsAstUtil.clearProject();
         });
     }
@@ -38,18 +46,28 @@ class HMRouterPluginManager {
             throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.ERROR_CONFIG, node.getNodeName(), node.getNodePath());
         }
         const controller = new framework_1.PluginExecutionController(node, moduleContext, options.extensions);
-        this.controllerSet.add(controller);
+        this.controllerMap.set(node.getNodeName(), controller);
         if ((0, framework_1.isHspModule)(node)) {
             let packageJsonPath = framework_1.PluginFileUtil.pathResolve(node.getNodePath(), 'oh-package.json5');
-            let packageJsonContent = framework_1.PluginFileUtil.readFileSync(packageJsonPath);
-            let packageJson = JSON.parse(packageJsonContent.toString());
+            let packageJson = framework_1.PluginFileUtil.readJson5(packageJsonPath);
             let hspNameArr = framework_1.PluginStore.getInstance().get('hspModuleNames');
             if (!hspNameArr) {
                 framework_1.PluginStore.getInstance().set('hspModuleNames', []);
             }
+            let hspModulesInfo = framework_1.PluginStore.getInstance().get('hspModulesInfo');
+            if (!hspModulesInfo) {
+                framework_1.PluginStore.getInstance().set('hspModulesInfo', []);
+            }
             framework_1.PluginStore.getInstance().get('hspModuleNames')?.push(packageJson.name);
+            framework_1.PluginStore.getInstance().get('hspModulesInfo')?.push({
+                moduleName: node.getNodeName(),
+                packageName: packageJson.name
+            });
         }
     }
+    addModuleNode(node) {
+        this.moduleNodes.push(node);
+    }
 }
 exports.HMRouterPluginManager = HMRouterPluginManager;
 HMRouterPluginManager.instance = null;

package/dist/Index.d.ts

@@ -5,6 +5,11 @@ export * from './framework/extension';
 export interface PluginParam {
     extensions?: PluginExtension[];
 }
+export interface AppPluginParam {
+    ignoreModuleNames: string[];
+}
 export declare function hapPlugin(options?: PluginParam): HvigorPlugin;
 export declare function hspPlugin(options?: PluginParam): HvigorPlugin;
 export declare function harPlugin(options?: PluginParam): HvigorPlugin;
+export declare function modulePlugin(options?: PluginParam): HvigorPlugin;
+export declare function appPlugin(options: AppPluginParam): HvigorPlugin;

package/dist/Index.js

@@ -14,7 +14,7 @@ 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.harPlugin = exports.hspPlugin = exports.hapPlugin = void 0;
+exports.appPlugin = exports.modulePlugin = exports.harPlugin = exports.hspPlugin = exports.hapPlugin = void 0;
 const hvigor_ohos_plugin_1 = require("@ohos/hvigor-ohos-plugin");
 const constants_1 = require("./hmrouter_extension/constants");
 const HMRouterPluginManager_1 = require("./HMRouterPluginManager");
@@ -47,3 +47,31 @@ function harPlugin(options = {}) {
     };
 }
 exports.harPlugin = harPlugin;
+function modulePlugin(options = {}) {
+    return {
+        pluginId: constants_1.PluginConstants.HAP_PLUGIN_ID,
+        apply(node) {
+            node.getAllPluginIds().forEach((pluginId) => {
+                HMRouterPluginManager_1.HMRouterPluginManager.getInstance().registerPlugin(node, pluginId, options);
+            });
+        },
+    };
+}
+exports.modulePlugin = modulePlugin;
+function appPlugin(options) {
+    return {
+        pluginId: constants_1.PluginConstants.HAP_PLUGIN_ID,
+        apply(node) {
+            if (!options) {
+                throw new Error('No options provided');
+            }
+            node.subNodes(subNode => {
+                if (options.ignoreModuleNames.includes(subNode.getNodeName())) {
+                    return;
+                }
+                HMRouterPluginManager_1.HMRouterPluginManager.getInstance().addModuleNode(subNode);
+            });
+        },
+    };
+}
+exports.appPlugin = appPlugin;

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

@@ -7,9 +7,20 @@ export declare class PluginExecutionController {
     private readonly taskManager;
     private readonly baseContext;
     private extensionContextCache;
+    private originalBuilderDir?;
     constructor(node: HvigorNode, moduleContext: OhosModuleContext, moduleExtensions?: PluginExtension[]);
     start(): void;
     complete(): void;
     private initializeContext;
     private registerHvigorTasks;
+    private filterScanFilesForTarget;
+    private backupScanFiles;
+    private restoreScanFiles;
+    private backupConfig;
+    private restoreConfig;
+    private adjustConfigForTarget;
+    private registerMainPluginTask;
+    private registerObfuscationTask;
+    private registerCopyRouterMapTask;
+    private getTaskName;
 }

package/dist/framework/core/PluginExecutionController.js

@@ -5,6 +5,7 @@ const TaskManager_1 = require("./TaskManager");
 const TaskStage_1 = require("./TaskStage");
 const constants_1 = require("../constants");
 const extension_1 = require("../extension");
+const utils_1 = require("../utils");
 class PluginExecutionController {
     constructor(node, moduleContext, moduleExtensions) {
         this.extensionContextCache = new Map();
@@ -28,35 +29,141 @@ class PluginExecutionController {
     registerHvigorTasks() {
         this.moduleContext.targets((target) => {
             const targetName = target.getTargetName();
-            this.node.registerTask({
-                name: targetName + constants_1.TaskConstants.PLUGIN_TASK,
-                run: () => {
+            this.taskManager.context.currentTarget = target;
+            this.registerMainPluginTask(targetName);
+            this.registerObfuscationTask(targetName);
+            if ((0, utils_1.isHapModule)(this.node) || (0, utils_1.isHspModule)(this.node)) {
+                this.registerCopyRouterMapTask(targetName);
+            }
+        });
+    }
+    filterScanFilesForTarget() {
+        const currentTargetName = this.taskManager.context.currentTarget?.getTargetName();
+        if (!currentTargetName) {
+            return;
+        }
+        const buildProfileTargets = this.moduleContext.getBuildProfileOpt().targets || [];
+        const targetOpt = buildProfileTargets.find((target) => target.name === currentTargetName);
+        if (!targetOpt?.source?.sourceRoots || targetOpt.source.sourceRoots.length === 0) {
+            return;
+        }
+        const moduleRoot = this.moduleContext.getModulePath();
+        const absoluteSourceRoots = targetOpt.source.sourceRoots.map((sourceRoot) => {
+            const absolutePath = utils_1.PluginFileUtil.resolve(moduleRoot, sourceRoot);
+            const normalizedPath = utils_1.PluginFileUtil.normalize(absolutePath);
+            return normalizedPath.endsWith(utils_1.PluginFileUtil.sep) ? normalizedPath : normalizedPath + utils_1.PluginFileUtil.sep;
+        });
+        this.baseContext.scanFiles = this.baseContext.scanFiles.filter((filePath) => {
+            const normalizedFilePath = utils_1.PluginFileUtil.normalize(filePath);
+            return absoluteSourceRoots.some((sourceRootPath) => {
+                return normalizedFilePath.startsWith(sourceRootPath);
+            });
+        });
+    }
+    backupScanFiles() {
+        return [...this.baseContext.scanFiles];
+    }
+    restoreScanFiles(backup) {
+        this.baseContext.scanFiles = backup;
+    }
+    backupConfig() {
+        const hmrouterContext = this.taskManager.context;
+        if (hmrouterContext.config && hmrouterContext.config.builderDir) {
+            this.originalBuilderDir = hmrouterContext.config.builderDir;
+        }
+    }
+    restoreConfig() {
+        if (this.originalBuilderDir) {
+            const hmrouterContext = this.taskManager.context;
+            if (hmrouterContext.config) {
+                hmrouterContext.config.builderDir = this.originalBuilderDir;
+            }
+            this.originalBuilderDir = undefined;
+        }
+    }
+    adjustConfigForTarget() {
+        const currentTargetName = this.taskManager.context.currentTarget?.getTargetName();
+        if (!currentTargetName) {
+            return;
+        }
+        const buildProfileTargets = this.moduleContext.getBuildProfileOpt().targets || [];
+        const targetOpt = buildProfileTargets.find((target) => target.name === currentTargetName);
+        if (!targetOpt?.source?.sourceRoots || targetOpt.source.sourceRoots.length === 0) {
+            return;
+        }
+        const hmrouterContext = this.taskManager.context;
+        if (!hmrouterContext.config || !hmrouterContext.config.builderDir) {
+            return;
+        }
+        const firstSourceRoot = targetOpt.source.sourceRoots[0];
+        const cleanSourceRoot = firstSourceRoot.replace(/^\.\//, '');
+        hmrouterContext.config.builderDir = `${cleanSourceRoot}/ets/generated`;
+    }
+    registerMainPluginTask(targetName) {
+        this.node.registerTask({
+            name: this.getTaskName(targetName, constants_1.TaskConstants.PLUGIN_TASK),
+            run: () => {
+                const scanFilesBackup = this.backupScanFiles();
+                try {
+                    this.backupConfig();
+                    this.filterScanFilesForTarget();
+                    this.adjustConfigForTarget();
                     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: () => {
+                }
+                finally {
+                    this.restoreConfig();
+                    this.restoreScanFiles(scanFilesBackup);
+                }
+            },
+            dependencies: [],
+            postDependencies: [this.getTaskName(targetName, constants_1.TaskConstants.PRE_BUILD)],
+        });
+    }
+    registerObfuscationTask(targetName) {
+        this.node.registerTask({
+            name: this.getTaskName(targetName, constants_1.TaskConstants.GENERATE_OBFUSCATION_TASK),
+            run: () => {
+                const scanFilesBackup = this.backupScanFiles();
+                try {
+                    this.backupConfig();
+                    this.filterScanFilesForTarget();
+                    this.adjustConfigForTarget();
                     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;
+                }
+                finally {
+                    this.restoreConfig();
+                    this.restoreScanFiles(scanFilesBackup);
+                }
+            },
+            dependencies: [this.getTaskName(targetName, constants_1.TaskConstants.PLUGIN_TASK)],
+            postDependencies: [this.getTaskName(targetName, constants_1.TaskConstants.PRE_BUILD)],
+        });
+    }
+    registerCopyRouterMapTask(targetName) {
+        this.node.registerTask({
+            name: this.getTaskName(targetName, constants_1.TaskConstants.COPY_ROUTER_MAP_TASK),
+            run: () => {
+                const scanFilesBackup = this.backupScanFiles();
+                try {
+                    this.backupConfig();
+                    this.filterScanFilesForTarget();
+                    this.adjustConfigForTarget();
                     this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_RESOURCE_PROCESS);
-                },
-                dependencies: [targetName + constants_1.TaskConstants.PROCESS_ROUTER_MAP],
-                postDependencies: [targetName + constants_1.TaskConstants.PROCESS_RESOURCE],
-            });
+                }
+                finally {
+                    this.restoreConfig();
+                    this.restoreScanFiles(scanFilesBackup);
+                }
+            },
+            dependencies: [this.getTaskName(targetName, constants_1.TaskConstants.PROCESS_ROUTER_MAP)],
+            postDependencies: [this.getTaskName(targetName, constants_1.TaskConstants.PROCESS_RESOURCE)],
         });
     }
+    getTaskName(targetName, taskConstant) {
+        return targetName + taskConstant;
+    }
 }
 exports.PluginExecutionController = PluginExecutionController;

package/dist/framework/core/TaskManager.js

@@ -24,14 +24,15 @@ class TaskManager {
         }
     }
     executeAnnotationAnalysis() {
-        const analyzers = this.getExtensions()
-            .map((extension) => extension.afterAnnotationAnalysis || null);
+        const extensions = this.getExtensions();
         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);
-            }
+            extensions.forEach((extension) => {
+                if (extension.afterAnnotationAnalysis) {
+                    extension.afterAnnotationAnalysis(sourceFile, file, this.context);
+                }
+            });
         });
         this.context.setCurrentFilePath('');
         this.validateTemplateData();

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

@@ -3,6 +3,7 @@
 import { FileUtil } from '@ohos/hvigor';
 import fs from 'fs';
 export declare class PluginFileUtil extends FileUtil {
+    static readonly sep: "\\" | "/";
     static rmSync(path: fs.PathLike, options?: fs.RmOptions): void;
     static unlinkSync(path: fs.PathLike): void;
     static readdirSync(path: fs.PathLike, options?: {
@@ -10,4 +11,7 @@ export declare class PluginFileUtil extends FileUtil {
         withFileTypes?: false | undefined;
         recursive?: boolean | undefined;
     }): string[];
+    static normalize(filePath: string): string;
+    static resolve(...paths: string[]): string;
+    static join(...paths: string[]): string;
 }

package/dist/framework/utils/FileUtil.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginFileUtil = void 0;
 const hvigor_1 = require("@ohos/hvigor");
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 class PluginFileUtil extends hvigor_1.FileUtil {
     static rmSync(path, options) {
         return fs_1.default.rmSync(path, options);
@@ -16,5 +17,15 @@ class PluginFileUtil extends hvigor_1.FileUtil {
     static readdirSync(path, options) {
         return fs_1.default.readdirSync(path, options);
     }
+    static normalize(filePath) {
+        return path_1.default.normalize(filePath);
+    }
+    static resolve(...paths) {
+        return path_1.default.resolve(...paths);
+    }
+    static join(...paths) {
+        return path_1.default.join(...paths);
+    }
 }
 exports.PluginFileUtil = PluginFileUtil;
+PluginFileUtil.sep = path_1.default.sep;

package/dist/hmrouter_extension/HMRouterExtension.d.ts

@@ -5,6 +5,7 @@ export declare class HMRouterDefaultExtension extends PluginExtension<HMRouterEx
     get name(): string;
     afterInitialize(context: HMRouterExtensionContext): void;
     afterAnnotationAnalysis(sourceFile: SourceFile, filePath: string, context: HMRouterExtensionContext): void;
+    private executeConstantParsing;
     afterCodeGeneration(context: HMRouterExtensionContext): void;
     afterRouterMapBuilding(context: HMRouterExtensionContext): void;
     afterConfigUpdate(context: HMRouterExtensionContext): void;