@hadss/hmrouter-plugin 1.0.0-rc.1 → 1.0.0-rc.10

package/README.md

@@ -1,37 +1,260 @@
 ## 编译插件配置
 
-1. 修改项目的`hvigor/hvigor-config.json`文件，加入路由编译插件
+1.修改项目的`hvigor/hvigor-config.json`文件，加入路由编译插件
+
 ```json5
 {
   "dependencies": {
-    "@hadss/hmrouter-plugin": "^1.0.0-rc.0" // 使用npm仓版本号
+    "@hadss/hmrouter-plugin": "^1.0.0-rc.10" // 使用npm仓版本号
   },
   // ...其他配置
 }
 ```
 
-2. 项目根目录或者模块目录创建路由编译插件配置文件`hmrouter_config.json`（推荐）
+2.在模块中引入路由编译插件，修改`hvigorfile.ts`
+
+```typescript
+import { hapTasks } from "@ohos/hvigor-ohos-plugin";
+import { hapPlugin } from "@hadss/hmrouter-plugin";
+
+export default {
+    system: hapTasks,
+    plugins: [hapPlugin()], // 使用HMRouter框架中标签的模块均需要配置，与模块类型保持一致
+};
+```
+
+> 请使用与模块类型一致的插件方法，如果模块是 Har 则使用`harPlugin()`, 模块是 Hsp 则使用`hspPlugin()`
+
+3.项目根目录或者模块目录创建路由编译插件配置文件`hmrouter_config.json`（推荐）
+
 ```json5
 {
-  "scanDir": ["src/main/ets/components","src/main/ets/interceptors"],
-  // 如果不传则扫描src/main/ets目录，对代码进行全量扫描，建议配置可缩短编译耗时
-  "saveGeneratedFile": false, // 默认为false，改成true则不删除编译产物
+  // 如果不配置则扫描src/main/ets目录，对代码进行全量扫描，如果配置则数组不能为空，建议配置指定目录可缩短编译耗时
+  "scanDir": [
+    "src/main/ets/components",
+    "src/main/ets/interceptors"
+  ],
+  // 默认为false，调试排除错误时可以改成true，不删除编译产物
+  "saveGeneratedFile": false,
+  // 默认为false，不自动配置混淆规则，只会生成hmrouter_obfuscation_rules.txt文件帮助开发者配置混淆文件；如果设置为true，会自动配置混淆规则，并删除hmrouter_obfuscation_rules.txt文件
+  "autoObfuscation": false,
+  // 默认模板文件，不配置时使用插件内置模板
+  "defaultPageTemplate": "./templates/defaultTemplate.ejs",
+  // 特殊页面模版文件，匹配原则支持文件通配符
+  "customPageTemplate": [
+    {
+      "srcPath": ["**/component/Home/**/*.ets"],
+      "templatePath": "./templates/home_shopping_template.ejs"
+    },
+    {
+      "srcPath": ["**/common/**/*.ets"],
+      "templatePath": "./templates/common_template.ejs"
+    },
+    {
+      "srcPath": ["**/live/**/*.ets"],
+      "templatePath": "./templates/live_template.ejs"
+    }
+  ]
 }
 ```
 
-3. 在模块中引入路由编译插件，修改`hvigorfile.ts`
-```typescript
-import { hapTasks } from '@ohos/hvigor-ohos-plugin';
-import { hapPlugin } from "@hadss/hmrouter-plugin";
+### hmrouter_config.json 配置
 
-export default {
-  system: hapTasks,
-  plugins: [hapPlugin()]
+`hmrouter_config.json`文件用于配置该插件在编译期的行为
+
+> 配置文件读取规则为 模块 > 工程 > 默认
+> 
+> 优先使用本模块内的配置，如果没有配置，则找模块目录的上级目录(最多找三层目录，找到则停止)，若找不到则使用默认配置
+
+> 1.0.0-rc.6 版本开始，支持混淆配置`autoObfuscation`
+> 
+> 1.0.0-rc.9 版本开始，支持自定义模版配置`customPageTemplate`
+
+| 配置项                 | 类型      | 是否必填 | 说明                                                                                                                                     |
+|---------------------|---------|------|----------------------------------------------------------------------------------------------------------------------------------------|
+| scanDir             | array   | 否    | 指定扫描当前模块路径，默认值为`src/main/ets`                                                                                                          |
+| saveGeneratedFile   | boolean | 否    | 默认为 false，不保留插件自动生成的代码，如果需要保留，需要设置为 true                                                                                               |
+| autoObfuscation     | boolean | 否    | 默认为 false，不自动配置混淆规则，只会生成`hmrouter_obfuscation_rules.txt`文件帮助开发者配置混淆规则；如果设置为 true，会自动配置混淆规则，并在编译完成后删除`hmrouter_obfuscation_rules.txt`文件 |
+| defaultPageTemplate | string  | 否    | 默认模版路径，相对于hmrouter_config.json文件，例如：`./templates/defaultTemplate.ejs`                                                                  |
+| customPageTemplate  | object  | 否    | srcPath为匹配的代码文件路径，支持通配符，templatePath为模版路径，可以实现不同的代码使用不同的模版来生成                                                                          |
+
+## 自定义模板使用
+
+在 `HMRouterPlugin` 中，EJS模板用于生成动态页面或组件，你可以在模板文件中使用 EJS 的语法
+
+> EJS语法可阅读参考[官网链接](https://github.com/mde/ejs)
+
+**模板文件示例：**
+
+```ejs
+import { <%= componentName %> } from '<%= importPath %>'
+
+@Builder
+export function <%= componentName %>Builder(name: string, param: Object) {
+  <%= componentName %>Generated()
+}
+
+@Component
+export struct <%= componentName %>Generated {
+  private pageUrl: string = '<%= pageUrl %>'
+
+  build() {
+    NavDestination() {
+      <%= componentName %>()
+    }
+    <% if(dialog){ %>.mode(NavDestinationMode.DIALOG)<% } %>
+    .hideTitleBar(true)
+  }
 }
 ```
 
-> 如果是Har则使用`harPlugin()`, Hsp则使用`hspPlugin()`
- 
-## HMRouter使用
+> 模板文件中至少需要包含`NavDestination`组件代码和相对应的`build`函数，缺少会导致编译失败或者页面白屏，插件中会内置一套默认模板，其中包含了**页面展示、生命周期注册、转场动画注册**
+
+### 默认模板介绍
+
+插件默认会根据如下模板来生成`NavDestination`页面代码，如有自定义模板的需求，建议先阅读内置模板的介绍在做更改，书写自定义模板时建议在内置模板基础上添加代码，删除内置模板相关代码可能会导致**编译失败、生命周期生效、转场动画失效等问题**。
+
+**默认模版`viewBuilder.ejs`：**
+
+```ejs
+import { <%= componentName %> } from '<%= importPath %>'
+import { TemplateService, TranslateOption, ScaleOption, OpacityOption } from '@hadss/hmrouter'
+
+@Builder
+export function <%= componentName %>Builder(name: string, param: Object) {
+  <%= componentName %>Generated()
+}
+
+@Component
+export struct <%= componentName %>Generated {
+  @State translateOption: TranslateOption = new TranslateOption()
+  @State scaleOption: ScaleOption = new ScaleOption()
+  @State opacityOption: OpacityOption = new OpacityOption()
+  private pageUrl: string = '<%= pageUrl %>'
+  private ndId: string = ''
+  private navigationId: string = ''
+
+  aboutToAppear(): void {
+    this.navigationId = this.queryNavigationInfo()!.navigationId;
+    TemplateService.aboutToAppear(this.navigationId, this.pageUrl, <%= dialog %>,
+      this.translateOption, this.scaleOption, this.opacityOption)
+  }
+
+  aboutToDisappear(): void {
+    TemplateService.aboutToDisappear(this.navigationId, this.pageUrl, this.ndId)
+  }
+
+  build() {
+    NavDestination() {
+      <%= componentName %>()
+    }
+    <% if(dialog){ %>.mode(NavDestinationMode.DIALOG)<% } %>
+    .hideTitleBar(true)
+    .gesture(PanGesture()
+      .onActionStart((event: GestureEvent) => {
+        TemplateService.interactiveStart(this.navigationId, this.ndId, event)
+      })
+      .onActionUpdate((event: GestureEvent) =>{
+        TemplateService.interactiveProgress(this.navigationId, this.ndId, event)
+      })
+      .onActionEnd((event: GestureEvent) =>{
+        TemplateService.interactiveFinish(this.navigationId, this.ndId, event)
+      })
+    )
+    .translate(this.translateOption)
+    .scale(this.scaleOption)
+    .opacity(this.opacityOption.opacity)
+    .onAppear(() => {
+      TemplateService.onAppear(this.navigationId, this.pageUrl, this.ndId)
+    })
+    .onDisAppear(() => {
+      TemplateService.onDisAppear(this.navigationId, this.pageUrl, this.ndId)
+    })
+    .onShown(() => {
+      TemplateService.onShown(this.navigationId, this.pageUrl, this.ndId)
+    })
+    .onHidden(() => {
+      TemplateService.onHidden(this.navigationId, this.pageUrl, this.ndId)
+    })
+    .onWillAppear(() => {
+      TemplateService.onWillAppear(this.navigationId, this.pageUrl)
+    })
+    .onWillDisappear(() => {
+      TemplateService.onWillDisappear(this.navigationId, this.pageUrl, this.ndId)
+    })
+    .onWillShow(() => {
+      TemplateService.onWillShow(this.navigationId, this.pageUrl, this.ndId)
+    })
+    .onWillHide(() => {
+      TemplateService.onWillHide(this.navigationId, this.pageUrl, this.ndId)
+    })
+    .onReady((navContext: NavDestinationContext) => {
+      this.ndId = navContext.navDestinationId!
+      TemplateService.onReady(this.navigationId, this.pageUrl, navContext)
+    })
+    .onBackPressed(() => {
+      return TemplateService.onBackPressed(this.navigationId, this.pageUrl, this.ndId)
+    })
+  }
+}
+```
+
+### 模板变量
+
+| 属性                | 描述              |
+|-------------------|-----------------|
+| pageUrl           | 标签中配置的pageUrl的值 |
+| importPath        | 原组件的导入路径        |
+| componentName     | 原组件名            |
+| dialog            | 是否dialog页面      |
+| generatorViewName | 生成的文件名          |
+
+### TemplateService内置模版方法
+
+该类中封装了一系列在模板中需要用到的注册、初始化、事件回调接口
+
+| 接口                         | 参数                                                                                                                                                  | 返回值  | 接口描述                  |
+|----------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|------|-----------------------|
+| static aboutToAppear       | navigationId: string,pageUrl: string, dialog: boolean, translateOption: TranslateOption,   scaleOption: ScaleOption,   opacityOption: OpacityOption | void | 注册接口，用于模板代码中注册动画与生命周期 |
+| static aboutToDisappear    | navigationId: string, pageUrl: string, ndId: string                                                                                                 | void | 销毁，用户销毁一个页面的动画与生命周期实例 |
+| static onDisAppear         | navigationId: string, pageUrl: string, navId: string                                                                                                | void | NavDestination生命周期    |
+| static onAppear            | navigationId: string, pageUrl: string, navId: string                                                                                                | void | NavDestination生命周期    |
+| static onShown             | navigationId: string, pageUrl: string, navId: string                                                                                                | void | NavDestination生命周期    |
+| static onHidden            | navigationId: string, pageUrl: string, navId: string                                                                                                | void | NavDestination生命周期    |
+| static onWillAppear        | navigationId: string, pageUrl: string                                                                                                               | void | NavDestination生命周期    |
+| static onWillDisappear     | navigationId: string, pageUrl: string, navId: string                                                                                                | void | NavDestination生命周期    |
+| static onWillShow          | navigationId: string, pageUrl: string, navId: string                                                                                                | void | NavDestination生命周期    |
+| static onWillHide          | navigationId: string, pageUrl: string, navId: string                                                                                                | void | NavDestination生命周期    |
+| static onReady             | navigationId: string, pageUrl: string, navContext: NavDestinationContext                                                                            | void | NavDestination生命周期    |
+| static onBackPressed       | navigationId: string, pageUrl: string, navId: string                                                                                                | void | NavDestination生命周期    |
+| static interactiveStart    | navigationId: string, ndId: string, event: GestureEvent                                                                                             | void | 手势转场动画触发              |
+| static interactiveFinish   | navigationId: string, ndId: string, event: GestureEvent                                                                                             | void | 手势转场动画更新              |
+| static interactiveProgress | navigationId: string, ndId: string, event: GestureEvent                                                                                             | void | 手势转场动画结束              |
+
+## 依赖系统版本
+
+最低版本
+
+```text
+HarmonyOS NEXT Developer Beta5版本及以上
+DevEco Studio 5.0.3.700及以上
+hvigor 5.5.1及以上
+```
+
+**推荐使用**
+
+```text
+HarmonyOS NEXT Beta1版本及以上
+DevEco Studio 5.0.3.800及以上
+hvigor 5.7.3及以上
+```
+
+> 低于DevEco Studio 5.0.3.800(hvigor 5.7.3)可能会导致远程的 HSP 中定义的 HMRouter 标签与路由表失效，会有如下 WARN 日志
+>
+> ```
+> [HMRouterPlugin] Your DevEco Studio version less than 5.0.3.800, may cause remote hsp dependencies get failed
+> ```
+
+## HMRouter路由框架使用
 
-详见[@hadss/hmrouter](https://ohpm.openharmony.cn/#/cn/detail/@hadss%2Fhmrouter)
+详见[@hadss/hmrouter](https://ohpm.openharmony.cn/#/cn/detail/@hadss%2Fhmrouter)

package/dist/HMRouterAnalyzer.d.ts

@@ -0,0 +1,31 @@
+import { AnalyzerResultLike } from './common/PluginModel';
+import { HMRouterPluginConfig } from './HMRouterPluginConfig';
+export declare class AnalyzerController {
+    private analyzeResult;
+    analyzeFile(sourceFilePath: string, config: HMRouterPluginConfig): void;
+    parseConstants(): void;
+    private parsePropertyValue;
+    getAnalyzeResultSet(): Set<AnalyzerResultLike>;
+    clearAnalyzeResultSet(): void;
+}
+export declare class AnalyzerService {
+    private readonly sourceFilePath;
+    private sourceFile;
+    private config;
+    private analyzerResultSet;
+    private importMap;
+    constructor(sourceFilePath: string, config: HMRouterPluginConfig);
+    start(): void;
+    getResult(): Set<AnalyzerResultLike>;
+    private analyzeImport;
+    private analyzeRouter;
+    private parseFileByLineOrder;
+    private analyzeComponent;
+    private addToResultSet;
+    private parseDecorator;
+    private parseDecoratorArguments;
+    private parseIdentifierPropertyValue;
+    private parsePropertyValue;
+    private getVariableFilePath;
+    private getOtherModuleVariableFilePath;
+}

package/dist/HMRouterAnalyzer.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzerService = exports.AnalyzerController = void 0;
+const ts_morph_1 = require("ts-morph");
+const Logger_1 = require("./common/Logger");
+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();
+    }
+    analyzeFile(sourceFilePath, config) {
+        let analyzerService = new AnalyzerService(sourceFilePath, config);
+        analyzerService.start();
+        analyzerService.getResult().forEach(item => {
+            item.pageSourceFile = sourceFilePath;
+            this.analyzeResult.add(item);
+        });
+        this.parseConstants();
+    }
+    parseConstants() {
+        this.analyzeResult.forEach((item) => {
+            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') {
+            return TsAstUtil_1.TsAstUtil.parseConstantValue(TsAstUtil_1.TsAstUtil.getSourceFile(propertyValue.variableFilePath), propertyValue.variableName);
+        }
+        else if (propertyValue.type === 'object') {
+            return TsAstUtil_1.TsAstUtil.parseConstantValue(TsAstUtil_1.TsAstUtil.getSourceFile(propertyValue.variableFilePath), propertyValue.variableName, propertyValue.propertyName);
+        }
+        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 {
+    constructor(sourceFilePath, config) {
+        this.analyzerResultSet = new Set();
+        this.importMap = new Map();
+        this.sourceFilePath = sourceFilePath;
+        this.sourceFile = TsAstUtil_1.TsAstUtil.getSourceFile(sourceFilePath);
+        this.config = config;
+    }
+    start() {
+        this.analyzeImport();
+        this.analyzeRouter();
+        this.analyzeComponent();
+        this.parseFileByLineOrder();
+    }
+    getResult() {
+        let HMRouterNum = 0;
+        this.analyzerResultSet.forEach((analyzerResult) => {
+            if (analyzerResult.annotation === CommonConstants_1.default.ROUTER_ANNOTATION) {
+                HMRouterNum++;
+            }
+        });
+        if (HMRouterNum > 1) {
+            Logger_1.Logger.error(Logger_1.PluginError.ERR_REPEAT_ANNOTATION, this.sourceFilePath);
+            throw new Error(`File:${this.sourceFilePath} exists more than one @HMRouter annotation`);
+        }
+        return this.analyzerResultSet;
+    }
+    analyzeImport() {
+        this.sourceFile.getImportDeclarations().forEach(importDeclaration => {
+            const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+            const namedImports = importDeclaration.getNamedImports().map(namedImport => namedImport.getName());
+            const defaultImport = importDeclaration.getDefaultImport()?.getText();
+            const namespaceImport = importDeclaration.getNamespaceImport()?.getText();
+            const importNames = [];
+            if (namedImports.length > 0) {
+                importNames.push(...namedImports);
+            }
+            if (defaultImport) {
+                importNames.push(defaultImport);
+            }
+            if (namespaceImport) {
+                importNames.push(namespaceImport);
+            }
+            if (importNames.length > 0) {
+                this.importMap.set(moduleSpecifier, importNames);
+            }
+        });
+    }
+    analyzeRouter() {
+        let viewNameArr = this.sourceFile.getChildrenOfKind(ts_morph_1.SyntaxKind.ExpressionStatement).map((node) => {
+            return node.getText();
+        }).filter((text) => {
+            return text != 'struct';
+        });
+        this.sourceFile.getChildrenOfKind(ts_morph_1.SyntaxKind.MissingDeclaration).forEach((node, index) => {
+            node.getChildrenOfKind(ts_morph_1.SyntaxKind.Decorator).forEach((decorator) => {
+                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 => {
+            if (statement.getKind() === ts_morph_1.SyntaxKind.MissingDeclaration && statement.getText().includes('HMRouter')) {
+                HMRouterExists = true;
+            }
+            if (statement.getKind() === ts_morph_1.SyntaxKind.Block && HMRouterExists) {
+                HMRouterExists = false;
+                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);
+                }
+            }
+        });
+    }
+    analyzeComponent() {
+        this.sourceFile.getClasses().forEach((cls) => {
+            cls.getDecorators().forEach((decorator) => {
+                if (this.config.annotation.includes(decorator.getName())) {
+                    this.addToResultSet(decorator, cls.getName());
+                }
+            });
+            cls.getMethods().forEach((method) => {
+                method.getDecorators().forEach((decorator) => {
+                    let serviceResult = this.addToResultSet(decorator, cls.getName());
+                    serviceResult.functionName = method.getName();
+                });
+            });
+        });
+    }
+    addToResultSet(decorator, componentName) {
+        let decoratorResult = this.parseDecorator(decorator);
+        decoratorResult.name = componentName;
+        if (decoratorResult.annotation) {
+            this.analyzerResultSet.add(decoratorResult);
+        }
+        return decoratorResult;
+    }
+    parseDecorator(decorator) {
+        let decoratorResult = {};
+        let decoratorName = decorator.getName();
+        if (this.config.annotation.includes(decoratorName)) {
+            decoratorResult.annotation = decoratorName;
+            let args = this.parseDecoratorArguments(decorator);
+            Object.assign(decoratorResult, args);
+        }
+        return decoratorResult;
+    }
+    parseDecoratorArguments(decorator) {
+        let argResult = {};
+        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 = this.parseIdentifierPropertyValue(prop.getInitializer());
+                    Reflect.set(argResult, propertyName, propertyValue);
+                });
+            }
+        });
+        return argResult;
+    }
+    parseIdentifierPropertyValue(value) {
+        switch (value.getKind()) {
+            case ts_morph_1.SyntaxKind.Identifier:
+                return {
+                    type: 'constant',
+                    variableName: 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())
+                };
+            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);
+        }
+    }
+    parsePropertyValue(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;
+            case ts_morph_1.SyntaxKind.FalseKeyword:
+                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());
+                break;
+        }
+        return propertyValue;
+    }
+    getVariableFilePath(variableName) {
+        let filePath = '';
+        let classesNames = this.sourceFile.getClasses().map((classes) => {
+            return classes.getName();
+        });
+        let variableNames = this.sourceFile.getVariableDeclarations().map((variableDeclaration) => {
+            return variableDeclaration.getName();
+        });
+        if (classesNames.includes(variableName) || variableNames.includes(variableName)) {
+            return this.sourceFilePath;
+        }
+        this.importMap.forEach((importNames, importPath) => {
+            if (importNames.includes(variableName)) {
+                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 {
+                    filePath = this.getOtherModuleVariableFilePath(importPath, 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.d.ts

@@ -0,0 +1,15 @@
+import { AnalyzerResultLike, HMRouterResult, RouterInfo } from './common/PluginModel';
+import { CustomPageTemplateImpl, HMRouterPluginConfig } from './HMRouterPluginConfig';
+export declare class HMRouterHvigorPlugin {
+    config: HMRouterPluginConfig;
+    routerMap: RouterInfo[];
+    scanFiles: string[];
+    private analyzerController;
+    constructor(config: HMRouterPluginConfig);
+    analyzeAnnotation(): void;
+    generateRouterMap(): void;
+    matchedPath(filePath: string, customPageTemplate: CustomPageTemplateImpl[], defaultTplFilePath: string): string;
+    pushRouterInfo(analyzeResult: AnalyzerResultLike): void;
+    generateBuilder(analyzeResult: HMRouterResult, pageSourceFile: string, tempFilePath: string): string;
+    deepScan(scanPath: string, filePath: string): void;
+}