arkanalyzer 1.0.86 → 1.0.88

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,38 @@
 {
   "name": "arkanalyzer",
-  "version": "1.0.86",
+  "version": "1.0.88",
   "files": [
     "docs",
     "lib",
     "config"
   ],
   "main": "lib/index.js",
+  "bin": {
+    "arkanalyzer": "lib/cli/cli.js"
+  },
   "scripts": {
     "prebuild": "node script/npmInstall.js",
     "build": "tsc",
-    "prepack": "npm run build && tsc -p ./tsconfig.prod.json",
+    "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",
+    "perf:arkts": "node --max-old-space-size=4096 --expose-gc --perf-basic-prof -r ts-node/register tests/samples/perf/main.ts --project=photos",
+    "perf:cpp": "node --max-old-space-size=16384 --expose-gc --perf-basic-prof -r ts-node/register tests/samples/perf/main.ts --project=opencv",
     "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": {
+    "@types/node": "^25.5.0",
     "@vitest/coverage-v8": "^1.5.0",
+    "copyfiles": "^2.4.1",
+    "node-api-headers": "^1.1.0",
+    "ohos-typescript": "^4.9.5-r4",
     "ts-node": "^10.9.1",
     "typedoc": "^0.28.0",
     "typedoc-plugin-markdown": "^4.6.3",