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

package/dist/hmrouter_extension/processor/ObfuscationProcessor.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObfuscationProcessor = void 0;
+const path_1 = __importDefault(require("path"));
 const framework_1 = require("../../framework");
 const constants_1 = require("../constants");
 class ObfuscationProcessor {
@@ -23,7 +27,7 @@ class ObfuscationProcessor {
         this.context.moduleContext?.setBuildProfileOpt(buildProfileOpt);
     }
     generateObfuscationRuleFile() {
-        const obfuscationFilePath = framework_1.PluginFileUtil.pathResolve(this.context.config.modulePath, constants_1.FilePathConstants.OBFUSCATION_FILE_NAME);
+        const obfuscationFilePath = this.context.config.getObfuscationFilePath();
         let routerMap = [];
         if (framework_1.PluginFileUtil.exist(this.context.config.getRouterMapDir())) {
             routerMap = JSON.parse(framework_1.PluginFileUtil.readFileSync(this.context.config.getRouterMapDir()).toString()).routerMap;
@@ -36,7 +40,7 @@ class ObfuscationProcessor {
     }
     handleHarPackageLogic(obfuscationString) {
         if (this.context.moduleContext.getModuleType() === constants_1.PluginConstants.HAR_MODULE_NAME) {
-            const consumerRulesPath = framework_1.PluginFileUtil.pathResolve(this.context.config.modulePath, constants_1.FilePathConstants.CONSUMER_FILE_NAME);
+            const consumerRulesPath = this.context.config.getConsumerRulesFilePath();
             framework_1.PluginFileUtil.ensureFileSync(consumerRulesPath);
             framework_1.PluginFileUtil.writeFileSync(consumerRulesPath, obfuscationString);
         }
@@ -77,10 +81,12 @@ class ObfuscationProcessor {
         return true;
     }
     addHMRouterObfuscationRules(ruleOptions, obfuscationOptions) {
-        const obfuscationFilePath = constants_1.FilePathConstants.CURRENT_DELIMITER + constants_1.FilePathConstants.OBFUSCATION_FILE_NAME;
+        let obfuscationFilePath = path_1.default.relative(this.context.config.modulePath, this.context.config.getObfuscationFilePath());
+        obfuscationFilePath = constants_1.FilePathConstants.CURRENT_DELIMITER + obfuscationFilePath;
         ruleOptions.files = this.appendFilePathSafely(ruleOptions.files, obfuscationFilePath);
         if (this.context.moduleContext.getModuleType() === constants_1.PluginConstants.HAR_MODULE_NAME) {
-            const consumerRulesPath = constants_1.FilePathConstants.CURRENT_DELIMITER + constants_1.FilePathConstants.CONSUMER_FILE_NAME;
+            let consumerRulesPath = path_1.default.relative(this.context.config.modulePath, this.context.config.getConsumerRulesFilePath());
+            consumerRulesPath = constants_1.FilePathConstants.CURRENT_DELIMITER + consumerRulesPath;
             obfuscationOptions.consumerFiles = this.appendFilePathSafely(obfuscationOptions.consumerFiles, consumerRulesPath);
         }
     }

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

@@ -1,6 +1,7 @@
 import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
 export declare class ResourceProcessProcessor {
     private context;
+    private rawFileContent;
     constructor(context: HMRouterExtensionContext);
     execute(): void;
     private copyRouterMapToRawFile;

package/dist/hmrouter_extension/processor/ResourceProcessor.js

@@ -5,6 +5,7 @@ const framework_1 = require("../../framework");
 const constants_1 = require("../constants");
 class ResourceProcessProcessor {
     constructor(context) {
+        this.rawFileContent = '';
         this.context = context;
     }
     execute() {
@@ -22,33 +23,44 @@ class ResourceProcessProcessor {
         let rawFilePath = this.context.config.getRawFilePath();
         framework_1.PluginFileUtil.ensureFileSync(rawFilePath);
         if (framework_1.PluginFileUtil.exist(routerMapFilePath)) {
-            framework_1.PluginFileUtil.copyFileSync(routerMapFilePath, rawFilePath);
+            this.rawFileContent = framework_1.PluginFileUtil.readFileSync(routerMapFilePath).toString();
         }
-        framework_1.Logger.info(this.context.node.getNodeName(), `Copy router map to raw file successfully, filePath: ${rawFilePath}`);
     }
     processHspModuleName() {
-        if (!(0, framework_1.isHapModule)(this.context.node)) {
+        let rawFilePath = this.context.config.getRawFilePath();
+        const oldcontent = framework_1.PluginFileUtil.readFileSync(rawFilePath).toString();
+        let content = this.rawFileContent;
+        if (!content) {
+            framework_1.Logger.warn(this.context.node.getNodeName(), `Raw file is empty, filePath: ${rawFilePath}`);
             return;
         }
-        let rawFilePath = this.context.config.getRawFilePath();
-        let rawFileRouterMap = JSON.parse(framework_1.PluginFileUtil.readFileSync(rawFilePath).toString());
-        rawFileRouterMap.hspModuleNames = [...new Set(framework_1.PluginStore.getInstance().get('hspModuleNames'))];
-        rawFileRouterMap.hspModuleNames.push(...this.getRemoteHspModuleNames(this.context.node.getAllPluginIds()));
-        let hspModulesInfo = framework_1.PluginStore.getInstance().get('hspModulesInfo');
-        if (hspModulesInfo && hspModulesInfo.length > 0) {
-            rawFileRouterMap.hspModulesInfo = hspModulesInfo;
+        if ((0, framework_1.isHapModule)(this.context.node)) {
+            let rawFileRouterMap = JSON.parse(content);
+            rawFileRouterMap.hspModuleNames = [...new Set(framework_1.PluginStore.getInstance().get('hspModuleNames'))];
+            rawFileRouterMap.hspModuleNames.push(...this.getRemoteHspModuleNames(this.context.node.getAllPluginIds()));
+            let hspModulesInfo = framework_1.PluginStore.getInstance().get('hspModulesInfo');
+            if (hspModulesInfo && hspModulesInfo.length > 0) {
+                rawFileRouterMap.hspModulesInfo = hspModulesInfo;
+            }
+            else {
+                rawFileRouterMap.hspModulesInfo = [];
+            }
+            let remoteHspModuleNames = this.getRemoteHspModuleNames(this.context.node.getAllPluginIds());
+            for (const remoteName of remoteHspModuleNames) {
+                rawFileRouterMap.hspModulesInfo.push({
+                    moduleName: remoteName,
+                    packageName: remoteName,
+                });
+            }
+            content = JSON.stringify(rawFileRouterMap);
         }
-        else {
-            rawFileRouterMap.hspModulesInfo = [];
+        if (oldcontent !== content) {
+            framework_1.Logger.debug(this.context.node.getNodeName(), `Raw file content has been updated, filePath: ${rawFilePath}`);
+            framework_1.PluginFileUtil.writeFileSync(rawFilePath, content);
         }
-        let remoteHspModuleNames = this.getRemoteHspModuleNames(this.context.node.getAllPluginIds());
-        for (const remoteName of remoteHspModuleNames) {
-            rawFileRouterMap.hspModulesInfo.push({
-                moduleName: remoteName,
-                packageName: remoteName,
-            });
+        else {
+            framework_1.Logger.debug(this.context.node.getNodeName(), `Raw file is not changed, filePath: ${rawFilePath}`);
         }
-        framework_1.PluginFileUtil.writeFileSync(rawFilePath, JSON.stringify(rawFileRouterMap));
     }
     getRemoteHspModuleNames(pluginIds) {
         let remoteHspModuleNames = [];

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

@@ -3,8 +3,5 @@ export declare class RouterMapBuildingProcessor {
     private context;
     constructor(context: HMRouterExtensionContext);
     execute(): void;
-    private buildRouterMap;
-    private useAnnotationConfig;
     private generateRouterMapFile;
-    private readExistingRouterMap;
 }

package/dist/hmrouter_extension/processor/RouterMapBuildingProcessor.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterMapBuildingProcessor = void 0;
 const framework_1 = require("../../framework");
-const constants_1 = require("../constants");
 const PluginError_1 = require("../error/PluginError");
 class RouterMapBuildingProcessor {
     constructor(context) {
@@ -10,76 +9,13 @@ class RouterMapBuildingProcessor {
     }
     execute() {
         framework_1.Logger.debug(this.context.node.getNodeName(), `Start to build router map...`);
-        for (const result of this.context.getAnalyzeResults()) {
-            this.buildRouterMap(result);
-        }
         const isHar = (0, framework_1.isHarModule)(this.context.node);
         if ((isHar && !this.context.routerMap) || (isHar && this.context.routerMap.length === 0)) {
             framework_1.Logger.info(this.context.node.getNodeName(), `Skip generating routerMap`);
             return;
         }
-        this.readExistingRouterMap();
         this.generateRouterMapFile();
     }
-    buildRouterMap(result) {
-        if (!result.sourceFilePath) {
-            throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.ERROR_PAGE_SOURCE_FILE, this.context.config.moduleName, result.sourceFilePath);
-        }
-        let pageSourceFile = this.context.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.context.generatedPaths.get(uniqueKey) || '';
-            this.context.routerMap.push({
-                name: pageUrl,
-                pageSourceFile: builderPath,
-                buildFunction: result.name + 'Builder',
-                customData: result,
-            });
-            return;
-        }
-        this.useAnnotationConfig(result, pageSourceFile);
-    }
-    useAnnotationConfig(result, pageSourceFile) {
-        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',
-            },
-        };
-        const config = annotationConfig[result.annotation];
-        const nameValue = result[config.propertyName];
-        const fullName = config.prefix + nameValue;
-        this.context.routerMap.push({
-            name: fullName,
-            pageSourceFile: pageSourceFile,
-            buildFunction: '',
-            customData: result,
-        });
-    }
     generateRouterMapFile() {
         let set = new Set();
         this.context.routerMap.forEach((item) => {
@@ -105,22 +41,5 @@ class RouterMapBuildingProcessor {
         framework_1.PluginFileUtil.writeFileSync(routerMapFilePath, routerMapJsonStr);
         framework_1.Logger.info(this.context.node.getNodeName(), `hm_router_map.json has been generated in ${routerMapFilePath}`);
     }
-    readExistingRouterMap() {
-        const moduleJsonOpt = this.context.moduleContext.getModuleJsonOpt();
-        if (!moduleJsonOpt?.module.routerMap) {
-            framework_1.Logger.info(this.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 = this.context.config.getModuleRouterMapFilePath(routerMapFileName);
-            const routerMapObj = framework_1.PluginFileUtil.readJson5(routerMapFilePath);
-            const systemRouterMap = routerMapObj[constants_1.RouterMapConstants.ROUTER_MAP_KEY];
-            if (systemRouterMap && systemRouterMap.length > 0) {
-                this.context.routerMap.unshift(...systemRouterMap);
-                framework_1.Logger.info(this.context.node.getNodeName(), `System routerMap added to the current routerMap`);
-            }
-        }
-    }
 }
 exports.RouterMapBuildingProcessor = RouterMapBuildingProcessor;

package/package.json

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

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

@@ -1,24 +0,0 @@
-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

@@ -1,208 +0,0 @@
-"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;