arkanalyzer 1.0.85 → 1.0.87

package/lib/utils/FileUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2026 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
@@ -40,14 +40,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFileRecursively = exports.ModulePath = exports.FileUtils = void 0;
+exports.getFileAbsPath = exports.getFileRecursively = exports.FileUtils = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = __importStar(require("./logger"));
-const pathTransfer_1 = require("./pathTransfer");
-const EtsConst_1 = require("../core/common/EtsConst");
 const ArkFile_1 = require("../core/model/ArkFile");
+const const_1 = require("../frontend/cppFrontend/ast/const");
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'FileUtils');
+const CXX_EXTENSION_SET = (0, const_1.getCxxSourceFileExtensionSet)();
 class FileUtils {
     static getIndexFileName(srcPath) {
         for (const fileInDir of fs_1.default.readdirSync(srcPath, { withFileTypes: true })) {
@@ -70,40 +70,6 @@ class FileUtils {
     static isAbsolutePath(path) {
         return /^(\/|\\|[A-Z]:\\)/.test(path);
     }
-    static generateModuleMap(ohPkgContentMap) {
-        const moduleMap = new Map();
-        ohPkgContentMap.forEach((content, filePath) => {
-            const moduleName = content.name;
-            if (moduleName && moduleName.startsWith('@')) {
-                const modulePath = path_1.default.dirname(filePath);
-                moduleMap.set(moduleName, new ModulePath(modulePath, content.main ? path_1.default.resolve(modulePath, content.main) : ''));
-            }
-        });
-        ohPkgContentMap.forEach((content, filePath) => {
-            if (!content.dependencies) {
-                return;
-            }
-            Object.entries(content.dependencies).forEach(([name, value]) => {
-                if (moduleMap.get(name)) {
-                    return;
-                }
-                const dir = path_1.default.dirname(filePath);
-                let modulePath = path_1.default.resolve(dir, value.replace('file:', ''));
-                let main = '';
-                if (this.isDirectory(modulePath)) {
-                    const target = ohPkgContentMap.get(path_1.default.resolve(modulePath, EtsConst_1.OH_PACKAGE_JSON5));
-                    if (target === null || target === void 0 ? void 0 : target.main) {
-                        main = path_1.default.resolve(modulePath, target.main);
-                    }
-                }
-                else {
-                    modulePath = path_1.default.resolve(dir, 'oh_modules', name);
-                }
-                moduleMap.set(name, new ModulePath(modulePath, main));
-            });
-        });
-        return moduleMap;
-    }
     static getFileLanguage(file, fileTags) {
         if (fileTags && fileTags.has(file)) {
             return fileTags.get(file);
@@ -117,6 +83,9 @@ class FileUtils {
             case '.js':
                 return ArkFile_1.Language.JAVASCRIPT;
             default:
+                if (CXX_EXTENSION_SET.has(extension)) {
+                    return ArkFile_1.Language.CXX;
+                }
                 return ArkFile_1.Language.UNKNOWN;
         }
     }
@@ -126,13 +95,6 @@ FileUtils.FILE_FILTER = {
     ignores: ['.git', '.preview', '.hvigor', '.idea', 'test', 'ohosTest'],
     include: /(?<!\.d)\.(ets|ts|json5)$/,
 };
-class ModulePath {
-    constructor(path, main) {
-        this.path = (0, pathTransfer_1.transfer2UnixPath)(path);
-        this.main = main ? (0, pathTransfer_1.transfer2UnixPath)(main) : main;
-    }
-}
-exports.ModulePath = ModulePath;
 function getFileRecursively(srcDir, fileName, visited = new Set()) {
     let res = '';
     if (!FileUtils.isDirectory(srcDir)) {
@@ -160,3 +122,23 @@ function getFileRecursively(srcDir, fileName, visited = new Set()) {
     return res;
 }
 exports.getFileRecursively = getFileRecursively;
+/**
+ * Try to combine each source path in the array with the relative path, returning the first absolute path that exists.
+ * @param srcPathList Source path array (absolute or relative paths)
+ * @param relativePath The relative path to concatenate
+ * @returns The first concatenated absolute path that exists; otherwise returns an empty string
+ */
+function getFileAbsPath(srcPathList, relativePath) {
+    if (!srcPathList || srcPathList.length === 0 || !relativePath) {
+        return '';
+    }
+    for (const srcPath of srcPathList) {
+        const srcDir = path_1.default.dirname(path_1.default.resolve(srcPath));
+        const absPath = path_1.default.resolve(srcDir, relativePath);
+        if (fs_1.default.existsSync(absPath)) {
+            return absPath;
+        }
+    }
+    return '';
+}
+exports.getFileAbsPath = getFileAbsPath;

package/lib/utils/LRUCacheDecorator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A function that generates a cache key from method arguments.
+ */
+export type KeyGenerator = (...args: any[]) => string;
+/**
+ * LRU (Least Recently Used) cache decorator for methods.
+ * Caches return values based on method arguments, evicting the oldest entry
+ * when the cache reaches maxSize.
+ *
+ * @param maxSize - Maximum number of entries to keep in the cache.
+ * @param keyGenerator - Optional custom function to generate cache keys from method arguments.
+ */
+export declare function LRUCache(maxSize?: number, keyGenerator?: KeyGenerator): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Clear the LRU cache associated with a decorated method.
+ * @param target - The class (for static methods) or instance (for instance methods).
+ * @param propertyKey - The method name.
+ */
+export declare function clearLRUCache(target: any, propertyKey: string): void;
+//# sourceMappingURL=LRUCacheDecorator.d.ts.map

package/lib/utils/LRUCacheDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LRUCacheDecorator.d.ts","sourceRoot":"","sources":["../../src/utils/LRUCacheDecorator.ts"],"names":[],"mappings":"AA0CA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC;AAItD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAE,MAAa,EAAE,YAAY,CAAC,EAAE,YAAY,aAG9C,GAAG,gBAAgB,MAAM,cAAc,kBAAkB,UAuBtF;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAGpE"}

package/lib/utils/LRUCacheDecorator.js

@@ -0,0 +1,89 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2026 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearLRUCache = exports.LRUCache = void 0;
+/**
+ * LRU Cache Decorator — method-level caching with Least Recently Used eviction.
+ *
+ * Usage:
+ *   import { LRUCache, clearLRUCache } from './LRUCacheDecorator';
+ *
+ *   class Foo {
+ *       // Basic: cache up to 4096 entries (default)
+ *       @LRUCache()
+ *       static resolve(path: string): string { ... }
+ *
+ *       // Custom capacity
+ *       @LRUCache(1024)
+ *       static lookup(id: number): string { ... }
+ *
+ *       // Custom key generator — useful when you want case-insensitive keys,
+ *       // partial-argument keys, or any custom serialization.
+ *       @LRUCache(4096, (srcPath) => srcPath.toLowerCase())
+ *       static getFileRealPath(srcPath: string): string { ... }
+ *   }
+ *
+ *   // Clear the cache of a decorated method (e.g. on dispose)
+ *   clearLRUCache(Foo, 'resolve');
+ */
+const LRU_CACHE_SYMBOL = Symbol('LRUCache');
+const defaultKeyGenerator = (...args) => args.join();
+/**
+ * LRU (Least Recently Used) cache decorator for methods.
+ * Caches return values based on method arguments, evicting the oldest entry
+ * when the cache reaches maxSize.
+ *
+ * @param maxSize - Maximum number of entries to keep in the cache.
+ * @param keyGenerator - Optional custom function to generate cache keys from method arguments.
+ */
+function LRUCache(maxSize = 4096, keyGenerator) {
+    const resolveKey = keyGenerator !== null && keyGenerator !== void 0 ? keyGenerator : defaultKeyGenerator;
+    const cache = new Map();
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const key = resolveKey(...args);
+            if (cache.has(key)) {
+                const value = cache.get(key);
+                cache.delete(key);
+                cache.set(key, value);
+                return value;
+            }
+            const result = originalMethod.apply(this, args);
+            if (cache.size >= maxSize) {
+                const firstKey = cache.keys().next().value;
+                if (firstKey) {
+                    cache.delete(firstKey);
+                }
+            }
+            cache.set(key, result);
+            return result;
+        };
+        descriptor.value[LRU_CACHE_SYMBOL] = cache;
+    };
+}
+exports.LRUCache = LRUCache;
+/**
+ * Clear the LRU cache associated with a decorated method.
+ * @param target - The class (for static methods) or instance (for instance methods).
+ * @param propertyKey - The method name.
+ */
+function clearLRUCache(target, propertyKey) {
+    var _a;
+    const cache = (_a = target[propertyKey]) === null || _a === void 0 ? void 0 : _a[LRU_CACHE_SYMBOL];
+    cache === null || cache === void 0 ? void 0 : cache.clear();
+}
+exports.clearLRUCache = clearLRUCache;

package/lib/utils/ModuleUtils.d.ts

@@ -0,0 +1,39 @@
+export declare class ModulePath {
+    path: string;
+    main: string;
+    /**
+     * Create a new ModulePath instance.
+     * @param path - The module path.
+     * @param main - The main entry file path of the module.
+     */
+    constructor(path: string, main: string);
+}
+export declare class ModuleUtils {
+    private static readonly FILE_EXT;
+    private static readonly OH_PACKAGE_DEPENDENCY_KEYS;
+    static MODULES: Map<string, ModulePath>;
+    static dispose(): void;
+    /**
+     * Get the real file path for a given source path, resolving file extensions and checking existence.
+     * Results are cached via LRU for performance.
+     * @param srcPath - The source path to resolve, e.g.: /projectA/src/foo
+     * @returns The resolved real file path, or empty string if not found.
+     */
+    static getFileRealPath(srcPath: string): string;
+    /**
+     * Generate a module map from oh-package.json5 content.
+     * @param ohPkgContentMap - A map of oh-package.json5 file paths to their parsed content.
+     * @returns A map of module names to their module paths.
+     */
+    static generateModuleMap(ohPkgContentMap: Map<string, {
+        [k: string]: unknown;
+    }>): Map<string, ModulePath>;
+    private static addDependModule;
+    private static processDependency;
+    /**
+     * Handle "foo_test": "@module:Foo" dependency.
+     */
+    private static handleModuleRefDependency;
+    private static findModulePathInOHPM;
+}
+//# sourceMappingURL=ModuleUtils.d.ts.map

package/lib/utils/ModuleUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleUtils.d.ts","sourceRoot":"","sources":["../../src/utils/ModuleUtils.ts"],"names":[],"mappings":"AA2BA,qBAAa,UAAU;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;gBACS,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAIzC;AAGD,qBAAa,WAAW;IACpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAA+F;IAC/H,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAA8D;IAChH,OAAc,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAa;WAM7C,OAAO,IAAI,IAAI;IAK7B;;;;;OAKG;WAEW,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IA6CtD;;;;OAIG;WACW,iBAAiB,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC;IA2BhH,OAAO,CAAC,MAAM,CAAC,eAAe;IA6B9B,OAAO,CAAC,MAAM,CAAC,iBAAiB;IA8BhC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAaxC,OAAO,CAAC,MAAM,CAAC,oBAAoB;CAyBtC"}

package/lib/utils/ModuleUtils.js

@@ -0,0 +1,261 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2026 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleUtils = exports.ModulePath = void 0;
+const path_1 = __importDefault(require("path"));
+const json5parser_1 = require("./json5parser");
+const EtsConst_1 = require("../core/common/EtsConst");
+const FileUtils_1 = require("./FileUtils");
+const pathTransfer_1 = require("./pathTransfer");
+const fs_1 = __importDefault(require("fs"));
+const logger_1 = __importStar(require("./logger"));
+const LRUCacheDecorator_1 = require("./LRUCacheDecorator");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ModuleUtils');
+const jsExt = '.js';
+class ModulePath {
+    /**
+     * Create a new ModulePath instance.
+     * @param path - The module path.
+     * @param main - The main entry file path of the module.
+     */
+    constructor(path, main) {
+        this.path = (0, pathTransfer_1.transfer2UnixPath)(path);
+        this.main = (0, pathTransfer_1.transfer2UnixPath)(main);
+    }
+}
+exports.ModulePath = ModulePath;
+class ModuleUtils {
+    /*
+     * Set static field to be null, then all related objects could be freed by GC.
+     * Class SdkUtils is only internally used by ArkAnalyzer type inference, the dispose method should be called at the end of type inference.
+     */
+    static dispose() {
+        (0, LRUCacheDecorator_1.clearLRUCache)(ModuleUtils, 'getFileRealPath');
+        this.MODULES.clear();
+    }
+    /**
+     * Get the real file path for a given source path, resolving file extensions and checking existence.
+     * Results are cached via LRU for performance.
+     * @param srcPath - The source path to resolve, e.g.: /projectA/src/foo
+     * @returns The resolved real file path, or empty string if not found.
+     */
+    static getFileRealPath(srcPath) {
+        if (srcPath.endsWith(EtsConst_1.OH_PACKAGE_JSON5)) {
+            return fs_1.default.realpathSync(srcPath);
+        }
+        let result = '';
+        try {
+            const stats = fs_1.default.statSync(srcPath, { throwIfNoEntry: false });
+            const dir = (stats === null || stats === void 0 ? void 0 : stats.isDirectory()) ? srcPath : path_1.default.dirname(srcPath);
+            const baseName = (stats === null || stats === void 0 ? void 0 : stats.isDirectory()) ? 'index' : path_1.default.basename(srcPath);
+            const files = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            let bestOrder = Number.POSITIVE_INFINITY;
+            let bestName = '';
+            const length = baseName.length;
+            for (const file of files) {
+                const name = file.name;
+                const regex = new RegExp(`^${baseName}`, 'i');
+                if (!regex.test(name)) {
+                    continue;
+                }
+                const suffix = name.slice(length);
+                if (suffix.length === 0) {
+                    bestName = name;
+                    break;
+                }
+                const order = this.FILE_EXT.get(suffix);
+                if (order === undefined) {
+                    continue;
+                }
+                if (order < bestOrder) {
+                    bestOrder = order;
+                    bestName = name;
+                }
+                if (order <= 1) {
+                    break;
+                }
+            }
+            if (bestName) {
+                result = fs_1.default.realpathSync(path_1.default.join(dir, bestName));
+            }
+        }
+        catch (e) {
+            logger.warn(srcPath + ' not found.');
+        }
+        return result;
+    }
+    /**
+     * Generate a module map from oh-package.json5 content.
+     * @param ohPkgContentMap - A map of oh-package.json5 file paths to their parsed content.
+     * @returns A map of module names to their module paths.
+     */
+    static generateModuleMap(ohPkgContentMap) {
+        if (ohPkgContentMap.size > 0 && this.MODULES.size === 0) {
+            const pkgs = Array.from(ohPkgContentMap);
+            const projectPkg = pkgs[0];
+            const projectDir = path_1.default.dirname(projectPkg[0]);
+            pkgs.reverse().forEach((entry) => {
+                var _a;
+                const filePath = entry[0];
+                const content = entry[1];
+                const moduleName = (_a = content.name) !== null && _a !== void 0 ? _a : '';
+                this.addDependModule(filePath, content, this.MODULES, moduleName, false, projectDir);
+            });
+            //process project oh-package.json5 override
+            this.processDependency(projectPkg[1].overrides, projectDir, this.MODULES, true, projectDir);
+            const overrideDependencyMap = projectPkg[1].overrideDependencyMap;
+            if (overrideDependencyMap) {
+                Object.entries(overrideDependencyMap).forEach(([name, value]) => {
+                    const dFile = path_1.default.isAbsolute(value) ? value : path_1.default.resolve(projectDir, value);
+                    const dFileContent = (0, json5parser_1.fetchDependenciesFromFile)(dFile);
+                    this.addDependModule(dFile, dFileContent, this.MODULES, name, true, projectDir);
+                });
+            }
+        }
+        return this.MODULES;
+    }
+    static addDependModule(ohPkgFile, content, ret, moduleName, override, projectDir) {
+        if (Object.keys(content).length === 0) {
+            return;
+        }
+        const ohPkgFileRealPath = this.getFileRealPath(ohPkgFile);
+        if (!ohPkgFileRealPath) {
+            return;
+        }
+        const modulePath = path_1.default.dirname(ohPkgFileRealPath);
+        // deep first
+        this.OH_PACKAGE_DEPENDENCY_KEYS.forEach((dependencyKey) => this.processDependency(content[dependencyKey], modulePath, ret, override, projectDir));
+        // skip empty or duplicate module
+        if (!moduleName || (!override && ret.has(moduleName))) {
+            return;
+        }
+        let entry = content.types || content.main;
+        if (!entry) {
+            entry = '';
+        }
+        else if (entry.endsWith(jsExt)) {
+            entry = entry.substring(0, entry.length - jsExt.length);
+        }
+        const main = this.getFileRealPath(path_1.default.resolve(modulePath, entry));
+        ret.set(moduleName, new ModulePath(modulePath, main));
+    }
+    static processDependency(dependencies, modulePath, ret, override, projectDir) {
+        if (!dependencies) {
+            return;
+        }
+        Object.entries(dependencies).forEach(([name, value]) => {
+            if (!override && ret.get(name)) {
+                return;
+            }
+            if (this.handleModuleRefDependency(name, value, ret)) {
+                return;
+            }
+            // order： 1. local module 2. current module oh_modules 3. project oh_modules 4. project oh_modules .ohpm
+            const candidates = [
+                path_1.default.resolve(modulePath, value.replace('file:', '')),
+                path_1.default.resolve(value.endsWith('.har') && modulePath.includes(EtsConst_1.OHPM) ? modulePath.substring(0, modulePath.lastIndexOf(EtsConst_1.OH_MODULES)) : modulePath, EtsConst_1.OH_MODULES, name),
+                path_1.default.resolve(projectDir, EtsConst_1.OH_MODULES, name),
+                this.findModulePathInOHPM(projectDir, name, value),
+            ];
+            const dPath = candidates.find((candidate) => FileUtils_1.FileUtils.isDirectory(candidate));
+            if (!dPath) {
+                logger.warn(`Cannot find module: ${name} dependency in ${modulePath} ${EtsConst_1.OH_PACKAGE_JSON5}`);
+                return;
+            }
+            const dFile = path_1.default.resolve(dPath, EtsConst_1.OH_PACKAGE_JSON5);
+            const dFileContent = (0, json5parser_1.fetchDependenciesFromFile)(dFile);
+            this.addDependModule(dFile, dFileContent, ret, name, override, projectDir);
+        });
+    }
+    /**
+     * Handle "foo_test": "@module:Foo" dependency.
+     */
+    static handleModuleRefDependency(name, value, ret) {
+        if (!value.startsWith(EtsConst_1.MODULE_PREFIX)) {
+            return false;
+        }
+        const moduleRef = ret.get(value.slice(EtsConst_1.MODULE_PREFIX.length));
+        if (moduleRef) {
+            ret.set(name, moduleRef);
+            return true;
+        }
+        logger.warn(`Cannot find module: ${name}`);
+        return false;
+    }
+    static findModulePathInOHPM(projectDir, moduleName, value) {
+        const OHPMPath = path_1.default.resolve(projectDir, EtsConst_1.OH_MODULES, EtsConst_1.OHPM);
+        const prefix = `${moduleName.replace('/', '+')}@`;
+        // fix version
+        if (/^\d+(?:\.\d+){2}(?:-[0-9A-Za-z-]+)?$/.test(value)) {
+            return path_1.default.resolve(OHPMPath, prefix + value, EtsConst_1.OH_MODULES, moduleName);
+        }
+        // try to find the best version
+        try {
+            const dirs = fs_1.default.readdirSync(OHPMPath, { withFileTypes: true })
+                .filter((dir) => dir.isDirectory() && dir.name.startsWith(prefix));
+            for (const dir of dirs) {
+                const dirName = dir.name;
+                if (value.startsWith('^') && dirName.split('@')[1] < value.substring(1)) {
+                    continue;
+                }
+                return path_1.default.resolve(OHPMPath, dirName, EtsConst_1.OH_MODULES, moduleName);
+            }
+        }
+        catch (e) {
+            logger.warn(`Cannot find module: ${moduleName} in ${OHPMPath}`);
+        }
+        return '';
+    }
+}
+ModuleUtils.FILE_EXT = new Map([['.ets', 0], ['.ts', 1], ['.d.ets', 2], ['.d.ts', 3], ['.js', 4]]);
+ModuleUtils.OH_PACKAGE_DEPENDENCY_KEYS = ['dependencies', 'devDependencies', 'dynamicDependencies'];
+ModuleUtils.MODULES = new Map();
+__decorate([
+    (0, LRUCacheDecorator_1.LRUCache)()
+], ModuleUtils, "getFileRealPath", null);
+exports.ModuleUtils = ModuleUtils;

package/package.json

@@ -1,32 +1,35 @@
 {
   "name": "arkanalyzer",
-  "version": "1.0.85",
+  "version": "1.0.87",
   "files": [
     "docs",
     "lib",
     "config"
   ],
   "main": "lib/index.js",
+  "bin": {
+    "arkanalyzer": "lib/cli/cli.js"
+  },
   "scripts": {
+    "prebuild": "node script/npmInstall.js",
     "build": "tsc",
-    "prepack": "tsc -p ./tsconfig.prod.json",
-    "test": "vitest",
-    "testonce": "vitest --no-color run",
-    "coverage": "vitest run --coverage",
+    "build:cpp": "node script/buildCpp.js",
+    "prepack": "npm run build && tsc -p ./tsconfig.prod.json && node script/vendorOhosTypescript.js && copyfiles -f arkCppAst/* lib/ast",
+    "test": "npm run build && vitest",
+    "testonce": "npm run build && vitest --no-color run",
+    "coverage": "npm run build && vitest run --coverage",
     "heapdump": "npm run build && node --expose-gc out/tests/HeapDumpTest.js",
-    "postinstall": "node script/npmInstall.js",
-    "gendoc": "npx typedoc"
+    "gendoc": "npm run build && npx typedoc"
   },
   "dependencies": {
     "commander": "13.1.0",
-    "log4js": "6.9.1",
-    "ohos-typescript": "^4.9.5-r4"
+    "log4js": "6.9.1"
   },
-  "bundledDependencies": [
-    "ohos-typescript"
-  ],
   "devDependencies": {
+    "copyfiles": "^2.4.1",
+    "@types/node": "^25.5.0",
     "@vitest/coverage-v8": "^1.5.0",
+    "ohos-typescript": "^4.9.5-r4",
     "ts-node": "^10.9.1",
     "typedoc": "^0.28.0",
     "typedoc-plugin-markdown": "^4.6.3",