@hadss/hmrouter-plugin 1.1.0-beta.0 → 1.2.0-beta.0

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

@@ -0,0 +1,15 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class InitializerProcessor {
+    private readonly context;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private scanFiles;
+    private deepScan;
+    private initConfig;
+    private readConfigFile;
+    private readProjectConfig;
+    private readModuleConfig;
+    private mergeConfigs;
+    private setupAppContext;
+    private createConfigInstance;
+}

package/dist/hmrouter_extension/processor/InitializerProcessor.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializerProcessor = void 0;
+const hvigor_ohos_plugin_1 = require("@ohos/hvigor-ohos-plugin");
+const framework_1 = require("../../framework");
+const HMRouterPluginConfig_1 = require("../config/HMRouterPluginConfig");
+const constants_1 = require("../constants");
+class InitializerProcessor {
+    constructor(context) {
+        this.context = context;
+    }
+    execute() {
+        this.context.config = this.initConfig(this.context.node);
+        this.context.routerMap = [];
+        framework_1.Logger.debug(this.context.node.getNodeName(), `read config finished, config: ${this.context.config}`);
+        this.scanFiles();
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Scanned ${this.context.scanFiles.length} files ${this.context.scanFiles}`);
+    }
+    scanFiles() {
+        this.context.config.scanDir.forEach((dir) => {
+            const scanPath = this.context.config.getScanPath(dir);
+            this.deepScan(scanPath, '', this.context);
+        });
+    }
+    deepScan(scanPath, filePath, context) {
+        let resolvePath = framework_1.PluginFileUtil.pathResolve(scanPath, filePath);
+        if (!framework_1.PluginFileUtil.exist(resolvePath)) {
+            return;
+        }
+        if (framework_1.PluginFileUtil.isDictionary(resolvePath)) {
+            const files = framework_1.PluginFileUtil.readdirSync(resolvePath);
+            files.forEach((file) => {
+                this.deepScan(resolvePath, file, context);
+            });
+        }
+        else {
+            context.scanFiles.push(resolvePath);
+        }
+    }
+    initConfig(node) {
+        this.setupAppContext(node);
+        const projectConfigParam = this.readProjectConfig();
+        const moduleConfigParam = this.readModuleConfig(node);
+        const mergedConfigParam = this.mergeConfigs(projectConfigParam, moduleConfigParam);
+        return this.createConfigInstance(node, mergedConfigParam);
+    }
+    readConfigFile(configPath) {
+        let configParam = {};
+        if (framework_1.PluginFileUtil.exist(configPath)) {
+            configParam = framework_1.PluginFileUtil.readJson5(configPath);
+        }
+        return configParam;
+    }
+    readProjectConfig() {
+        const projectConfigFilePath = framework_1.PluginFileUtil.pathResolve(framework_1.PluginStore.getInstance().get('projectFilePath'), constants_1.FilePathConstants.CONFIG_FILE_NAME);
+        return this.readConfigFile(projectConfigFilePath);
+    }
+    readModuleConfig(node) {
+        const moduleConfigFilePath = framework_1.PluginFileUtil.pathResolve(node.getNodePath(), constants_1.FilePathConstants.CONFIG_FILE_NAME);
+        return this.readConfigFile(moduleConfigFilePath);
+    }
+    mergeConfigs(projectConfigParam, moduleConfigParam) {
+        const defaultConfig = {
+            scanDir: [constants_1.FilePathConstants.DEFAULT_SCAN_DIR],
+            routerMapDir: constants_1.FilePathConstants.DEFAULT_ROUTER_MAP_DIR,
+            builderDir: constants_1.FilePathConstants.DEFAULT_BUILD_DIR,
+            defaultPageTemplate: constants_1.TemplateConstants.VIEW_BUILDER_TEMPLATE,
+            customPageTemplate: [],
+            saveGeneratedFile: false,
+            autoObfuscation: false,
+        };
+        return {
+            ...defaultConfig,
+            ...projectConfigParam,
+            ...moduleConfigParam,
+        };
+    }
+    setupAppContext(node) {
+        const appContext = node.getParentNode()?.getContext(hvigor_ohos_plugin_1.OhosPluginId.OHOS_APP_PLUGIN);
+        if (appContext) {
+            framework_1.PluginStore.getInstance().set('projectFilePath', appContext.getProjectPath());
+            framework_1.PluginStore.getInstance().set('appContext', appContext);
+            framework_1.PluginStore.getInstance().set('buildMode', appContext.getBuildMode());
+        }
+    }
+    createConfigInstance(node, configParam) {
+        const modulePath = node.getNodePath();
+        let nodeName = node.getNodeName();
+        if ((0, framework_1.isHapModule)(node)) {
+            let packageJson = framework_1.PluginFileUtil.readJson5(framework_1.PluginFileUtil.pathResolve(node.getNodePath(), constants_1.FilePathConstants.OH_PACKAGE_FILE_NAME));
+            nodeName = packageJson.name;
+        }
+        return new HMRouterPluginConfig_1.HMRouterPluginConfig(nodeName, modulePath, modulePath, configParam);
+    }
+}
+exports.InitializerProcessor = InitializerProcessor;

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

@@ -0,0 +1,12 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class ObfuscationProcessor {
+    private context;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private generateObfuscationRuleFile;
+    private handleHarPackageLogic;
+    private isEnableObfuscation;
+    private addHMRouterObfuscationRules;
+    private appendFilePathSafely;
+    private buildObfuscatedStrings;
+}

package/dist/hmrouter_extension/processor/ObfuscationProcessor.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObfuscationProcessor = void 0;
+const framework_1 = require("../../framework");
+const constants_1 = require("../constants");
+class ObfuscationProcessor {
+    constructor(context) {
+        this.context = context;
+    }
+    execute() {
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Start to obfuscation...`);
+        const buildProfileOpt = this.context.moduleContext?.getBuildProfileOpt();
+        if (!this.isEnableObfuscation(buildProfileOpt)) {
+            framework_1.Logger.info(this.context.node.getNodeName(), 'This compilation does not turn on code obfuscation, skip hmrouter_obfuscation_rules.txt file generation');
+            return;
+        }
+        const obfuscationString = this.generateObfuscationRuleFile();
+        this.handleHarPackageLogic(obfuscationString);
+        this.context.moduleContext?.setBuildProfileOpt(buildProfileOpt);
+    }
+    generateObfuscationRuleFile() {
+        const obfuscationFilePath = framework_1.PluginFileUtil.pathResolve(this.context.config.modulePath, constants_1.FilePathConstants.OBFUSCATION_FILE_NAME);
+        const routerMap = JSON.parse(framework_1.PluginFileUtil.readFileSync(this.context.config.getRouterMapDir()).toString()).routerMap;
+        const obfuscationString = this.buildObfuscatedStrings(routerMap);
+        framework_1.PluginFileUtil.ensureFileSync(obfuscationFilePath);
+        framework_1.PluginFileUtil.writeFileSync(obfuscationFilePath, obfuscationString);
+        framework_1.Logger.info(this.context.node.getNodeName(), `Generate obfuscation rule file successfully, filePath: ${obfuscationFilePath}`);
+        return obfuscationString;
+    }
+    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);
+            framework_1.PluginFileUtil.ensureFileSync(consumerRulesPath);
+            framework_1.PluginFileUtil.writeFileSync(consumerRulesPath, obfuscationString);
+        }
+    }
+    isEnableObfuscation(buildProfileOpt) {
+        const currentBuildMode = framework_1.PluginStore.getInstance().get('buildMode');
+        const buildOption = buildProfileOpt.buildOptionSet?.find((item) => item.name === currentBuildMode);
+        if (!buildOption) {
+            return false;
+        }
+        const arkOptions = framework_1.ObjectUtils.ensureNestedObject(buildOption, ['arkOptions']);
+        const obfuscationOptions = framework_1.ObjectUtils.ensureNestedObject(arkOptions, ['obfuscation']);
+        const ruleOptions = framework_1.ObjectUtils.ensureNestedObject(obfuscationOptions, ['ruleOptions']);
+        const isObfuscationEnabled = !!ruleOptions.enable;
+        if (!isObfuscationEnabled) {
+            return false;
+        }
+        if (this.context.config?.autoObfuscation) {
+            this.addHMRouterObfuscationRules(ruleOptions, obfuscationOptions);
+        }
+        return true;
+    }
+    addHMRouterObfuscationRules(ruleOptions, obfuscationOptions) {
+        const obfuscationFilePath = constants_1.FilePathConstants.CURRENT_DELIMITER + constants_1.FilePathConstants.OBFUSCATION_FILE_NAME;
+        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;
+            obfuscationOptions.consumerFiles = this.appendFilePathSafely(obfuscationOptions.consumerFiles, consumerRulesPath);
+        }
+    }
+    appendFilePathSafely(target, filePath) {
+        if (typeof target === 'string') {
+            return target === filePath ? [target] : [target, filePath];
+        }
+        else if (Array.isArray(target)) {
+            if (!target.includes(filePath)) {
+                target.push(filePath);
+            }
+            return target;
+        }
+        else {
+            return [filePath];
+        }
+    }
+    buildObfuscatedStrings(routerMap) {
+        let srcPathArr = [
+            ...new Set(routerMap.map((routerInfo) => {
+                return constants_1.FilePathConstants.CURRENT_DELIMITER + routerInfo.pageSourceFile;
+            })),
+        ];
+        let classNameArr = [
+            ...new Set(routerMap
+                .filter((routerInfo) => {
+                return routerInfo.name.includes('__');
+            })
+                .map((routerInfo) => {
+                return routerInfo.customData.className;
+            })),
+        ];
+        let functionName = [
+            ...new Set(routerMap
+                .filter((routerInfo) => {
+                return routerInfo.name.includes(constants_1.PrefixConstants.SERVICE_PREFIX);
+            })
+                .map((routerInfo) => {
+                return routerInfo.customData.functionName;
+            })),
+        ];
+        let watchFunctionName = [
+            ...new Set(routerMap
+                .filter((routerInfo) => {
+                return routerInfo.buildFunction;
+            })
+                .map((routerInfo) => {
+                return routerInfo.buildFunction + constants_1.TemplateConstants.WARP_BUILDER;
+            })),
+        ];
+        return (constants_1.ObfuscationConstants.KEEP_FILE_NAME +
+            constants_1.FilePathConstants.LINE_BREAK +
+            srcPathArr
+                .concat(constants_1.ObfuscationConstants.KEEP_PROPERTY_NAME, functionName)
+                .concat(constants_1.ObfuscationConstants.KEEP_GLOBAL_NAME, classNameArr, watchFunctionName)
+                .join(constants_1.FilePathConstants.LINE_BREAK));
+    }
+}
+exports.ObfuscationProcessor = ObfuscationProcessor;

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

@@ -0,0 +1,9 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class ResourceProcessProcessor {
+    private context;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private copyRouterMapToRawFile;
+    private processHspModuleName;
+    private getRemoteHspModuleNames;
+}

package/dist/hmrouter_extension/processor/ResourceProcessor.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceProcessProcessor = void 0;
+const framework_1 = require("../../framework");
+const constants_1 = require("../constants");
+class ResourceProcessProcessor {
+    constructor(context) {
+        this.context = context;
+    }
+    execute() {
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Start to copy router map to raw file...`);
+        this.copyRouterMapToRawFile();
+        this.processHspModuleName();
+    }
+    copyRouterMapToRawFile() {
+        let routerMapFilePath = framework_1.PluginFileUtil.pathResolve(this.context.currentTarget?.getBuildTargetOutputPath(), constants_1.FilePathConstants.TEMP_ROUTER_MAP_PATH, this.context.currentTarget?.getTargetName(), constants_1.RouterMapConstants.ROUTER_MAP_NAME);
+        let rawFilePath = this.context.config.getRawFilePath();
+        framework_1.PluginFileUtil.ensureFileSync(rawFilePath);
+        framework_1.PluginFileUtil.copyFileSync(routerMapFilePath, rawFilePath);
+        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)) {
+            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()));
+        framework_1.PluginFileUtil.writeFileSync(rawFilePath, JSON.stringify(rawFileRouterMap));
+    }
+    getRemoteHspModuleNames(pluginIds) {
+        let remoteHspModuleNames = [];
+        try {
+            pluginIds.forEach((id) => {
+                let context = this.context.node.getContext(id);
+                let signedHspObj = context.getOhpmRemoteHspDependencyInfo(true);
+                let remoteHspObj = context.getOhpmRemoteHspDependencyInfo(false);
+                for (const key in signedHspObj) {
+                    remoteHspModuleNames.push(signedHspObj[key].name);
+                }
+                for (const key in remoteHspObj) {
+                    remoteHspModuleNames.push(remoteHspObj[key].name);
+                }
+            });
+        }
+        catch (error) {
+            framework_1.Logger.warn(this.context.node.getNodeName(), 'Your DevEco Studio version less than 5.0.3.800, may cause remote hsp dependencies get failed');
+        }
+        return remoteHspModuleNames;
+    }
+}
+exports.ResourceProcessProcessor = ResourceProcessProcessor;

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

@@ -0,0 +1,9 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class RouterMapBuildingProcessor {
+    private context;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private buildRouterMap;
+    private generateRouterMapFile;
+    private readExistingRouterMap;
+}

package/dist/hmrouter_extension/processor/RouterMapBuildingProcessor.js

@@ -0,0 +1,117 @@
+"use strict";
+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) {
+        this.context = context;
+    }
+    execute() {
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Start to build router map...`);
+        this.readExistingRouterMap();
+        for (const result of this.context.getAnalyzeResults()) {
+            this.buildRouterMap(result);
+        }
+        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 builderPath = this.context.generatedPaths.get(result.name) || '';
+            this.context.routerMap.push({
+                name: pageUrl,
+                pageSourceFile: builderPath,
+                buildFunction: result.name + 'Builder',
+                customData: result,
+            });
+            return;
+        }
+        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) => {
+            if (set.has(item.name)) {
+                throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.DUPLICATE_NAME, this.context.config.moduleName, item.name);
+            }
+            set.add(item.name);
+        });
+        let routerMap = {
+            routerMap: this.context.routerMap.map((item) => {
+                if (item.customData && item.customData.annotation) {
+                    delete item.customData.annotation;
+                    delete item.customData.sourceFilePath;
+                    delete item.customData.isDefaultExport;
+                    delete item.customData.templateData;
+                }
+                return item;
+            }),
+        };
+        const routerMapJsonStr = JSON.stringify(routerMap, null, 2);
+        const routerMapFilePath = this.context.config.getRouterMapDir();
+        framework_1.PluginFileUtil.ensureFileSync(routerMapFilePath);
+        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.debug(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.debug(this.context.node.getNodeName(), `System routerMap added to the current routerMap`);
+            }
+        }
+    }
+}
+exports.RouterMapBuildingProcessor = RouterMapBuildingProcessor;

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

@@ -0,0 +1,7 @@
+export * from './CodeGenerationProcessor';
+export * from './CompletionProcessor';
+export * from './ConfigUpdateProcessor';
+export * from './ObfuscationProcessor';
+export * from './InitializerProcessor';
+export * from './RouterMapBuildingProcessor';
+export * from './ResourceProcessor';

package/dist/hmrouter_extension/processor/index.js

@@ -0,0 +1,23 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CodeGenerationProcessor"), exports);
+__exportStar(require("./CompletionProcessor"), exports);
+__exportStar(require("./ConfigUpdateProcessor"), exports);
+__exportStar(require("./ObfuscationProcessor"), exports);
+__exportStar(require("./InitializerProcessor"), exports);
+__exportStar(require("./RouterMapBuildingProcessor"), exports);
+__exportStar(require("./ResourceProcessor"), exports);