@hadss/hmrouter-plugin 1.0.0-rc.9 → 1.1.1-alpha.0

package/dist/hmrouter_extension/error/PluginError.d.ts

@@ -0,0 +1,29 @@
+export declare enum ErrorCode {
+    UNKNOWN_ERROR = 40000000,
+    DUPLICATE_NAME = 40000001,
+    WRONG_DECORATION = 40000002,
+    REPEAT_ANNOTATION = 40000003,
+    ERROR_CONFIG = 40000004,
+    NOT_EMPTY_STRING = 40000005,
+    INVALID_STRING_VALUE = 40000006,
+    ERROR_PAGE_SOURCE_FILE = 40000007,
+    FILE_ACCESS_ERROR = 40000101,
+    FILE_NOT_FOUND = 40000102,
+    PARSE_FILE_ERROR = 40000103,
+    TEMPLATE_RENDER_ERROR = 40000201,
+    TEMPLATE_NOT_FOUND = 40000202,
+    UNKNOWN_CLASS = 40000301,
+    UNKNOWN_PROPERTY = 40000302,
+    UNKNOWN_CONSTANT = 40000303,
+    UNKNOWN_VARIABLE = 40000304,
+    EXTENSION_LOAD_ERROR = 40000401,
+    EXTENSION_EXECUTE_ERROR = 40000402
+}
+export declare class PluginError extends Error {
+    readonly code: ErrorCode;
+    readonly module: string;
+    readonly data?: any;
+    constructor(code: ErrorCode, module: string, params?: string | string[], data?: any);
+    private logError;
+    static create(code: ErrorCode, module: string, params?: string | string[], data?: any): PluginError;
+}

package/dist/hmrouter_extension/error/PluginError.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginError = exports.ErrorCode = void 0;
+const framework_1 = require("../../framework");
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["UNKNOWN_ERROR"] = 40000000] = "UNKNOWN_ERROR";
+    ErrorCode[ErrorCode["DUPLICATE_NAME"] = 40000001] = "DUPLICATE_NAME";
+    ErrorCode[ErrorCode["WRONG_DECORATION"] = 40000002] = "WRONG_DECORATION";
+    ErrorCode[ErrorCode["REPEAT_ANNOTATION"] = 40000003] = "REPEAT_ANNOTATION";
+    ErrorCode[ErrorCode["ERROR_CONFIG"] = 40000004] = "ERROR_CONFIG";
+    ErrorCode[ErrorCode["NOT_EMPTY_STRING"] = 40000005] = "NOT_EMPTY_STRING";
+    ErrorCode[ErrorCode["INVALID_STRING_VALUE"] = 40000006] = "INVALID_STRING_VALUE";
+    ErrorCode[ErrorCode["ERROR_PAGE_SOURCE_FILE"] = 40000007] = "ERROR_PAGE_SOURCE_FILE";
+    ErrorCode[ErrorCode["FILE_ACCESS_ERROR"] = 40000101] = "FILE_ACCESS_ERROR";
+    ErrorCode[ErrorCode["FILE_NOT_FOUND"] = 40000102] = "FILE_NOT_FOUND";
+    ErrorCode[ErrorCode["PARSE_FILE_ERROR"] = 40000103] = "PARSE_FILE_ERROR";
+    ErrorCode[ErrorCode["TEMPLATE_RENDER_ERROR"] = 40000201] = "TEMPLATE_RENDER_ERROR";
+    ErrorCode[ErrorCode["TEMPLATE_NOT_FOUND"] = 40000202] = "TEMPLATE_NOT_FOUND";
+    ErrorCode[ErrorCode["UNKNOWN_CLASS"] = 40000301] = "UNKNOWN_CLASS";
+    ErrorCode[ErrorCode["UNKNOWN_PROPERTY"] = 40000302] = "UNKNOWN_PROPERTY";
+    ErrorCode[ErrorCode["UNKNOWN_CONSTANT"] = 40000303] = "UNKNOWN_CONSTANT";
+    ErrorCode[ErrorCode["UNKNOWN_VARIABLE"] = 40000304] = "UNKNOWN_VARIABLE";
+    ErrorCode[ErrorCode["EXTENSION_LOAD_ERROR"] = 40000401] = "EXTENSION_LOAD_ERROR";
+    ErrorCode[ErrorCode["EXTENSION_EXECUTE_ERROR"] = 40000402] = "EXTENSION_EXECUTE_ERROR";
+})(ErrorCode = exports.ErrorCode || (exports.ErrorCode = {}));
+const ERROR_MAP = new Map([
+    [ErrorCode.UNKNOWN_ERROR, 'Unknown error'],
+    [ErrorCode.DUPLICATE_NAME, 'Duplicate name: %s'],
+    [ErrorCode.WRONG_DECORATION, 'Structure with @HMRouter annotation cannot contain NavDestination component, filePath: %s'],
+    [ErrorCode.REPEAT_ANNOTATION, 'File contains multiple annotations of the same type: %s'],
+    [ErrorCode.ERROR_CONFIG, 'Module context is empty, please check the hvigorfile.ts file in the module directory: %s'],
+    [ErrorCode.NOT_EMPTY_STRING, 'Constant value cannot be an empty string: %s'],
+    [ErrorCode.INVALID_STRING_VALUE, 'Invalid string value: %s'],
+    [ErrorCode.ERROR_PAGE_SOURCE_FILE, 'Page source file is empty, please check the pageSourceFile: %s'],
+    [ErrorCode.FILE_ACCESS_ERROR, 'File access error: %s'],
+    [ErrorCode.FILE_NOT_FOUND, 'File not found: %s'],
+    [ErrorCode.PARSE_FILE_ERROR, 'File parsing error: %s'],
+    [ErrorCode.TEMPLATE_RENDER_ERROR, 'Template rendering error: %s'],
+    [ErrorCode.TEMPLATE_NOT_FOUND, 'Template not found: %s'],
+    [ErrorCode.UNKNOWN_CLASS, 'Unknown class: %s'],
+    [ErrorCode.UNKNOWN_PROPERTY, 'Unknown property: %s'],
+    [ErrorCode.UNKNOWN_CONSTANT, 'Unknown constant: %s'],
+    [ErrorCode.UNKNOWN_VARIABLE, 'Unknown variable: %s'],
+    [ErrorCode.EXTENSION_LOAD_ERROR, 'Extension loading error: %s'],
+    [ErrorCode.EXTENSION_EXECUTE_ERROR, 'Extension execution error: %s'],
+]);
+class PluginError extends Error {
+    constructor(code, module, params, data) {
+        let message = ERROR_MAP.get(code) || 'Unknown error';
+        if (params) {
+            if (Array.isArray(params)) {
+                params.forEach((param) => {
+                    message = message.replace(`%s`, param);
+                });
+            }
+            else {
+                message = message.replace('%s', params);
+            }
+        }
+        super(message);
+        this.code = code;
+        this.module = module;
+        this.data = data;
+        Object.setPrototypeOf(this, PluginError.prototype);
+        this.logError();
+    }
+    logError() {
+        framework_1.Logger.error(this.module, `error code: ${this.code}, error message: ${this.message}`, this.data);
+    }
+    static create(code, module, params, data) {
+        return new PluginError(code, module, params, data);
+    }
+}
+exports.PluginError = PluginError;

package/dist/hmrouter_extension/model/HMAnnotationModel.d.ts

@@ -0,0 +1,28 @@
+import { BaseAnalyzeResult } from '../../framework';
+export interface HMRouterResult extends BaseAnalyzeResult {
+    pageUrl: any;
+    dialog?: boolean;
+    singleton?: boolean;
+    interceptors?: string[];
+    animator?: string;
+    lifecycle?: string;
+    useNavDst?: boolean;
+}
+export interface HMAnimatorResult extends BaseAnalyzeResult {
+    animatorName: string;
+}
+export interface HMInterceptorResult extends BaseAnalyzeResult {
+    interceptorName: string;
+    priority?: number;
+    global?: boolean;
+}
+export interface HMLifecycleResult extends BaseAnalyzeResult {
+    lifecycleName: string;
+    priority?: number;
+    global?: boolean;
+}
+export interface HMServiceResult extends BaseAnalyzeResult {
+    serviceName: string;
+    functionName: string;
+    singleton?: boolean;
+}

package/dist/hmrouter_extension/model/HMAnnotationModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hmrouter_extension/model/RouterInfo.d.ts

@@ -0,0 +1,6 @@
+export interface RouterInfo {
+    name: string;
+    pageSourceFile: string;
+    buildFunction: string;
+    customData: Record<string, any>;
+}

package/dist/hmrouter_extension/model/RouterInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/hmrouter_extension/model/TemplateModel.d.ts

@@ -0,0 +1,8 @@
+export interface TemplateModel {
+    pageUrl: string;
+    importPath: string;
+    componentName: string;
+    dialog: boolean;
+    generatorViewName: string;
+    isDefaultExport?: boolean;
+}

package/dist/hmrouter_extension/model/TemplateModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,3 @@
+export * from './HMAnnotationModel';
+export * from './TemplateModel';
+export * from './RouterInfo';

package/dist/hmrouter_extension/model/index.js

@@ -0,0 +1,19 @@
+"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("./HMAnnotationModel"), exports);
+__exportStar(require("./TemplateModel"), exports);
+__exportStar(require("./RouterInfo"), exports);

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

@@ -0,0 +1,13 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class CodeGenerationProcessor {
+    private context;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private generatePageFile;
+    private matchedPath;
+    private prepareTemplateModel;
+    private determineTemplatePath;
+    private generateFile;
+    private detectLibraryVersion;
+    private getLibraryPossiblePaths;
+}

package/dist/hmrouter_extension/processor/CodeGenerationProcessor.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGenerationProcessor = void 0;
+const micromatch_1 = __importDefault(require("micromatch"));
+const ejs_1 = __importDefault(require("ejs"));
+const framework_1 = require("../../framework");
+const PluginError_1 = require("../error/PluginError");
+const constants_1 = require("../constants");
+class CodeGenerationProcessor {
+    constructor(context) {
+        this.context = context;
+    }
+    execute() {
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Start to code generation...`);
+        this.context.generatedPaths = new Map();
+        this.context.getAnalyzeResults().forEach((result) => {
+            if (result.annotation === constants_1.AnnotationConstants.ROUTER_ANNOTATION) {
+                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);
+                this.generatePageFile(result, pageSourceFile, this.matchedPath(pageSourceFile, this.context.config.customPageTemplate, this.context.config.getDefaultTplFilePath()));
+            }
+        });
+    }
+    generatePageFile(result, pageSourceFile, tempFilePath) {
+        const templateModel = this.prepareTemplateModel(result, pageSourceFile);
+        tempFilePath = this.determineTemplatePath(result, tempFilePath);
+        const generatedFilePath = this.generateFile(templateModel, tempFilePath);
+        framework_1.Logger.info(this.context.node.getNodeName(), `Builder ${templateModel.generatorViewName}.ets has been generated in ${generatedFilePath}`);
+        this.context.generatedPaths.set(result.name, generatedFilePath);
+    }
+    matchedPath(filePath, customPageTemplate, defaultTplFilePath) {
+        for (const template of customPageTemplate) {
+            if (micromatch_1.default.isMatch(filePath, template.srcPath)) {
+                framework_1.Logger.debug(this.context.node.getNodeName(), `${filePath} detected matching template: ${template.templatePath}`);
+                return framework_1.PluginFileUtil.pathResolve(this.context.config.configDir, template.templatePath);
+            }
+        }
+        return defaultTplFilePath;
+    }
+    prepareTemplateModel(analyzeResult, pageSourceFile) {
+        let importPath = this.context.config
+            .getRelativeBuilderPath(pageSourceFile)
+            .replaceAll(constants_1.FilePathConstants.FILE_SEPARATOR, constants_1.FilePathConstants.DELIMITER)
+            .replaceAll(constants_1.FilePathConstants.ETS_SUFFIX, '');
+        let generatorViewName = constants_1.PrefixConstants.VIEW_NAME_PREFIX + analyzeResult.name + framework_1.StringUtil.stringToHashCode(analyzeResult.pageUrl);
+        let templateData = this.context.getTemplateData(analyzeResult.name);
+        return {
+            pageUrl: analyzeResult.pageUrl,
+            componentName: analyzeResult.name,
+            dialog: !!analyzeResult.dialog,
+            isDefaultExport: !!templateData?.isDefaultExport,
+            importPath,
+            generatorViewName,
+            ...templateData,
+        };
+    }
+    determineTemplatePath(analyzeResult, defaultTemplatePath) {
+        const libraryVersion = this.detectLibraryVersion();
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Library version: ${libraryVersion}`);
+        const useV1Template = libraryVersion.startsWith(constants_1.VersionConstants.HMROUTER_VERSION_V1);
+        if (useV1Template) {
+            return framework_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3) + constants_1.TemplateConstants.V1_TEMPLATE);
+        }
+        else if (analyzeResult.useNavDst === true) {
+            return framework_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3), constants_1.TemplateConstants.CUSTOM_BUILDER_TEMPLATE);
+        }
+        return defaultTemplatePath;
+    }
+    generateFile(templateModel, templatePath) {
+        if (!framework_1.PluginFileUtil.exist(templatePath)) {
+            throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.TEMPLATE_NOT_FOUND, this.context.config.moduleName, templatePath);
+        }
+        const tpl = framework_1.PluginFileUtil.readFileSync(templatePath).toString();
+        const templateStr = ejs_1.default.render(tpl, templateModel);
+        const generatorFilePath = this.context.config.getGeneratedFilePath(templateModel.generatorViewName);
+        framework_1.PluginFileUtil.ensureFileSync(generatorFilePath);
+        framework_1.PluginFileUtil.writeFileSync(generatorFilePath, templateStr);
+        return this.context.config
+            .getBuilderFilePath(templateModel.generatorViewName)
+            .replaceAll(constants_1.FilePathConstants.FILE_SEPARATOR, constants_1.FilePathConstants.DELIMITER);
+    }
+    detectLibraryVersion() {
+        let libraryVersion = '';
+        const possiblePaths = this.getLibraryPossiblePaths();
+        for (const packagePath of possiblePaths) {
+            try {
+                if (framework_1.PluginFileUtil.exist(packagePath)) {
+                    const packageJson = framework_1.PluginFileUtil.readJson5(packagePath);
+                    libraryVersion = packageJson[constants_1.VersionConstants.HMROUTER_VERSION_KEY] || '';
+                    if (libraryVersion) {
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
+        return libraryVersion;
+    }
+    getLibraryPossiblePaths() {
+        const paths = [];
+        paths.push(framework_1.PluginFileUtil.pathResolve(this.context.config.modulePath, constants_1.FilePathConstants.OH_MODULE_PATH, constants_1.VersionConstants.HMROUTER_ORGANIZATION, constants_1.VersionConstants.HMROUTER_LIB_NAME, constants_1.FilePathConstants.OH_PACKAGE_FILE_NAME));
+        const projectRoot = framework_1.PluginStore.getInstance().get('projectFilePath');
+        if (projectRoot && projectRoot !== this.context.config.modulePath) {
+            paths.push(framework_1.PluginFileUtil.pathResolve(projectRoot, constants_1.FilePathConstants.OH_MODULE_PATH, constants_1.VersionConstants.HMROUTER_ORGANIZATION, constants_1.VersionConstants.HMROUTER_LIB_NAME, constants_1.FilePathConstants.OH_PACKAGE_FILE_NAME));
+        }
+        return paths;
+    }
+}
+exports.CodeGenerationProcessor = CodeGenerationProcessor;

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

@@ -0,0 +1,11 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class CompletionProcessor {
+    private context;
+    private config;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private deleteRouterMapFile;
+    private deleteRawFile;
+    private deleteGeneratorFile;
+    private deleteObfuscationFile;
+}

package/dist/hmrouter_extension/processor/CompletionProcessor.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionProcessor = void 0;
+const framework_1 = require("../../framework");
+class CompletionProcessor {
+    constructor(context) {
+        this.context = context;
+        this.config = context.config;
+    }
+    execute() {
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Start to delete temporary files...`);
+        if (this.context.config.saveGeneratedFile) {
+            framework_1.Logger.info(this.context.node.getNodeName(), `Save generated file is true, skip deleting temporary files`);
+            return;
+        }
+        this.deleteRouterMapFile();
+        this.deleteRawFile();
+        this.deleteGeneratorFile();
+        if (this.config?.autoObfuscation) {
+            this.deleteObfuscationFile();
+        }
+    }
+    deleteRouterMapFile() {
+        let routerMapDirPath = this.config.getRouterMapDir();
+        if (framework_1.PluginFileUtil.exist(routerMapDirPath)) {
+            framework_1.PluginFileUtil.unlinkSync(routerMapDirPath);
+            framework_1.Logger.info(this.context.node.getNodeName(), `Delete router map file successfully, filePath: ${routerMapDirPath}`);
+        }
+    }
+    deleteRawFile() {
+        let rawFilePath = this.config.getRawFilePath();
+        if (framework_1.PluginFileUtil.exist(rawFilePath)) {
+            framework_1.PluginFileUtil.unlinkSync(rawFilePath);
+            framework_1.Logger.info(this.context.node.getNodeName(), `Delete raw file successfully, filePath: ${rawFilePath}`);
+        }
+    }
+    deleteGeneratorFile() {
+        let builderDirPath = this.config.getBuilderDir();
+        if (framework_1.PluginFileUtil.exist(builderDirPath)) {
+            framework_1.PluginFileUtil.rmSync(builderDirPath, {
+                recursive: true,
+            });
+            framework_1.Logger.info(this.context.node.getNodeName(), `Delete generator file successfully, filePath: ${builderDirPath}`);
+        }
+    }
+    deleteObfuscationFile() {
+        let obfuscationFilePath = this.config.getObfuscationFilePath();
+        if (framework_1.PluginFileUtil.exist(obfuscationFilePath)) {
+            framework_1.PluginFileUtil.unlinkSync(obfuscationFilePath);
+            framework_1.Logger.info(this.context.node.getNodeName(), `Delete obfuscation file successfully, filePath: ${obfuscationFilePath}`);
+        }
+        let consumerRulesPath = this.config.getConsumerRulesFilePath();
+        if (framework_1.PluginFileUtil.exist(consumerRulesPath)) {
+            framework_1.PluginFileUtil.unlinkSync(consumerRulesPath);
+            framework_1.Logger.info(this.context.node.getNodeName(), `Delete consumer rules file successfully, filePath: ${consumerRulesPath}`);
+        }
+    }
+}
+exports.CompletionProcessor = CompletionProcessor;

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

@@ -0,0 +1,11 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class ConfigUpdateProcessor {
+    private moduleContext;
+    private readonly routerMap;
+    private readonly nodeName;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private updateModuleJson;
+    private updateBuildProfile;
+    private pushRouterInfo;
+}

package/dist/hmrouter_extension/processor/ConfigUpdateProcessor.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigUpdateProcessor = void 0;
+const framework_1 = require("../../framework");
+const constants_1 = require("../constants");
+class ConfigUpdateProcessor {
+    constructor(context) {
+        this.moduleContext = context.moduleContext;
+        this.routerMap = context.routerMap;
+        this.nodeName = context.node.getNodeName();
+    }
+    execute() {
+        framework_1.Logger.debug(this.nodeName, `Start to update module.json and build profile...`);
+        this.updateModuleJson();
+        this.updateBuildProfile();
+    }
+    updateModuleJson() {
+        const moduleJsonOpt = this.moduleContext.getModuleJsonOpt();
+        moduleJsonOpt.module.routerMap = constants_1.RouterMapConstants.MODULE_ROUTER_MAP_NAME;
+        this.moduleContext.setModuleJsonOpt(moduleJsonOpt);
+        framework_1.Logger.info(this.nodeName, `Update module.json5 routerMap successfully, current routerMap: ${this.moduleContext.getModuleJsonOpt().module.routerMap}`);
+    }
+    updateBuildProfile() {
+        const buildProfileOpt = this.moduleContext.getBuildProfileOpt();
+        let sources = framework_1.ObjectUtils.ensureNestedObject(buildProfileOpt, [
+            'buildOption',
+            'arkOptions',
+            'runtimeOnly',
+            'sources',
+        ]);
+        if (!Array.isArray(sources)) {
+            buildProfileOpt.buildOption.arkOptions.runtimeOnly.sources = [];
+        }
+        this.pushRouterInfo(buildProfileOpt, this.routerMap);
+        this.moduleContext.setBuildProfileOpt(buildProfileOpt);
+        framework_1.Logger.info(this.nodeName, `Update build profile successfully, current sources: ${this.moduleContext.getBuildProfileOpt()?.buildOption?.arkOptions?.runtimeOnly?.sources}`);
+    }
+    pushRouterInfo(buildProfileOpt, routerMap) {
+        let sources = buildProfileOpt.buildOption.arkOptions.runtimeOnly.sources;
+        routerMap.forEach((item) => {
+            const name = item.name;
+            if (name.includes(constants_1.PrefixConstants.LIFECYCLE_PREFIX) ||
+                name.includes(constants_1.PrefixConstants.INTERCEPTOR_PREFIX) ||
+                name.includes(constants_1.PrefixConstants.ANIMATOR_PREFIX) ||
+                name.includes(constants_1.PrefixConstants.SERVICE_PREFIX) ||
+                name.includes(constants_1.PrefixConstants.SERVICE_PROVIDE_PREFIX)) {
+                sources.push(constants_1.FilePathConstants.CURRENT_DELIMITER + item.pageSourceFile);
+            }
+        });
+        sources = [...new Set(sources)];
+    }
+}
+exports.ConfigUpdateProcessor = ConfigUpdateProcessor;

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,95 @@
+"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);
+        }
+    }
+    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,13 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class ObfuscationProcessor {
+    private context;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private checkObfuscationEnabled;
+    private generateObfuscationRuleFile;
+    private handleHarPackageLogic;
+    private isEnableObfuscation;
+    private addHMRouterObfuscationRules;
+    private appendFilePathSafely;
+    private buildObfuscatedStrings;
+}