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

package/dist/framework/core/TaskManager.js

@@ -1,9 +1,42 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskManager = void 0;
+const micromatch_1 = __importDefault(require("micromatch"));
+const constants_1 = require("../../hmrouter_extension/constants");
+const PluginError_1 = require("../../hmrouter_extension/error/PluginError");
 const extension_1 = require("../extension");
 const utils_1 = require("../utils");
 const TaskStage_1 = require("./TaskStage");
+const annotationConfig = {
+    [constants_1.AnnotationConstants.ANIMATOR_ANNOTATION]: {
+        prefix: constants_1.PrefixConstants.ANIMATOR_PREFIX,
+        propertyName: 'animatorName',
+        resultType: 'HMAnimatorResult',
+    },
+    [constants_1.AnnotationConstants.INTERCEPTOR_ANNOTATION]: {
+        prefix: constants_1.PrefixConstants.INTERCEPTOR_PREFIX,
+        propertyName: 'interceptorName',
+        resultType: 'HMInterceptorResult',
+    },
+    [constants_1.AnnotationConstants.LIFECYCLE_ANNOTATION]: {
+        prefix: constants_1.PrefixConstants.LIFECYCLE_PREFIX,
+        propertyName: 'lifecycleName',
+        resultType: 'HMLifecycleResult',
+    },
+    [constants_1.AnnotationConstants.SERVICE_ANNOTATION]: {
+        prefix: constants_1.PrefixConstants.SERVICE_PREFIX,
+        propertyName: 'serviceName',
+        resultType: 'HMServiceResult',
+    },
+    [constants_1.AnnotationConstants.SERVICE_PROVIDE_ANNOTATION]: {
+        prefix: constants_1.PrefixConstants.SERVICE_PROVIDE_PREFIX,
+        propertyName: 'serviceName',
+        resultType: 'HMServiceResult',
+    },
+};
 class TaskManager {
     constructor(context, moduleExtensions) {
         this.extensionManager = extension_1.ExtensionManager.getInstance();
@@ -18,23 +51,38 @@ class TaskManager {
             default:
                 this.getExtensions().forEach((extension) => {
                     const methodName = stage.toString();
-                    extension[methodName]?.(this.context);
+                    const extensionMethods = {
+                        'afterInitialize': extension.afterInitialize?.bind(extension),
+                        'afterCodeGeneration': extension.afterCodeGeneration?.bind(extension),
+                        'afterRouterMapBuilding': extension.afterRouterMapBuilding?.bind(extension),
+                        'afterConfigUpdate': extension.afterConfigUpdate?.bind(extension),
+                        'afterObfuscationProcess': extension.afterObfuscationProcess?.bind(extension),
+                        'afterResourceProcess': extension.afterResourceProcess?.bind(extension),
+                        'afterCompletion': extension.afterCompletion?.bind(extension)
+                    };
+                    const method = extensionMethods[methodName];
+                    if (method) {
+                        method(this.context);
+                    }
                 });
                 break;
         }
     }
     executeAnnotationAnalysis() {
+        this.routerContext = this.context;
         const extensions = this.getExtensions();
-        this.context.scanFiles.forEach((file) => {
-            this.context.setCurrentFilePath(file);
+        this.routerContext.scanFiles.forEach((file) => {
+            this.routerContext.setCurrentFilePath(file);
             const sourceFile = utils_1.TsAstUtil.getSourceFile(file);
             extensions.forEach((extension) => {
                 if (extension.afterAnnotationAnalysis) {
-                    extension.afterAnnotationAnalysis(sourceFile, file, this.context);
+                    extension.afterAnnotationAnalysis(sourceFile, file, this.routerContext);
                 }
             });
         });
-        this.context.setCurrentFilePath('');
+        this.routerContext.setCurrentFilePath('');
+        this.generateRouterFilePath();
+        this.buildRouterMap();
         this.validateTemplateData();
     }
     getExtensions() {
@@ -54,17 +102,243 @@ class TaskManager {
     }
     validateTemplateData() {
         const componentNames = new Set();
-        this.context.getAnalyzeResults().forEach((result) => {
+        this.routerContext.getAnalyzeResults().forEach((result) => {
             if (result.name) {
                 componentNames.add(result.name);
             }
         });
-        const templateComponentNames = new Set(this.context.getTemplateDataMap().keys());
+        const templateComponentNames = new Set(this.routerContext.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.`);
+                utils_1.Logger.warn(this.routerContext.node.getNodeName(), `Component ${name} has template data but was not found in analyze results.`);
             }
         });
     }
+    generateRouterFilePath() {
+        this.routerContext.generatedPaths = new Map();
+        this.routerContext.getAnalyzeResults().forEach((analyzeResult) => {
+            if (analyzeResult.annotation === constants_1.AnnotationConstants.ROUTER_ANNOTATION) {
+                const relativeShortPath = this.routerContext.config.getRelativeShortSourcePath(analyzeResult);
+                const generatedFilePath = this.routerContext.config
+                    .getBuilderFilePath(relativeShortPath)
+                    .replaceAll(constants_1.FilePathConstants.FILE_SEPARATOR, constants_1.FilePathConstants.DELIMITER);
+                this.buildRouterTemplatePath(analyzeResult);
+                const uniqueKey = `${analyzeResult.name}#${analyzeResult.pageUrl}`;
+                this.routerContext.generatedPaths.set(uniqueKey, generatedFilePath);
+            }
+        });
+    }
+    buildRouterMap() {
+        this.routerContext.getAnalyzeResults().forEach((result) => {
+            if (!result.sourceFilePath) {
+                throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.ERROR_PAGE_SOURCE_FILE, this.routerContext.config.moduleName, result.sourceFilePath);
+            }
+            let pageSourceFile = this.routerContext.config
+                .getRelativeSourcePath(result.sourceFilePath)
+                .replaceAll(constants_1.FilePathConstants.FILE_SEPARATOR, constants_1.FilePathConstants.DELIMITER);
+            if (result.annotation === constants_1.AnnotationConstants.ROUTER_ANNOTATION) {
+                let pageUrl = result.pageUrl;
+                let uniqueKey = `${result.name}#${pageUrl}`;
+                let builderPath = this.routerContext.generatedPaths.get(uniqueKey) || '';
+                this.routerContext.routerMap.push({
+                    name: pageUrl,
+                    pageSourceFile: builderPath,
+                    buildFunction: result.name + 'Builder',
+                    customData: result,
+                });
+                return;
+            }
+            this.useAnnotationConfig(result, pageSourceFile, this.routerContext);
+        });
+        this.readExistingRouterMap(this.routerContext);
+    }
+    useAnnotationConfig(result, pageSourceFile, context) {
+        const config = annotationConfig[result.annotation];
+        let nameValue;
+        switch (result.annotation) {
+            case constants_1.AnnotationConstants.ANIMATOR_ANNOTATION:
+                nameValue = result.animatorName;
+                break;
+            case constants_1.AnnotationConstants.INTERCEPTOR_ANNOTATION:
+                nameValue = result.interceptorName;
+                break;
+            case constants_1.AnnotationConstants.LIFECYCLE_ANNOTATION:
+                nameValue = result.lifecycleName;
+                break;
+            case constants_1.AnnotationConstants.SERVICE_ANNOTATION:
+            case constants_1.AnnotationConstants.SERVICE_PROVIDE_ANNOTATION:
+                nameValue = result.serviceName;
+                break;
+            default:
+                nameValue = result.name;
+                break;
+        }
+        const fullName = config.prefix + nameValue;
+        context.routerMap.push({
+            name: fullName,
+            pageSourceFile: pageSourceFile,
+            buildFunction: '',
+            customData: result,
+        });
+    }
+    buildRouterTemplatePath(result) {
+        let pageSourceFile = this.routerContext.config
+            .getRelativeSourcePath(result.sourceFilePath)
+            .replaceAll(constants_1.FilePathConstants.FILE_SEPARATOR, constants_1.FilePathConstants.DELIMITER);
+        let tempFilePath = this.matchedPath(pageSourceFile, this.routerContext.config.customPageTemplate, this.routerContext.config.getDefaultTplFilePath());
+        tempFilePath = this.determineTemplatePath(result, tempFilePath);
+        result.templatePath = tempFilePath;
+    }
+    matchedPath(filePath, customPageTemplate, defaultTplFilePath) {
+        for (const template of customPageTemplate) {
+            if (micromatch_1.default.isMatch(filePath, template.srcPath)) {
+                utils_1.Logger.debug(this.routerContext.node.getNodeName(), `${filePath} detected matching template: ${template.templatePath}`);
+                return utils_1.PluginFileUtil.pathResolve(this.routerContext.config.configDir, template.templatePath);
+            }
+        }
+        return defaultTplFilePath;
+    }
+    readExistingRouterMap(context) {
+        const moduleJsonOpt = context.moduleContext.getModuleJsonOpt();
+        if (!moduleJsonOpt?.module.routerMap) {
+            utils_1.Logger.info(context.node.getNodeName(), `No routerMap found in the module configuration`);
+            return;
+        }
+        const routerMapFileName = moduleJsonOpt.module.routerMap.split(':')[1];
+        if (routerMapFileName !== 'hm_router_map') {
+            const routerMapFilePath = context.config.getModuleRouterMapFilePath(routerMapFileName);
+            const routerMapObj = utils_1.PluginFileUtil.readJson5(routerMapFilePath);
+            const systemRouterMap = routerMapObj[constants_1.RouterMapConstants.ROUTER_MAP_KEY];
+            if (systemRouterMap && systemRouterMap.length > 0) {
+                context.routerMap.unshift(...systemRouterMap);
+                utils_1.Logger.info(context.node.getNodeName(), `System routerMap added to the current routerMap`);
+            }
+        }
+    }
+    determineTemplatePath(analyzeResult, defaultTemplatePath) {
+        const libraryVersion = this.detectLibraryVersion();
+        utils_1.Logger.debug(this.routerContext.node.getNodeName(), `Library version: ${libraryVersion}`);
+        if (analyzeResult.useNavDst === true) {
+            return utils_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3), constants_1.TemplateConstants.CUSTOM_BUILDER_TEMPLATE);
+        }
+        const templateType = this.determineTemplateType(libraryVersion);
+        if (templateType !== 'latest' && libraryVersion) {
+            utils_1.Logger.warn(this.routerContext.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 utils_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3) + constants_1.TemplateConstants.V1_TEMPLATE);
+            case 'v1_1':
+                return utils_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';
+    }
+    detectLibraryVersion() {
+        let libraryVersion = '';
+        const possiblePaths = this.getLibraryPossiblePaths();
+        for (const packagePath of possiblePaths) {
+            libraryVersion = this.detectLibraryVersion2(packagePath);
+            if (libraryVersion) {
+                break;
+            }
+        }
+        return libraryVersion;
+    }
+    detectLibraryVersion2(lockFilePath) {
+        try {
+            if (!utils_1.PluginFileUtil.exist(lockFilePath)) {
+                return '';
+            }
+            const lockFileData = utils_1.PluginFileUtil.readJson5(lockFilePath);
+            return this.extractHMRouterVersion(lockFileData.packages);
+        }
+        catch (error) {
+            return '';
+        }
+    }
+    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(utils_1.PluginFileUtil.pathResolve(this.routerContext.config.modulePath, constants_1.FilePathConstants.OH_PACKAGE_LOCK_FILE_NAME));
+        const projectRoot = utils_1.PluginStore.getInstance().get('projectFilePath');
+        if (projectRoot && projectRoot !== this.routerContext.config.modulePath) {
+            paths.push(utils_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.TaskManager = TaskManager;

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

@@ -1,6 +1,7 @@
 import { HvigorNode } from '@ohos/hvigor';
 import { OhosModuleContext, Target } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
 import { BaseAnalyzeResult, ExtensionContext } from './Interface';
+import { RouterInfo } from '../../../hmrouter_extension/model';
 export declare class ExtensionContextImpl implements ExtensionContext {
     node: HvigorNode;
     moduleContext: OhosModuleContext;
@@ -30,8 +31,8 @@ export declare class ExtensionContextImpl implements ExtensionContext {
     set _currentView(v: BaseAnalyzeResult[]);
     get _currentFilePath(): string | undefined;
     set _currentFilePath(v: string | undefined);
-    get routerMap(): any[];
-    set routerMap(v: any[]);
+    get routerMap(): RouterInfo[];
+    set routerMap(v: RouterInfo[]);
     get generatedPaths(): Map<string, string>;
     set generatedPaths(v: Map<string, string>);
 }

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

@@ -19,4 +19,5 @@ export interface ExtensionContext extends BaseExtensionContext {
     getTemplateData(componentName: string): Record<string, any> | undefined;
     getTemplateDataMap(): Map<string, Record<string, any>>;
     addTemplateData(componentName: string, data: Record<string, any>): void;
+    setCurrentFilePath(filePath: string): void;
 }

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

@@ -2,3 +2,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;
+export declare function isModule(pluginId: string): boolean;

package/dist/framework/utils/ModuleTypeUtil.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHspModule = exports.isHarModule = exports.isHapModule = void 0;
+exports.isModule = 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);
@@ -14,3 +14,12 @@ function isHspModule(node) {
     return node.getAllPluginIds().includes(hvigor_ohos_plugin_1.OhosPluginId.OHOS_HSP_PLUGIN);
 }
 exports.isHspModule = isHspModule;
+function isModule(pluginId) {
+    return [
+        hvigor_ohos_plugin_1.OhosPluginId.OHOS_HSP_PLUGIN,
+        hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAR_PLUGIN,
+        hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAP_PLUGIN,
+        hvigor_ohos_plugin_1.OhosPluginId.OHOS_APP_PLUGIN
+    ].includes(pluginId);
+}
+exports.isModule = isModule;

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

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

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

@@ -2,7 +2,7 @@ export declare class PluginStore {
     private static instance;
     private dataMap;
     private constructor();
-    set(key: string, value: any): void;
+    set(key: string, value: unknown): void;
     get<T>(key: string): T | undefined;
     private clear;
     static destroy(): void;

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

@@ -1,3 +1,4 @@
 export declare class StringUtil {
     static stringToHashCode(str: string): number;
+    static longestCommonPrefixOpt(strs: string[]): string;
 }

package/dist/framework/utils/StringUtil.js

@@ -14,5 +14,18 @@ class StringUtil {
         }
         return hash;
     }
+    static longestCommonPrefixOpt(strs) {
+        if (!strs || strs.length === 0) {
+            return '';
+        }
+        const shortestStr = strs.reduce((shortest, curr) => curr.length < shortest.length ? curr : shortest, strs[0]);
+        for (let i = 0; i < shortestStr.length; i++) {
+            const char = shortestStr[i];
+            if (!strs.every(str => str[i] === char)) {
+                return shortestStr.substring(0, i);
+            }
+        }
+        return shortestStr;
+    }
 }
 exports.StringUtil = StringUtil;

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

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

package/dist/framework/utils/index.js

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

package/dist/hmrouter_extension/analyzer/RouterAnalyzer.js

@@ -14,6 +14,7 @@ class RouterAnalyzer extends AbstractAnnotationAnalyzer_1.AbstractAnnotationAnal
     }
     analyze(sourceFile, filePath, context) {
         framework_1.Logger.debug('', `Start to analyze source file: ${filePath}`);
+        this.constantResolver.setContext(context);
         sourceFile.getChildrenOfKind(ts_morph_1.SyntaxKind.MissingDeclaration).forEach((node) => {
             const componentName = this.extractComponentNameFromNode(node);
             node.getChildrenOfKind(ts_morph_1.SyntaxKind.Decorator).forEach((decorator) => {

package/dist/hmrouter_extension/analyzer/interface/IConstantResolver.d.ts

@@ -1,5 +1,7 @@
 import { Expression, SourceFile } from 'ts-morph';
+import { HMRouterExtensionContext } from '../../HMRouterExtensionContext';
 export interface IConstantResolver {
+    setContext(context: HMRouterExtensionContext): void;
     resolveConstant(value: any, sourceFile: SourceFile, filePath: string): any;
     resolvePropertyValue(value: Expression, sourceFile: SourceFile, filePath: string): any;
     getVariableFilePath(variableName: string, sourceFile: SourceFile, filePath: string): string;

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

@@ -1,11 +1,22 @@
 import { Expression, SourceFile } from 'ts-morph';
 import { IConstantResolver } from '../interface/IConstantResolver';
+import { HMRouterExtensionContext } from '../../HMRouterExtensionContext';
 export declare class ConstantResolver implements IConstantResolver {
     private importMapCache;
+    private importMapCacheFilePath;
+    private context?;
+    setContext(context: HMRouterExtensionContext): void;
     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): string;
+    private findExportInFile;
+    private isFileExists;
+    private findLocalDefinition;
+    private findReExportedDeclaration;
+    private findReExport;
+    private shouldCheckReExport;
+    private findNamedExport;
     private parsePrimitiveValue;
     private parseConstantValue;
 }

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

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstantResolver = void 0;
 const ts_morph_1 = require("ts-morph");
@@ -6,9 +9,14 @@ const framework_1 = require("../../../framework");
 const constants_1 = require("../../constants");
 const ImportAnalyzer_1 = require("./ImportAnalyzer");
 const PluginError_1 = require("../../error/PluginError");
+const path_1 = __importDefault(require("path"));
 class ConstantResolver {
     constructor() {
         this.importMapCache = new Map();
+        this.importMapCacheFilePath = [];
+    }
+    setContext(context) {
+        this.context = context;
     }
     resolveConstant(value, sourceFile, filePath) {
         if (value.type === 'constant') {
@@ -94,14 +102,141 @@ class ConstantResolver {
         return resultPath;
     }
     getOtherModuleVariableFilePath(moduleName, variableName) {
-        if (framework_1.ArkAnalyzerUtil.isReady()) {
-            const filePath = framework_1.ArkAnalyzerUtil.findVariableFilePath(moduleName, variableName);
-            if (filePath) {
-                return filePath;
+        const dependencies = this.context?.moduleContext.getOhpmDependencyInfo() || {};
+        for (const [dependencyName, dependencyInfo] of Object.entries(dependencies)) {
+            if (moduleName.indexOf(dependencyName) === 0) {
+                const cacheImport = this.importMapCacheFilePath.find((f) => f.dependencyName === dependencyName &&
+                    f.importConstantName === variableName && f.importPath === moduleName);
+                if (cacheImport) {
+                    return cacheImport.importFullPath;
+                }
+                const isFullPathImport = dependencyName !== moduleName;
+                let dependencyFilePath = '';
+                if (isFullPathImport) {
+                    dependencyFilePath = dependencyInfo.packagePath + moduleName.replace(dependencyName, '') + constants_1.FilePathConstants.ETS_SUFFIX;
+                }
+                else {
+                    const dependPackageFileName = framework_1.PluginFileUtil.readJson5(framework_1.PluginFileUtil.pathResolve(dependencyInfo.packagePath, constants_1.FilePathConstants.OH_PACKAGE_FILE_NAME));
+                    dependencyFilePath = framework_1.PluginFileUtil.pathResolve(dependencyInfo.packagePath, dependPackageFileName.main || 'Index.ets');
+                }
+                const path = this.findExportInFile(dependencyFilePath, variableName);
+                if (path) {
+                    this.importMapCacheFilePath.push({
+                        dependencyName: dependencyName,
+                        importPath: moduleName,
+                        importConstantName: variableName,
+                        importFullPath: path
+                    });
+                    return path;
+                }
             }
         }
         throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.UNKNOWN_VARIABLE, '', variableName);
     }
+    findExportInFile(filePath, variableName) {
+        if (!this.isFileExists(filePath)) {
+            return undefined;
+        }
+        const sourceFile = framework_1.TsAstUtil.getSourceFile(filePath);
+        const localDefinitionPath = this.findLocalDefinition(sourceFile, filePath, variableName);
+        if (localDefinitionPath) {
+            return localDefinitionPath;
+        }
+        const reExportedPath = this.findReExportedDeclaration(sourceFile, filePath, variableName);
+        if (reExportedPath) {
+            return reExportedPath;
+        }
+        const namedExportPath = this.findNamedExport(sourceFile, filePath, variableName);
+        if (namedExportPath) {
+            return namedExportPath;
+        }
+        return undefined;
+    }
+    isFileExists(filePath) {
+        if (!framework_1.PluginFileUtil.exist(filePath)) {
+            const alternativePath = filePath.replace(constants_1.FilePathConstants.ETS_SUFFIX, constants_1.FilePathConstants.D_ETS_SUFFIX);
+            return framework_1.PluginFileUtil.exist(alternativePath);
+        }
+        return true;
+    }
+    findLocalDefinition(sourceFile, filePath, variableName) {
+        const localDefinitions = [
+            ...sourceFile.getVariableDeclarations(),
+            ...sourceFile.getClasses(),
+            ...sourceFile.getInterfaces(),
+        ].filter(node => node.getName() === variableName);
+        if (localDefinitions.length > 0) {
+            framework_1.Logger.debug('', `Object "${variableName}" is defined locally in file: ${filePath}`);
+            return filePath;
+        }
+        return undefined;
+    }
+    findReExportedDeclaration(sourceFile, filePath, variableName) {
+        const exportDeclarations = sourceFile.getExportDeclarations();
+        for (const exportDecl of exportDeclarations) {
+            const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+            if (!moduleSpecifier) {
+                continue;
+            }
+            if (!this.shouldCheckReExport(exportDecl, variableName)) {
+                continue;
+            }
+            const originalDefinitionPath = this.findReExport(moduleSpecifier, filePath, variableName);
+            if (originalDefinitionPath) {
+                return originalDefinitionPath;
+            }
+        }
+        for (const exportDecl of exportDeclarations) {
+            const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+            if (!moduleSpecifier) {
+                continue;
+            }
+            if (!exportDecl.isNamespaceExport()) {
+                continue;
+            }
+            const originalDefinitionPath = this.findReExport(moduleSpecifier, filePath, variableName);
+            if (originalDefinitionPath) {
+                return originalDefinitionPath;
+            }
+        }
+        return undefined;
+    }
+    findReExport(moduleSpecifier, filePath, variableName) {
+        const resolvedPath = framework_1.PluginFileUtil.pathResolve(path_1.default.dirname(filePath), moduleSpecifier + constants_1.FilePathConstants.ETS_SUFFIX);
+        const originalDefinitionPath = this.findExportInFile(resolvedPath, variableName);
+        if (originalDefinitionPath) {
+            framework_1.Logger.debug('', `Object "${variableName}" is re-exported from: ${resolvedPath}`);
+            return originalDefinitionPath;
+        }
+        return undefined;
+    }
+    shouldCheckReExport(exportDecl, variableName) {
+        const namedExports = exportDecl.getNamedExports();
+        if (namedExports.some(specifier => specifier.getAliasNode()?.getText() === variableName || specifier.getName() === variableName)) {
+            return true;
+        }
+        return false;
+    }
+    findNamedExport(sourceFile, filePath, variableName) {
+        const exportSpecifiers = sourceFile.getExportedDeclarations().get(variableName);
+        if (!exportSpecifiers || exportSpecifiers.length === 0) {
+            return undefined;
+        }
+        const exportSpecifier = exportSpecifiers[0];
+        const symbol = exportSpecifier.getSymbol();
+        if (!symbol) {
+            return undefined;
+        }
+        const definitions = symbol.getDeclarations();
+        for (const definition of definitions) {
+            const definitionFilePath = definition.getSourceFile().getFilePath();
+            if (definitionFilePath !== filePath) {
+                framework_1.Logger.debug('', `Object "${variableName}" is exported from: ${definitionFilePath}`);
+                return definitionFilePath;
+            }
+        }
+        return undefined;
+    }
     parsePrimitiveValue(value) {
         let propertyValue;
         switch (value.getKind()) {