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

package/dist/HMRouterAnalyzer.js

@@ -3,12 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnalyzerController = void 0;
+exports.AnalyzerService = exports.AnalyzerController = void 0;
 const ts_morph_1 = require("ts-morph");
 const Logger_1 = require("./common/Logger");
-const CommonConstants_1 = __importDefault(require("./constants/CommonConstants"));
 const TsAstUtil_1 = require("./utils/TsAstUtil");
+const CommonConstants_1 = __importDefault(require("./constants/CommonConstants"));
 const FileUtil_1 = __importDefault(require("./utils/FileUtil"));
+const ConfigConstants_1 = __importDefault(require("./constants/ConfigConstants"));
+const PluginStore_1 = __importDefault(require("./store/PluginStore"));
 class AnalyzerController {
     constructor() {
         this.analyzeResult = new Set();
@@ -20,31 +22,55 @@ class AnalyzerController {
             item.pageSourceFile = sourceFilePath;
             this.analyzeResult.add(item);
         });
-        this.parsePageUrl();
+        this.parseConstants();
     }
-    parsePageUrl() {
+    parseConstants() {
         this.analyzeResult.forEach((item) => {
-            if (item.annotation !== 'HMRouter') {
-                return;
+            Object.getOwnPropertyNames(item).forEach((key) => {
+                let propertyValue = Reflect.get(item, key);
+                propertyValue = this.parsePropertyValue(propertyValue);
+                if (propertyValue === '') {
+                    Logger_1.Logger.error(Logger_1.PluginError.ERR_NOT_EMPTY_STRING);
+                    throw new Error('constants value cannot be an empty string, filePath:' + item.pageSourceFile);
+                }
+                Reflect.set(item, key, propertyValue);
+            });
+        });
+    }
+    parsePropertyValue(propertyValue) {
+        if (propertyValue.type === 'constant') {
+            try {
+                return TsAstUtil_1.TsAstUtil.parseConstantValue(TsAstUtil_1.TsAstUtil.getSourceFile(propertyValue.variableFilePath), propertyValue.variableName);
             }
-            let pageUrl = item.pageUrl;
-            if (pageUrl.type === 'constant') {
-                pageUrl =
-                    TsAstUtil_1.TsAstUtil.parseConstantValue(TsAstUtil_1.project.addSourceFileAtPath(pageUrl.variableFilePath), pageUrl.variableName);
+            catch (error) {
+                Logger_1.Logger.error(`Failed to parse constant ${propertyValue.variableName}: ${error.message}`);
+                throw new Error(`Failed to parse constant ${propertyValue.variableName}: ${error.message}`);
             }
-            else if (pageUrl.type === 'object') {
-                pageUrl = TsAstUtil_1.TsAstUtil.parseConstantValue(TsAstUtil_1.project.addSourceFileAtPath(pageUrl.variableFilePath), pageUrl.variableName, pageUrl.propertyName);
+        }
+        else if (propertyValue.type === 'object') {
+            try {
+                return TsAstUtil_1.TsAstUtil.parseConstantValue(TsAstUtil_1.TsAstUtil.getSourceFile(propertyValue.variableFilePath), propertyValue.variableName, propertyValue.propertyName);
             }
-            if (pageUrl === '') {
-                Logger_1.Logger.error(Logger_1.PluginError.ERR_NOT_EMPTY_STRING);
-                throw new Error('constant value cannot be an empty string');
+            catch (error) {
+                Logger_1.Logger.error(`Failed to parse object property ${propertyValue.variableName}.${propertyValue.propertyName}: ${error.message}`);
+                throw new Error(`Failed to parse object property ${propertyValue.variableName}.${propertyValue.propertyName}: ${error.message}`);
             }
-            item.pageUrl = pageUrl;
-        });
+        }
+        else if (propertyValue.type === 'array') {
+            return propertyValue.value.map((item) => {
+                return this.parsePropertyValue(item);
+            });
+        }
+        else {
+            return propertyValue;
+        }
     }
     getAnalyzeResultSet() {
         return this.analyzeResult;
     }
+    clearAnalyzeResultSet() {
+        this.analyzeResult.clear();
+    }
 }
 exports.AnalyzerController = AnalyzerController;
 class AnalyzerService {
@@ -75,9 +101,9 @@ class AnalyzerService {
         return this.analyzerResultSet;
     }
     analyzeImport() {
-        this.sourceFile.getImportDeclarations().forEach(importDeclaration => {
+        this.sourceFile.getImportDeclarations().forEach((importDeclaration) => {
             const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
-            const namedImports = importDeclaration.getNamedImports().map(namedImport => namedImport.getName());
+            const namedImports = importDeclaration.getNamedImports().map((namedImport) => namedImport.getName());
             const defaultImport = importDeclaration.getDefaultImport()?.getText();
             const namespaceImport = importDeclaration.getNamespaceImport()?.getText();
             const importNames = [];
@@ -91,20 +117,23 @@ class AnalyzerService {
                 importNames.push(namespaceImport);
             }
             if (importNames.length > 0) {
-                let variableFilePath = FileUtil_1.default.pathResolve(this.config.modulePath, moduleSpecifier);
-                importNames.forEach((item) => {
-                    if (FileUtil_1.default.exist(variableFilePath)) {
-                        TsAstUtil_1.importVariableCache.set(variableFilePath + CommonConstants_1.default.VARIABLE_SEPARATOR + item, '');
-                    }
-                });
-                this.importMap.set(moduleSpecifier, importNames);
+                if (this.importMap.has(moduleSpecifier)) {
+                    const existingImports = this.importMap.get(moduleSpecifier);
+                    this.importMap.set(moduleSpecifier, [...new Set([...existingImports, ...importNames])]);
+                }
+                else {
+                    this.importMap.set(moduleSpecifier, importNames);
+                }
             }
         });
     }
     analyzeRouter() {
-        let viewNameArr = this.sourceFile.getChildrenOfKind(ts_morph_1.SyntaxKind.ExpressionStatement).map((node) => {
+        let viewNameArr = this.sourceFile
+            .getChildrenOfKind(ts_morph_1.SyntaxKind.ExpressionStatement)
+            .map((node) => {
             return node.getText();
-        }).filter((text) => {
+        })
+            .filter((text) => {
             return text != 'struct';
         });
         this.sourceFile.getChildrenOfKind(ts_morph_1.SyntaxKind.MissingDeclaration).forEach((node, index) => {
@@ -112,23 +141,42 @@ class AnalyzerService {
                 this.addToResultSet(decorator, viewNameArr[index]);
             });
         });
+        this.sourceFile.getExportAssignments().forEach((exportAssignment, index) => {
+            exportAssignment.getDescendantsOfKind(ts_morph_1.SyntaxKind.Decorator).forEach((decorator) => {
+                let result = this.addToResultSet(decorator, viewNameArr[index]);
+                result.isDefaultExport = true;
+            });
+        });
     }
     parseFileByLineOrder() {
         const statements = this.sourceFile.getStatements();
         const sortedStatements = statements.sort((a, b) => a.getStart() - b.getStart());
         let HMRouterExists = false;
-        sortedStatements.forEach(statement => {
+        let useNavDst = false;
+        sortedStatements.forEach((statement) => {
             if (statement.getKind() === ts_morph_1.SyntaxKind.MissingDeclaration && statement.getText().includes('HMRouter')) {
                 HMRouterExists = true;
+                useNavDst = false;
+                const text = statement.getText();
+                if (/(useNavDst\s*:\s*true)/.test(text)) {
+                    useNavDst = true;
+                    Logger_1.Logger.info('Found HMRouter with useNavDst=true, skipping NavDestination check');
+                }
             }
             if (statement.getKind() === ts_morph_1.SyntaxKind.Block && HMRouterExists) {
                 HMRouterExists = false;
-                statement.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier).forEach((node) => {
-                    if (node.getText() === 'NavDestination') {
-                        Logger_1.Logger.error(Logger_1.PluginError.ERR_WRONG_DECORATION);
-                        throw new Error('NavDestination is not allowed in HMRouter, filePath:' + this.sourceFilePath);
-                    }
-                });
+                if (useNavDst) {
+                    return;
+                }
+                let reg = new RegExp(/NavDestination\s*\(\s*\)/);
+                let text = statement.getText();
+                const cleanedCodeBlock = text
+                    .replace(/(["'`]).*?\1/g, '')
+                    .replace(/\/\/.*|\/\*[\s\S]*?\*\//g, '');
+                if (reg.test(cleanedCodeBlock)) {
+                    Logger_1.Logger.error(Logger_1.PluginError.ERR_WRONG_DECORATION);
+                    throw new Error('NavDestination is not allowed in HMRouter, filePath:' + this.sourceFilePath);
+                }
             }
         });
     }
@@ -167,45 +215,57 @@ class AnalyzerService {
     }
     parseDecoratorArguments(decorator) {
         let argResult = {};
-        decorator.getArguments().map(arg => {
+        decorator.getArguments().map((arg) => {
             const objLiteral = arg.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
             if (objLiteral) {
                 objLiteral.getProperties().forEach((prop) => {
                     let propertyName = prop.getName();
-                    let propertyValue = propertyName === CommonConstants_1.default.PAGE_URL ?
-                        this.parsePageUrlValue(prop.getInitializer()) :
-                        this.parsePropertyValue(prop.getInitializer());
+                    let propertyValue = this.parseIdentifierPropertyValue(prop.getInitializer());
                     Reflect.set(argResult, propertyName, propertyValue);
                 });
             }
         });
         return argResult;
     }
-    parsePageUrlValue(value) {
+    parseIdentifierPropertyValue(value) {
         switch (value.getKind()) {
             case ts_morph_1.SyntaxKind.Identifier:
+                if (value.getText() === 'undefined') {
+                    throw new Error(`Invalid property value, in ${this.sourceFilePath}`);
+                }
                 return {
                     type: 'constant',
                     variableName: value.getText(),
-                    variableFilePath: this.getVariableFilePath(value.getText())
+                    variableFilePath: this.getVariableFilePath(value.getText()),
                 };
             case ts_morph_1.SyntaxKind.PropertyAccessExpression:
                 return {
                     type: 'object',
                     variableName: value.getExpression().getText(),
                     propertyName: value?.getName(),
-                    variableFilePath: this.getVariableFilePath(value?.getExpression().getText())
+                    variableFilePath: this.getVariableFilePath(value?.getExpression().getText()),
+                };
+            case ts_morph_1.SyntaxKind.ArrayLiteralExpression:
+                return {
+                    type: 'array',
+                    value: value
+                        .asKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression)
+                        ?.getElements()
+                        .map((item) => this.parseIdentifierPropertyValue(item)),
                 };
             default:
-                return this.parsePropertyValue(value);
+                return this.parsePrimitiveValue(value);
         }
     }
-    parsePropertyValue(value) {
+    parsePrimitiveValue(value) {
         let propertyValue;
         switch (value.getKind()) {
             case ts_morph_1.SyntaxKind.StringLiteral:
                 propertyValue = value.asKind(ts_morph_1.SyntaxKind.StringLiteral)?.getLiteralValue();
                 break;
+            case ts_morph_1.SyntaxKind.NumericLiteral:
+                propertyValue = value.asKind(ts_morph_1.SyntaxKind.NumericLiteral)?.getLiteralValue();
+                break;
             case ts_morph_1.SyntaxKind.TrueKeyword:
                 propertyValue = true;
                 break;
@@ -213,13 +273,16 @@ class AnalyzerService {
                 propertyValue = false;
                 break;
             case ts_morph_1.SyntaxKind.ArrayLiteralExpression:
-                propertyValue = value.asKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression)?.getElements()
-                    .map(item => item.asKind(ts_morph_1.SyntaxKind.StringLiteral)?.getLiteralValue());
+                propertyValue = value
+                    .asKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression)
+                    ?.getElements()
+                    .map((item) => item.asKind(ts_morph_1.SyntaxKind.StringLiteral)?.getLiteralValue());
                 break;
         }
         return propertyValue;
     }
     getVariableFilePath(variableName) {
+        let filePath = '';
         let classesNames = this.sourceFile.getClasses().map((classes) => {
             return classes.getName();
         });
@@ -229,16 +292,52 @@ class AnalyzerService {
         if (classesNames.includes(variableName) || variableNames.includes(variableName)) {
             return this.sourceFilePath;
         }
-        else {
-            let filePath = '';
-            this.importMap.forEach((value, key) => {
-                if (value.includes(variableName)) {
-                    filePath =
-                        FileUtil_1.default.pathResolve(this.sourceFilePath.split(CommonConstants_1.default.FILE_SEPARATOR).slice(0, -1)
-                            .join(CommonConstants_1.default.FILE_SEPARATOR), key) + CommonConstants_1.default.VIEW_NAME_SUFFIX;
+        for (const [importPath, importNames] of this.importMap.entries()) {
+            if (importNames.includes(variableName)) {
+                try {
+                    let currentDir = FileUtil_1.default.pathResolve(this.sourceFilePath, CommonConstants_1.default.PARENT_DELIMITER);
+                    let tempFilePath = FileUtil_1.default.pathResolve(currentDir, importPath + CommonConstants_1.default.ETS_SUFFIX);
+                    if (FileUtil_1.default.exist(tempFilePath)) {
+                        filePath = tempFilePath;
+                    }
+                    else {
+                        try {
+                            filePath = this.getOtherModuleVariableFilePath(importPath, variableName);
+                        }
+                        catch (error) {
+                            Logger_1.Logger.warn(`Cannot find variable ${variableName} in module ${importPath}: ${error.message}`);
+                        }
+                    }
                 }
-            });
-            return filePath;
+                catch (error) {
+                    Logger_1.Logger.warn(`Error parsing import path ${importPath}: ${error.message}`);
+                }
+            }
+        }
+        if (!filePath) {
+            Logger_1.Logger.warn(`Cannot find file path for variable ${variableName}`);
+        }
+        return filePath;
+    }
+    getOtherModuleVariableFilePath(moduleName, variableName) {
+        let moduleFilePath = FileUtil_1.default.pathResolve(this.config.modulePath, CommonConstants_1.default.OH_MODULE_PATH, moduleName, ConfigConstants_1.default.DEFAULT_SCAN_DIR);
+        if (!FileUtil_1.default.exist(moduleFilePath)) {
+            moduleFilePath = FileUtil_1.default.pathResolve(PluginStore_1.default.getInstance().projectFilePath, CommonConstants_1.default.OH_MODULE_PATH, moduleName, ConfigConstants_1.default.DEFAULT_SCAN_DIR);
+        }
+        let variableMap;
+        if (PluginStore_1.default.getInstance().variableCache.has(moduleName)) {
+            variableMap = PluginStore_1.default.getInstance().variableCache.get(moduleName);
+        }
+        else {
+            variableMap = TsAstUtil_1.TsAstUtil.parseCrossModuleVariable(moduleFilePath);
+            PluginStore_1.default.getInstance().variableCache.set(moduleName, variableMap);
+        }
+        for (let [key, value] of variableMap) {
+            if (value.includes(variableName)) {
+                return key;
+            }
         }
+        throw new Error(`Unknown variable ${variableName} in ${moduleName}`);
     }
 }
+exports.AnalyzerService = AnalyzerService;

package/dist/HMRouterHvigorPlugin.js

@@ -26,7 +26,7 @@ class HMRouterHvigorPlugin {
         });
         Logger_1.Logger.info(`Scanned ${this.scanFiles.length} files`, this.scanFiles);
         this.scanFiles.forEach((filePath) => {
-            if (filePath.endsWith(CommonConstants_1.default.VIEW_NAME_SUFFIX)) {
+            if (filePath.endsWith(CommonConstants_1.default.ETS_SUFFIX)) {
                 this.analyzerController.analyzeFile(filePath, this.config);
             }
         });
@@ -50,15 +50,17 @@ class HMRouterHvigorPlugin {
                 if (item.customData && item.customData.annotation) {
                     delete item.customData.annotation;
                     delete item.customData.pageSourceFile;
+                    delete item.customData.isDefaultExport;
                 }
                 return item;
-            }),
+            })
         };
         const routerMapJsonStr = JSON.stringify(routerMap, null, 2);
         const routerMapFilePath = this.config.getRouterMapDir();
         FileUtil_1.default.ensureFileSync(routerMapFilePath);
         FileUtil_1.default.writeFileSync(routerMapFilePath, routerMapJsonStr);
         Logger_1.Logger.info(`hm_router_map.json has been generated in ${routerMapFilePath}`);
+        this.analyzerController.clearAnalyzeResultSet();
     }
     matchedPath(filePath, customPageTemplate, defaultTplFilePath) {
         for (const template of customPageTemplate) {
@@ -94,17 +96,34 @@ class HMRouterHvigorPlugin {
                 let serviceName = CommonConstants_1.default.SERVICE_PREFIX + analyzeResult.serviceName;
                 this.routerMap.push(new PluginModel_1.RouterInfo(serviceName, pageSourceFile, '', analyzeResult));
                 break;
+            case CommonConstants_1.default.SERVICE_PROVIDE_ANNOTATION:
+                let className = CommonConstants_1.default.SERVICE_PROVIDE_PREFIX + analyzeResult.serviceName;
+                this.routerMap.push(new PluginModel_1.RouterInfo(className, pageSourceFile, '', analyzeResult));
+                break;
         }
     }
     generateBuilder(analyzeResult, pageSourceFile, tempFilePath) {
         let importPath = this.config
             .getRelativeBuilderPath(pageSourceFile)
             .replaceAll(CommonConstants_1.default.FILE_SEPARATOR, CommonConstants_1.default.DELIMITER)
-            .replaceAll(CommonConstants_1.default.VIEW_NAME_SUFFIX, '');
+            .replaceAll(CommonConstants_1.default.ETS_SUFFIX, '');
         let generatorViewName = CommonConstants_1.default.VIEW_NAME_PREFIX +
             analyzeResult.name +
             StringUtil_1.StringUtil.stringToHashCode(analyzeResult.pageUrl);
-        const templateModel = new PluginModel_1.TemplateModel(analyzeResult.pageUrl, importPath, analyzeResult.name, !!analyzeResult.dialog, generatorViewName);
+        const templateModel = new PluginModel_1.TemplateModel(analyzeResult.pageUrl, importPath, analyzeResult.name, !!analyzeResult.dialog, generatorViewName, analyzeResult.isDefaultExport);
+        if (analyzeResult.useNavDst === true) {
+            Logger_1.Logger.info(`Using custom template for ${analyzeResult.name} with useNavDst=true`);
+            const customTplPath = FileUtil_1.default.pathResolve(__dirname, CommonConstants_1.default.PARENT_DELIMITER + CommonConstants_1.default.CUSTOM_BUILDER_TEMPLATE);
+            if (FileUtil_1.default.exist(customTplPath)) {
+                tempFilePath = customTplPath;
+            }
+            else {
+                Logger_1.Logger.info(`Custom template not found at ${customTplPath}, falling back to default template`);
+            }
+        }
+        if (!FileUtil_1.default.exist(tempFilePath)) {
+            throw new Error('Invalid template path: ' + tempFilePath);
+        }
         const tpl = FileUtil_1.default.readFileSync(tempFilePath).toString();
         const templateStr = ejs_1.default.render(tpl, templateModel);
         const generatorFilePath = this.config.getGeneratedFilePath(templateModel.generatorViewName);

package/dist/HMRouterPluginConfig.d.ts

@@ -22,6 +22,7 @@ export declare class HMRouterPluginConfig {
     getRawFilePath(): string;
     getDefaultTplFilePath(): string;
     getObfuscationFilePath(): string;
+    getConsumerRulesFilePath(): string;
 }
 export interface HMRouterPluginConfigParam {
     scanDir?: string[];

package/dist/HMRouterPluginConfig.js

@@ -21,7 +21,8 @@ class HMRouterPluginConfig {
             ConfigConstants_1.default.ANIMATOR_ANNOTATION,
             ConfigConstants_1.default.INTERCEPTOR_ANNOTATION,
             ConfigConstants_1.default.LIFECYCLE_ANNOTATION,
-            ConfigConstants_1.default.SERVICE_ANNOTATION
+            ConfigConstants_1.default.SERVICE_ANNOTATION,
+            ConfigConstants_1.default.SERVICE_PROVIDE_ANNOTATION
         ];
         this.defaultPageTemplate =
             param.defaultPageTemplate ? param.defaultPageTemplate : ConfigConstants_1.default.DEFAULT_BUILD_TPL;
@@ -39,13 +40,13 @@ class HMRouterPluginConfig {
         return path_1.default.relative(this.builderDir, filePath);
     }
     getGeneratedFilePath(generatorViewName) {
-        return FileUtil_1.default.pathResolve(this.modulePath, this.builderDir, generatorViewName + CommonConstants_1.default.VIEW_NAME_SUFFIX);
+        return FileUtil_1.default.pathResolve(this.modulePath, this.builderDir, generatorViewName + CommonConstants_1.default.ETS_SUFFIX);
     }
     getBuilderDir() {
         return FileUtil_1.default.pathResolve(this.modulePath, this.builderDir);
     }
     getBuilderFilePath(generatorViewName) {
-        return path_1.default.join(this.builderDir, generatorViewName + CommonConstants_1.default.VIEW_NAME_SUFFIX);
+        return path_1.default.join(this.builderDir, generatorViewName + CommonConstants_1.default.ETS_SUFFIX);
     }
     getRouterMapDir() {
         return FileUtil_1.default.pathResolve(this.modulePath, this.routerMapDir, CommonConstants_1.default.ROUTER_MAP_NAME);
@@ -66,5 +67,8 @@ class HMRouterPluginConfig {
     getObfuscationFilePath() {
         return FileUtil_1.default.pathResolve(this.modulePath, CommonConstants_1.default.OBFUSCATION_FILE_NAME);
     }
+    getConsumerRulesFilePath() {
+        return FileUtil_1.default.pathResolve(this.modulePath, CommonConstants_1.default.CONSUMER_FILE_NAME);
+    }
 }
 exports.HMRouterPluginConfig = HMRouterPluginConfig;

package/dist/HMRouterPluginHandle.d.ts

@@ -13,6 +13,7 @@ export declare class HMRouterPluginHandle {
     private isEnableObfuscation;
     private copyRouterMapToRawFileTask;
     private writeHspModuleName;
+    private getRemoteHspModuleNames;
     private taskExec;
     private updateModuleJsonOpt;
     private updateBuildProfileOpt;