@hadss/hmrouter-plugin 1.2.2 → 1.2.3-rc.1

package/README.md

@@ -16,12 +16,14 @@ HMRouter编译插件是一个基于hvigor的编译插件，用于：
 
 ### 工程级配置
 
+***插件版本建议和库的版本保持一致***
+
 在工程的`hvigor/hvigor-config.json`文件中添加路由编译插件：
 
 ```json5
 {
   "dependencies": {
-    "@hadss/hmrouter-plugin": "^1.2.2"  // 使用最新版本
+    "@hadss/hmrouter-plugin": "^1.2.3-rc.1"  // 使用最新版本
   },
   // ...其余配置
 }
@@ -438,6 +440,14 @@ hvigor 5.7.3及以上
 
 ## 更新日志
 
+### 1.2.3-rc.1 (2026.01.15)
+
+- [修复插件编译报错路由常量找不到问题](https://gitcode.com/openharmony-sig/ohrouter/issues/207)
+
+### 1.2.3-rc.0 (2025.12.11)
+
+- [修复库版本与插件版本不匹配时编译报错的问题](https://gitcode.com/openharmony-sig/ohrouter/issues/250)
+
 ### 1.2.2 (2025.10.24)
 
 - [修复系统路由表合并异常的问题](https://gitcode.com/openharmony-sig/ohrouter/issues/215)

package/dist/HMRouterPluginManager.d.ts

@@ -9,4 +9,5 @@ export declare class HMRouterPluginManager {
     static getInstance(): HMRouterPluginManager;
     registerPlugin(node: HvigorNode, pluginId: string, options: PluginParam): void;
     addModuleNode(node: HvigorNode, isIgnored: boolean): void;
+    private initializeArkAnalyzer;
 }

package/dist/HMRouterPluginManager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HMRouterPluginManager = void 0;
 const hvigor_1 = require("@ohos/hvigor");
+const hvigor_ohos_plugin_1 = require("@ohos/hvigor-ohos-plugin");
 const PluginError_1 = require("./hmrouter_extension/error/PluginError");
 const HMRouterExtension_1 = require("./hmrouter_extension/HMRouterExtension");
 const framework_1 = require("./framework");
@@ -13,6 +14,7 @@ class HMRouterPluginManager {
         framework_1.Logger.info('', 'HMRouterPlugin starting...');
         (0, framework_1.registerPluginExtension)(new HMRouterExtension_1.HMRouterDefaultExtension());
         hvigor_1.hvigor.nodesEvaluated(() => {
+            this.initializeArkAnalyzer();
             this.moduleNodes.forEach((node) => {
                 if (this.controllerMap.has(node.getNodeName())) {
                     return;
@@ -29,6 +31,7 @@ class HMRouterPluginManager {
             this.controllerMap.forEach((controller) => {
                 controller.complete();
             });
+            framework_1.ArkAnalyzerUtil.clear();
             HMRouterPluginManager.instance = null;
             framework_1.PluginStore.destroy();
             framework_1.ExtensionManager.destroy();
@@ -73,6 +76,18 @@ class HMRouterPluginManager {
             this.nodeIgnored.add(node.getNodeName());
         }
     }
+    initializeArkAnalyzer() {
+        if (this.moduleNodes.length === 0) {
+            return;
+        }
+        const firstNode = this.moduleNodes[0];
+        const appContext = firstNode.getParentNode()?.getContext(hvigor_ohos_plugin_1.OhosPluginId.OHOS_APP_PLUGIN);
+        if (appContext) {
+            const projectPath = appContext.getProjectPath();
+            framework_1.Logger.info('', `Initializing ArkAnalyzer for project: ${projectPath}`);
+            framework_1.ArkAnalyzerUtil.initialize(projectPath);
+        }
+    }
 }
 exports.HMRouterPluginManager = HMRouterPluginManager;
 HMRouterPluginManager.instance = null;

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

@@ -0,0 +1,24 @@
+export declare class ArkAnalyzerUtil {
+    private static instance;
+    private scene;
+    private isInitialized;
+    private constructor();
+    static getInstance(): ArkAnalyzerUtil;
+    init(projectRoot: string): boolean;
+    isReady(): boolean;
+    findVariableFilePath(moduleName: string, variableName: string): string | undefined;
+    private findModuleSceneByName;
+    private getAllModuleScenes;
+    private findInModuleScene;
+    private findInAllFiles;
+    private isModuleMatch;
+    private findExportInFile;
+    private traceToDefinition;
+    private findFileByPath;
+    private normalizeModuleName;
+    clear(): void;
+    static isReady(): boolean;
+    static findVariableFilePath(moduleName: string, variableName: string): string | undefined;
+    static initialize(projectRoot: string): void;
+    static clear(): void;
+}

package/dist/framework/utils/ArkAnalyzerUtil.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkAnalyzerUtil = void 0;
+const arkanalyzer_1 = require("arkanalyzer");
+const Logger_1 = require("./Logger");
+const path_1 = __importDefault(require("path"));
+class ArkAnalyzerUtil {
+    constructor() {
+        this.scene = null;
+        this.isInitialized = false;
+    }
+    static getInstance() {
+        if (!ArkAnalyzerUtil.instance) {
+            ArkAnalyzerUtil.instance = new ArkAnalyzerUtil();
+        }
+        return ArkAnalyzerUtil.instance;
+    }
+    init(projectRoot) {
+        if (this.isInitialized) {
+            return true;
+        }
+        try {
+            this.scene = new arkanalyzer_1.Scene();
+            const options = {
+                supportFileExts: ['.ets', '.d.ets'],
+                projectName: 'HMRouterProject'
+            };
+            const config = new arkanalyzer_1.SceneConfig(options);
+            config.buildFromProjectDir(projectRoot);
+            this.scene.buildSceneFromProjectDir(config);
+            this.scene.buildScene4HarmonyProject();
+            this.scene.inferTypes();
+            this.isInitialized = true;
+            Logger_1.Logger.info('ArkAnalyzerUtil', 'Initialized successfully');
+            return true;
+        }
+        catch (e) {
+            Logger_1.Logger.error('ArkAnalyzerUtil', `Failed to initialize: ${e}`);
+            return false;
+        }
+    }
+    isReady() {
+        return this.isInitialized && this.scene !== null;
+    }
+    findVariableFilePath(moduleName, variableName) {
+        if (!this.scene) {
+            throw new Error('ArkAnalyzer scene not initialized');
+        }
+        const moduleScene = this.findModuleSceneByName(moduleName);
+        if (moduleScene) {
+            const result = this.findInModuleScene(moduleScene, variableName);
+            if (result) {
+                return result;
+            }
+        }
+        return this.findInAllFiles(moduleName, variableName);
+    }
+    findModuleSceneByName(moduleName) {
+        if (!this.scene) {
+            return undefined;
+        }
+        let moduleScene = this.scene.getModuleScene(moduleName);
+        if (moduleScene) {
+            return moduleScene;
+        }
+        const allScenes = this.getAllModuleScenes();
+        moduleScene = allScenes.find(scene => scene.getModuleName().toLowerCase() === moduleName.toLowerCase());
+        if (moduleScene) {
+            return moduleScene;
+        }
+        const normalizedModuleName = this.normalizeModuleName(moduleName);
+        if (normalizedModuleName !== moduleName) {
+            moduleScene = allScenes.find(scene => {
+                const sceneName = scene.getModuleName();
+                const normalizedSceneName = this.normalizeModuleName(sceneName);
+                return normalizedSceneName.toLowerCase() === normalizedModuleName.toLowerCase();
+            });
+        }
+        return moduleScene;
+    }
+    getAllModuleScenes() {
+        if (!this.scene) {
+            return [];
+        }
+        const scenes = [];
+        const files = this.scene.getFiles();
+        const seenScenes = new Set();
+        for (const file of files) {
+            const moduleScene = file.getModuleScene();
+            if (moduleScene && !seenScenes.has(moduleScene)) {
+                seenScenes.add(moduleScene);
+                scenes.push(moduleScene);
+            }
+        }
+        return scenes;
+    }
+    findInModuleScene(moduleScene, variableName) {
+        const filesMap = moduleScene.getModuleFilesMap();
+        for (const [, arkFile] of filesMap) {
+            const exportInfos = arkFile.getExportInfos();
+            for (const exportInfo of exportInfos) {
+                if (exportInfo.getExportClauseName() === variableName) {
+                    return this.traceToDefinition(exportInfo, arkFile);
+                }
+            }
+        }
+        return undefined;
+    }
+    findInAllFiles(moduleName, variableName) {
+        const normalizedModuleName = this.normalizeModuleName(moduleName);
+        const files = this.scene.getFiles();
+        for (const arkFile of files) {
+            if (!this.isModuleMatch(arkFile, moduleName, normalizedModuleName)) {
+                continue;
+            }
+            const result = this.findExportInFile(arkFile, variableName);
+            if (result) {
+                return result;
+            }
+        }
+        return undefined;
+    }
+    isModuleMatch(arkFile, moduleName, normalizedModuleName) {
+        const fileModuleName = arkFile.getModuleName() || arkFile.getModuleScene()?.getModuleName() || '';
+        const normalizedFileModule = this.normalizeModuleName(fileModuleName);
+        if (fileModuleName === moduleName) {
+            return true;
+        }
+        if (fileModuleName.toLowerCase() === moduleName.toLowerCase()) {
+            return true;
+        }
+        if (normalizedFileModule.toLowerCase() === normalizedModuleName.toLowerCase()) {
+            return true;
+        }
+        return false;
+    }
+    findExportInFile(arkFile, variableName) {
+        const exportInfos = arkFile.getExportInfos();
+        for (const exportInfo of exportInfos) {
+            if (exportInfo.getExportClauseName() === variableName) {
+                return this.traceToDefinition(exportInfo, arkFile);
+            }
+        }
+        return undefined;
+    }
+    traceToDefinition(exportInfo, currentFile) {
+        const fromPath = exportInfo.getFrom();
+        if (!fromPath) {
+            return currentFile.getFilePath();
+        }
+        const currentDir = path_1.default.dirname(currentFile.getFilePath());
+        let targetPath = path_1.default.resolve(currentDir, fromPath);
+        if (!targetPath.endsWith('.ets') && !targetPath.endsWith('.d.ets')) {
+            targetPath += '.ets';
+        }
+        const targetFile = this.findFileByPath(targetPath);
+        if (!targetFile) {
+            return currentFile.getFilePath();
+        }
+        const variableName = exportInfo.getNameBeforeAs() || exportInfo.getExportClauseName();
+        const targetExports = targetFile.getExportInfos();
+        for (const targetExport of targetExports) {
+            if (targetExport.getExportClauseName() === variableName) {
+                return this.traceToDefinition(targetExport, targetFile);
+            }
+        }
+        return targetFile.getFilePath();
+    }
+    findFileByPath(filePath) {
+        const files = this.scene.getFiles();
+        for (const arkFile of files) {
+            if (arkFile.getFilePath() === filePath) {
+                return arkFile;
+            }
+        }
+        return undefined;
+    }
+    normalizeModuleName(moduleName) {
+        if (moduleName.startsWith('@')) {
+            const parts = moduleName.split('/');
+            return parts.length >= 2 ? parts[1] : moduleName;
+        }
+        return moduleName;
+    }
+    clear() {
+        if (this.scene) {
+            this.scene.dispose();
+            this.scene = null;
+        }
+        this.isInitialized = false;
+    }
+    static isReady() {
+        return ArkAnalyzerUtil.getInstance().isReady();
+    }
+    static findVariableFilePath(moduleName, variableName) {
+        return ArkAnalyzerUtil.getInstance().findVariableFilePath(moduleName, variableName);
+    }
+    static initialize(projectRoot) {
+        ArkAnalyzerUtil.getInstance().init(projectRoot);
+    }
+    static clear() {
+        ArkAnalyzerUtil.getInstance().clear();
+    }
+}
+exports.ArkAnalyzerUtil = ArkAnalyzerUtil;

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

@@ -5,3 +5,4 @@ export * from './ModuleTypeUtil';
 export * from './StringUtil';
 export * from './ObjectUtils';
 export * from './Logger';
+export * from './ArkAnalyzerUtil';

package/dist/framework/utils/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./ModuleTypeUtil"), exports);
 __exportStar(require("./StringUtil"), exports);
 __exportStar(require("./ObjectUtils"), exports);
 __exportStar(require("./Logger"), exports);
+__exportStar(require("./ArkAnalyzerUtil"), exports);

package/dist/hmrouter_extension/HMRouterExtension.js

@@ -19,7 +19,7 @@ class HMRouterDefaultExtension extends framework_1.PluginExtension {
             framework_2.Logger.debug(this.name, 'module ignored: annotationAnalysis');
             return;
         }
-        AnnotationAnalyzerRegistry_1.AnnotationAnalyzerRegistry.getInstance().initialize(context.config.modulePath);
+        AnnotationAnalyzerRegistry_1.AnnotationAnalyzerRegistry.getInstance().initialize();
         const analyzers = AnnotationAnalyzerRegistry_1.AnnotationAnalyzerRegistry.getInstance().getAnalyzers();
         for (const analyzer of analyzers) {
             analyzer.analyze(sourceFile, filePath, context);

package/dist/hmrouter_extension/analyzer/AnnotationAnalyzerRegistry.d.ts

@@ -6,7 +6,7 @@ export declare class AnnotationAnalyzerRegistry {
     private constantResolver;
     private constructor();
     static getInstance(): AnnotationAnalyzerRegistry;
-    initialize(modulePath: string): void;
+    initialize(): void;
     registerAnalyzer(analyzer: AbstractAnnotationAnalyzer): void;
     getAnalyzers(): AbstractAnnotationAnalyzer[];
     getConstantResolver(): IConstantResolver;

package/dist/hmrouter_extension/analyzer/AnnotationAnalyzerRegistry.js

@@ -15,11 +15,11 @@ class AnnotationAnalyzerRegistry {
         }
         return this.instance;
     }
-    initialize(modulePath) {
+    initialize() {
         if (this.constantResolver) {
             return;
         }
-        this.constantResolver = new ConstantResolver_1.ConstantResolver(modulePath);
+        this.constantResolver = new ConstantResolver_1.ConstantResolver();
         this.registerDefaultAnalyzers();
     }
     registerAnalyzer(analyzer) {

package/dist/hmrouter_extension/analyzer/utils/ConstantResolver.d.ts

@@ -2,14 +2,10 @@ import { Expression, SourceFile } from 'ts-morph';
 import { IConstantResolver } from '../interface/IConstantResolver';
 export declare class ConstantResolver implements IConstantResolver {
     private importMapCache;
-    private readonly modulePath;
-    constructor(modulePath: string);
     resolveConstant(value: any, sourceFile: SourceFile, filePath: string): any;
     resolvePropertyValue(value: Expression, sourceFile: SourceFile, filePath: string): any;
     getVariableFilePath(variableName: string, sourceFile: SourceFile, filePath: string): string;
-    getOtherModuleVariableFilePath(moduleName: string, variableName: string, modulePath: string): string;
+    getOtherModuleVariableFilePath(moduleName: string, variableName: string): string;
     private parsePrimitiveValue;
     private parseConstantValue;
-    private parseCrossModuleVariable;
-    getExportedVariables(sourceFile: SourceFile): string[];
 }

package/dist/hmrouter_extension/analyzer/utils/ConstantResolver.js

@@ -7,9 +7,8 @@ const constants_1 = require("../../constants");
 const ImportAnalyzer_1 = require("./ImportAnalyzer");
 const PluginError_1 = require("../../error/PluginError");
 class ConstantResolver {
-    constructor(modulePath) {
+    constructor() {
         this.importMapCache = new Map();
-        this.modulePath = modulePath;
     }
     resolveConstant(value, sourceFile, filePath) {
         if (value.type === 'constant') {
@@ -87,33 +86,18 @@ class ConstantResolver {
         if (!resultPath) {
             for (const [importPath, importNames] of importMap.entries()) {
                 if (importNames.includes(variableName)) {
-                    resultPath = this.getOtherModuleVariableFilePath(importPath, variableName, this.modulePath);
+                    resultPath = this.getOtherModuleVariableFilePath(importPath, variableName);
                     break;
                 }
             }
         }
         return resultPath;
     }
-    getOtherModuleVariableFilePath(moduleName, variableName, modulePath) {
-        let moduleFilePath = framework_1.PluginFileUtil.pathResolve(modulePath, constants_1.FilePathConstants.OH_MODULE_PATH, moduleName, constants_1.FilePathConstants.DEFAULT_SCAN_DIR);
-        if (!framework_1.PluginFileUtil.exist(moduleFilePath)) {
-            moduleFilePath = framework_1.PluginFileUtil.pathResolve(framework_1.PluginStore.getInstance().get('projectFilePath'), constants_1.FilePathConstants.OH_MODULE_PATH, moduleName, constants_1.FilePathConstants.DEFAULT_SCAN_DIR);
-        }
-        const variableCache = framework_1.PluginStore.getInstance().get('variableCache');
-        if (!variableCache) {
-            framework_1.PluginStore.getInstance().set('variableCache', new Map());
-        }
-        let variableMap;
-        if (variableCache?.has(moduleName)) {
-            variableMap = variableCache.get(moduleName);
-        }
-        else {
-            variableMap = this.parseCrossModuleVariable(moduleFilePath);
-            variableCache?.set(moduleName, variableMap);
-        }
-        for (let [key, value] of variableMap) {
-            if (value.includes(variableName)) {
-                return key;
+    getOtherModuleVariableFilePath(moduleName, variableName) {
+        if (framework_1.ArkAnalyzerUtil.isReady()) {
+            const filePath = framework_1.ArkAnalyzerUtil.findVariableFilePath(moduleName, variableName);
+            if (filePath) {
+                return filePath;
             }
         }
         throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.UNKNOWN_VARIABLE, '', variableName);
@@ -177,41 +161,5 @@ class ConstantResolver {
         }
         return resultValue;
     }
-    parseCrossModuleVariable(scanDir) {
-        let sourceFiles = framework_1.TsAstUtil.project.addSourceFilesAtPaths(`${scanDir}/**/*.ets`);
-        const exportMap = new Map();
-        for (let sourceFile of sourceFiles) {
-            const exportedNames = this.getExportedVariables(sourceFile);
-            if (exportedNames.length > 0) {
-                exportMap.set(sourceFile.getFilePath(), exportedNames);
-            }
-        }
-        return exportMap;
-    }
-    getExportedVariables(sourceFile) {
-        const exportSymbols = [];
-        let exportKeywordNodes = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ExportKeyword);
-        exportKeywordNodes.forEach((node) => {
-            let parentNodeKind = node.getParent()?.getKind();
-            switch (parentNodeKind) {
-                case ts_morph_1.SyntaxKind.VariableStatement:
-                    let variableStatement = node.getParent()?.asKind(ts_morph_1.SyntaxKind.VariableStatement);
-                    let variableNames = variableStatement
-                        .getDeclarationList()
-                        .getDeclarations()
-                        .map((declaration) => {
-                        return declaration.getName();
-                    });
-                    exportSymbols.push(...variableNames);
-                    break;
-                case ts_morph_1.SyntaxKind.ClassDeclaration:
-                    let classDeclaration = node.getParent();
-                    let className = classDeclaration?.asKind(ts_morph_1.SyntaxKind.ClassDeclaration)?.getName();
-                    exportSymbols.push(className);
-                    break;
-            }
-        });
-        return exportSymbols;
-    }
 }
 exports.ConstantResolver = ConstantResolver;

package/dist/hmrouter_extension/constants/FilePathConstants.d.ts

@@ -12,6 +12,7 @@ export default class FilePathConstants {
     static readonly CURRENT_DELIMITER = "./";
     static readonly OH_MODULE_PATH = "oh_modules";
     static readonly OH_PACKAGE_FILE_NAME = "oh-package.json5";
+    static readonly OH_PACKAGE_LOCK_FILE_NAME = "oh-package-lock.json5";
     static readonly LINE_BREAK = "\n";
     static readonly BUILD_PROFILE = "build-profile.json5";
     static readonly SDK_HOME = "default/openharmony/ets/oh-uni-package.json";

package/dist/hmrouter_extension/constants/FilePathConstants.js

@@ -20,6 +20,7 @@ FilePathConstants.PARENT_DELIMITER = '../';
 FilePathConstants.CURRENT_DELIMITER = './';
 FilePathConstants.OH_MODULE_PATH = 'oh_modules';
 FilePathConstants.OH_PACKAGE_FILE_NAME = 'oh-package.json5';
+FilePathConstants.OH_PACKAGE_LOCK_FILE_NAME = 'oh-package-lock.json5';
 FilePathConstants.LINE_BREAK = '\n';
 FilePathConstants.BUILD_PROFILE = 'build-profile.json5';
 FilePathConstants.SDK_HOME = 'default/openharmony/ets/oh-uni-package.json';

package/dist/hmrouter_extension/constants/TemplateConstants.d.ts

@@ -2,5 +2,6 @@ export default class TemplateConstants {
     static readonly CUSTOM_BUILDER_TEMPLATE = "template/customBuilder.ejs";
     static readonly VIEW_BUILDER_TEMPLATE = "template/viewBuilder.ejs";
     static readonly V1_TEMPLATE = "template/viewBuilder_v1.ejs";
+    static readonly V1_1_TEMPLATE = "template/viewBuilder_v1_1.ejs";
     static readonly WARP_BUILDER = "WrapBuilder";
 }

package/dist/hmrouter_extension/constants/TemplateConstants.js

@@ -6,4 +6,5 @@ exports.default = TemplateConstants;
 TemplateConstants.CUSTOM_BUILDER_TEMPLATE = 'template/customBuilder.ejs';
 TemplateConstants.VIEW_BUILDER_TEMPLATE = 'template/viewBuilder.ejs';
 TemplateConstants.V1_TEMPLATE = 'template/viewBuilder_v1.ejs';
+TemplateConstants.V1_1_TEMPLATE = 'template/viewBuilder_v1_1.ejs';
 TemplateConstants.WARP_BUILDER = 'WrapBuilder';

package/dist/hmrouter_extension/constants/VersionConstants.d.ts

@@ -3,4 +3,6 @@ export default class VersionConstants {
     static readonly HMROUTER_LIB_NAME = "hmrouter";
     static readonly HMROUTER_VERSION_KEY = "version";
     static readonly HMROUTER_VERSION_V1 = "1.0.0";
+    static readonly HMROUTER_MIN_VERSION_FOR_NAV_HELPER = "1.1.0";
+    static readonly HMROUTER_MIN_VERSION_FOR_SDK_API = "1.2.0";
 }

package/dist/hmrouter_extension/constants/VersionConstants.js

@@ -7,3 +7,5 @@ VersionConstants.HMROUTER_ORGANIZATION = '@hadss';
 VersionConstants.HMROUTER_LIB_NAME = 'hmrouter';
 VersionConstants.HMROUTER_VERSION_KEY = 'version';
 VersionConstants.HMROUTER_VERSION_V1 = '1.0.0';
+VersionConstants.HMROUTER_MIN_VERSION_FOR_NAV_HELPER = '1.1.0';
+VersionConstants.HMROUTER_MIN_VERSION_FOR_SDK_API = '1.2.0';

package/dist/hmrouter_extension/processor/CodeGenerationProcessor.d.ts

@@ -11,8 +11,12 @@ export declare class CodeGenerationProcessor {
     private matchedPath;
     private prepareTemplateModel;
     private determineTemplatePath;
+    private determineTemplateType;
     private generateFile;
     private detectLibraryVersion;
     private detectLibraryVersion2;
+    private extractHMRouterVersion;
     private getLibraryPossiblePaths;
+    private parseVersion;
+    private compareVersions;
 }

package/dist/hmrouter_extension/processor/CodeGenerationProcessor.js

@@ -125,14 +125,43 @@ class CodeGenerationProcessor {
     determineTemplatePath(analyzeResult, defaultTemplatePath) {
         const libraryVersion = this.detectLibraryVersion();
         framework_1.Logger.debug(this.context.node.getNodeName(), `Library version: ${libraryVersion}`);
-        const useV1Template = libraryVersion.startsWith(constants_1.VersionConstants.HMROUTER_VERSION_V1);
-        if (useV1Template) {
-            return framework_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3) + constants_1.TemplateConstants.V1_TEMPLATE);
-        }
-        else if (analyzeResult.useNavDst === true) {
+        if (analyzeResult.useNavDst === true) {
             return framework_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3), constants_1.TemplateConstants.CUSTOM_BUILDER_TEMPLATE);
         }
-        return defaultTemplatePath;
+        const templateType = this.determineTemplateType(libraryVersion);
+        if (templateType !== 'latest' && libraryVersion) {
+            framework_1.Logger.warn(this.context.node.getNodeName(), `[HMRouter Version Compatibility] Detected library version ${libraryVersion}, ` +
+                `which is below the minimum recommended version ${constants_1.VersionConstants.HMROUTER_MIN_VERSION_FOR_SDK_API}. ` +
+                `Automatically switched to compatible template (${templateType}). ` +
+                `Please upgrade @hadss/hmrouter to ${constants_1.VersionConstants.HMROUTER_MIN_VERSION_FOR_SDK_API} or higher for full feature support.`);
+        }
+        switch (templateType) {
+            case 'v1':
+                return framework_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3) + constants_1.TemplateConstants.V1_TEMPLATE);
+            case 'v1_1':
+                return framework_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3) + constants_1.TemplateConstants.V1_1_TEMPLATE);
+            case 'latest':
+            default:
+                return defaultTemplatePath;
+        }
+    }
+    determineTemplateType(libraryVersion) {
+        if (!libraryVersion) {
+            return 'v1';
+        }
+        const currentVersion = this.parseVersion(libraryVersion);
+        const v1_1Version = this.parseVersion(constants_1.VersionConstants.HMROUTER_MIN_VERSION_FOR_NAV_HELPER);
+        const v1_2Version = this.parseVersion(constants_1.VersionConstants.HMROUTER_MIN_VERSION_FOR_SDK_API);
+        if (!currentVersion || !v1_1Version || !v1_2Version) {
+            return 'v1';
+        }
+        if (this.compareVersions(currentVersion, v1_2Version) >= 0) {
+            return 'latest';
+        }
+        if (this.compareVersions(currentVersion, v1_1Version) >= 0) {
+            return 'v1_1';
+        }
+        return 'v1';
     }
     generateFile(templateModel, templatePath) {
         if (!framework_1.PluginFileUtil.exist(templatePath)) {
@@ -158,26 +187,78 @@ class CodeGenerationProcessor {
         }
         return libraryVersion;
     }
-    detectLibraryVersion2(packagePath) {
-        let libraryVersion = '';
+    detectLibraryVersion2(lockFilePath) {
         try {
-            if (framework_1.PluginFileUtil.exist(packagePath)) {
-                const packageJson = framework_1.PluginFileUtil.readJson5(packagePath);
-                libraryVersion = packageJson[constants_1.VersionConstants.HMROUTER_VERSION_KEY] || '';
+            if (!framework_1.PluginFileUtil.exist(lockFilePath)) {
+                return '';
             }
+            const lockFileData = framework_1.PluginFileUtil.readJson5(lockFilePath);
+            return this.extractHMRouterVersion(lockFileData.packages);
         }
         catch (error) {
+            return '';
         }
-        return libraryVersion;
+    }
+    extractHMRouterVersion(packages) {
+        if (!packages) {
+            return '';
+        }
+        const hmrouterPrefix = `${constants_1.VersionConstants.HMROUTER_ORGANIZATION}/${constants_1.VersionConstants.HMROUTER_LIB_NAME}@`;
+        for (const key of Object.keys(packages)) {
+            if (!key.startsWith(hmrouterPrefix)) {
+                continue;
+            }
+            const packageInfo = packages[key];
+            if (packageInfo && packageInfo[constants_1.VersionConstants.HMROUTER_VERSION_KEY]) {
+                return packageInfo[constants_1.VersionConstants.HMROUTER_VERSION_KEY];
+            }
+        }
+        return '';
     }
     getLibraryPossiblePaths() {
         const paths = [];
-        paths.push(framework_1.PluginFileUtil.pathResolve(this.context.config.modulePath, constants_1.FilePathConstants.OH_MODULE_PATH, constants_1.VersionConstants.HMROUTER_ORGANIZATION, constants_1.VersionConstants.HMROUTER_LIB_NAME, constants_1.FilePathConstants.OH_PACKAGE_FILE_NAME));
+        paths.push(framework_1.PluginFileUtil.pathResolve(this.context.config.modulePath, constants_1.FilePathConstants.OH_PACKAGE_LOCK_FILE_NAME));
         const projectRoot = framework_1.PluginStore.getInstance().get('projectFilePath');
         if (projectRoot && projectRoot !== this.context.config.modulePath) {
-            paths.push(framework_1.PluginFileUtil.pathResolve(projectRoot, constants_1.FilePathConstants.OH_MODULE_PATH, constants_1.VersionConstants.HMROUTER_ORGANIZATION, constants_1.VersionConstants.HMROUTER_LIB_NAME, constants_1.FilePathConstants.OH_PACKAGE_FILE_NAME));
+            paths.push(framework_1.PluginFileUtil.pathResolve(projectRoot, constants_1.FilePathConstants.OH_PACKAGE_LOCK_FILE_NAME));
         }
         return paths;
     }
+    parseVersion(version) {
+        const match = version.match(/^(\d+)\.(\d+)\.(\d+)(-.*)?/);
+        if (!match) {
+            return null;
+        }
+        return {
+            major: parseInt(match[1], 10),
+            minor: parseInt(match[2], 10),
+            patch: parseInt(match[3], 10),
+            preRelease: match[4] || '',
+        };
+    }
+    compareVersions(v1, v2) {
+        if (v1.major !== v2.major) {
+            return v1.major < v2.major ? -1 : 1;
+        }
+        if (v1.minor !== v2.minor) {
+            return v1.minor < v2.minor ? -1 : 1;
+        }
+        if (v1.patch !== v2.patch) {
+            return v1.patch < v2.patch ? -1 : 1;
+        }
+        if (v1.preRelease && !v2.preRelease) {
+            return -1;
+        }
+        if (!v1.preRelease && v2.preRelease) {
+            return 1;
+        }
+        if (v1.preRelease < v2.preRelease) {
+            return -1;
+        }
+        if (v1.preRelease > v2.preRelease) {
+            return 1;
+        }
+        return 0;
+    }
 }
 exports.CodeGenerationProcessor = CodeGenerationProcessor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hadss/hmrouter-plugin",
-  "version": "1.2.2",
+  "version": "1.2.3-rc.1",
   "description": "HMRouter Compiler Plugin",
   "main": "dist/Index.js",
   "scripts": {
@@ -21,7 +21,8 @@
   "dependencies": {
     "ejs": "^3.1.10",
     "micromatch": "^4.0.8",
-    "ts-morph": "^23.0.0"
+    "ts-morph": "^23.0.0",
+    "arkanalyzer": "^1.0.79"
   },
   "devDependencies": {
     "@ohos/hvigor": "^5.8.9",

package/template/viewBuilder_v1_1.ejs

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// instrument ignore file
+// auto-generated <%= componentName %>Builder.ets by HMRouter
+import <%if(isDefaultExport) {%> <%= componentName %> <% } else {%> { <%= componentName %> } <% } %> from '<%= importPath %>'
+import { NavDestinationHelper } from '@hadss/hmrouter';
+
+@Builder
+export function <%= componentName %>Builder(name: string, param: Object) {
+  <%= componentName %>Generated()
+}
+
+export const <%= componentName %>BuilderWrapBuilder = wrapBuilder(<%= componentName %>Builder)
+
+@Component
+export struct <%= componentName %>Generated {
+  private helper: NavDestinationHelper = new NavDestinationHelper(this);
+
+  build() {
+    NavDestination() {
+      <%= componentName %>()
+    }
+    <% if(dialog){ %>.mode(NavDestinationMode.DIALOG)<% } %>
+    .hideTitleBar(true)
+    .attributeModifier(this.helper.modifier)
+    .gestureModifier(this.helper.gestureModifier)
+    .onWillAppear(()=>{this.helper.onWillAppear()})
+    .onAppear(() => {this.helper.onAppear()})
+    .onWillShow(()=>{this.helper.onWillShow()})
+    .onShown(()=>{this.helper.onShown()})
+    .onWillHide(()=>{this.helper.onWillHide()})
+    .onHidden(()=>{this.helper.onHidden()})
+    .onWillDisappear(()=>{this.helper.onWillDisappear()})
+    .onDisAppear(()=>{this.helper.onDisAppear()})
+    .onReady((ctx)=>{this.helper.onReady(ctx)})
+    .onBackPressed(()=> this.helper.onBackPressed())
+  }
+}