@hadss/hmrouter-plugin 1.0.0-rc.5 → 1.0.0-rc.6

package/.mocharc.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+module.exports = {
+  extension: ['ts'],
+  require: 'ts-node/register',
+  spec: process.env.TEST_ENV === 'unit' ? 'tests/**/Unit.test.ts' : 'tests/**/*.test.ts',
+  recursive: true
+}

package/README.md

@@ -4,7 +4,7 @@
 ```json5
 {
   "dependencies": {
-    "@hadss/hmrouter-plugin": "^1.0.0-rc.4" // 使用npm仓版本号
+    "@hadss/hmrouter-plugin": "^1.0.0-rc.6" // 使用npm仓版本号
   },
   // ...其他配置
 }
@@ -28,13 +28,24 @@ export default {
 {
   // 如果不配置则扫描src/main/ets目录，对代码进行全量扫描，如果配置则数组不能为空，建议配置指定目录可缩短编译耗时
   "scanDir": ["src/main/ets/components","src/main/ets/interceptors"],
-  "saveGeneratedFile": false, // 默认为false，调试排除错误时可以改成true，不删除编译产物
+  "saveGeneratedFile": false, // 默认为false，调试排除错误时可以改成true，不删除编译产物,
+  "autoObfuscation": true // 默认为false，不自动配置混淆规则，只会生成hmrouter_obfuscation_rules.txt文件帮助开发者配置混淆规则；如果设置为true，会自动配置混淆规则，并在编译完成后删除hmrouter_obfuscation_rules.txt文件
 }
 ```
 
+### hmrouter_config.json配置
+
+`hmrouter_config.json`文件用于配置编译插件`@hadss/hmrouter-plugin`在编译期的行为
+
 > 配置文件读取规则为 模块 > 工程 > 默认
 > 优先使用本模块内的配置，如果没有配置，则找模块目录的上级目录(最多找三层目录，找到则停止)，若找不到则使用默认配置
 
+| 配置项               | 类型      | 是否必填 | 说明                                                                                                                                   |
+|-------------------|---------|------|--------------------------------------------------------------------------------------------------------------------------------------|
+| scanDir           | array   | 否    | 扫描当前模块使用HMRouter装饰器的路径，缺省值为`"src/main/ets"`                                                                                          |
+| saveGeneratedFile | boolean | 否    | 默认为false，不保留插件自动生成的代码，如果需要保留，需要设置为true                                                                                               |
+| autoObfuscation   | boolean | 否    | 默认为false，不自动配置混淆规则，只会生成`hmrouter_obfuscation_rules.txt`文件帮助开发者配置混淆规则；如果设置为true，会自动配置混淆规则，并在编译完成后删除`hmrouter_obfuscation_rules.txt`文件 |
+
 ## HMRouter使用
 
 详见[@hadss/hmrouter](https://ohpm.openharmony.cn/#/cn/detail/@hadss%2Fhmrouter)

package/dist/HMRouterAnalyzer.d.ts

@@ -1,40 +1,8 @@
 import { HMRouterPluginConfig } from './HMRouterPluginConfig';
 import { AnalyzerResultLike } from './common/PluginModel';
-export declare class Analyzer {
-    analyzeResultSet: Set<AnalyzerResultLike>;
-    private readonly sourcePath;
-    private readonly pluginConfig;
+export declare class AnalyzerController {
     private analyzeResult;
-    private classMethodAnalyzeResult;
-    private keywordPos;
-    private importMap;
-    constructor(sourcePath: string, pluginConfig: HMRouterPluginConfig);
-    start(): void;
-    private resolveNode;
-    private resolveImportDeclaration;
-    private resolveMissingDeclaration;
-    private isDecoratedClass;
-    private resolveClass;
-    private resolveClassMethod;
-    private resolveDecorator;
-    private switchIdentifier;
-    private resolveCallExpression;
-    private resolveExpression;
-    private resolveBlock;
-    private parseAnnotation;
-    private parseConfig;
-    private resolvePropertyAccess;
-    private resolveIdentifier;
-    private resolveArrayLiteral;
-    private resolveNumericLiteral;
-    private resolveStringLiteral;
-    private resolveTrueKeyword;
-    private resolveFalseKeyword;
-    private getSourceFile;
-    private findConstantValueInSourceFile;
-    private findObjectValueInSourceFile;
-    private resolveConstantValue;
-    private resolveObjectValue;
-    private resolvePath;
-    private parseVariableDeclaration;
+    analyzeFile(sourceFilePath: string, config: HMRouterPluginConfig): void;
+    parsePageUrl(): void;
+    getAnalyzeResultSet(): Set<AnalyzerResultLike>;
 }

package/dist/HMRouterAnalyzer.js

@@ -3,334 +3,242 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Analyzer = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const hvigor_1 = require("@ohos/hvigor");
+exports.AnalyzerController = void 0;
+const ts_morph_1 = require("ts-morph");
 const Logger_1 = require("./common/Logger");
-const Constant_1 = require("./common/Constant");
-class NodeInfo {
-}
-class Analyzer {
-    constructor(sourcePath, pluginConfig) {
-        this.analyzeResultSet = new Set();
-        this.analyzeResult = {};
-        this.classMethodAnalyzeResult = new Set();
-        this.keywordPos = 0;
-        this.importMap = new Map();
-        this.sourcePath = sourcePath;
-        this.pluginConfig = pluginConfig;
+const TsAstUtil_1 = require("./utils/TsAstUtil");
+const CommonConstants_1 = __importDefault(require("./constants/CommonConstants"));
+const FileUtil_1 = __importDefault(require("./utils/FileUtil"));
+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.parsePageUrl();
     }
-    start() {
-        const sourceCode = hvigor_1.FileUtil.readFileSync(this.sourcePath).toString();
-        const sourceFile = typescript_1.default.createSourceFile(this.sourcePath, sourceCode, typescript_1.default.ScriptTarget.ES2021, false);
-        typescript_1.default.forEachChild(sourceFile, node => {
-            this.resolveNode(node);
-            if (this.analyzeResult.annotation) {
-                this.analyzeResultSet.add(this.analyzeResult);
+    parsePageUrl() {
+        this.analyzeResult.forEach((item) => {
+            if (item.annotation !== 'HMRouter') {
+                return;
             }
-            if (this.classMethodAnalyzeResult.size > 0) {
-                this.analyzeResultSet = new Set([...this.analyzeResultSet, ...this.classMethodAnalyzeResult]);
+            let pageUrl = item.pageUrl;
+            if (pageUrl.type === 'constant') {
+                pageUrl =
+                    TsAstUtil_1.TsAstUtil.parseConstantValue(TsAstUtil_1.project.addSourceFileAtPath(pageUrl.variableFilePath), pageUrl.variableName);
             }
-        });
-        this.analyzeResultSet.forEach(value => {
-            if (value.annotation === 'HMRouter') {
-                let hmRouterResult = value;
-                if (hmRouterResult.pageUrl.type === 'constant') {
-                    hmRouterResult.pageUrl = this.resolveConstantValue(hmRouterResult.pageUrl.value);
-                }
-                else if (hmRouterResult.pageUrl.type === 'object') {
-                    hmRouterResult.pageUrl =
-                        this.resolveObjectValue(hmRouterResult.pageUrl.className, hmRouterResult.pageUrl.propertyName);
-                }
+            else if (pageUrl.type === 'object') {
+                pageUrl = TsAstUtil_1.TsAstUtil.parseConstantValue(TsAstUtil_1.project.addSourceFileAtPath(pageUrl.variableFilePath), pageUrl.variableName, pageUrl.propertyName);
             }
-        });
-    }
-    resolveNode(node) {
-        if (typescript_1.default.isImportDeclaration(node)) {
-            this.resolveImportDeclaration(node);
-        }
-        else if (typescript_1.default.isMissingDeclaration(node)) {
-            this.resolveMissingDeclaration(node);
-        }
-        else if (typescript_1.default.isClassDeclaration(node)) {
-            this.isDecoratedClass(node) ? this.resolveClass(node) : this.resolveClassMethod(node);
-        }
-        else if (typescript_1.default.isDecorator(node)) {
-            this.resolveDecorator(node);
-        }
-        else if (typescript_1.default.isCallExpression(node)) {
-            this.resolveCallExpression(node);
-        }
-        else if (typescript_1.default.isExpressionStatement(node)) {
-            this.resolveExpression(node);
-        }
-        else if (typescript_1.default.isBlock(node)) {
-            this.resolveBlock(node);
-        }
-        else if (typescript_1.default.isPropertyAssignment(node)) {
-            return this.resolvePropertyAccess(node);
-        }
-        else if (typescript_1.default.isIdentifier(node)) {
-            return this.resolveIdentifier(node);
-        }
-        else if (typescript_1.default.isStringLiteral(node)) {
-            return this.resolveStringLiteral(node);
-        }
-        else if (typescript_1.default.isNumericLiteral(node)) {
-            return this.resolveNumericLiteral(node);
-        }
-        else if (typescript_1.default.isArrayLiteralExpression(node)) {
-            return this.resolveArrayLiteral(node);
-        }
-        else if (node.kind === typescript_1.default.SyntaxKind.TrueKeyword) {
-            return this.resolveTrueKeyword();
-        }
-        else if (node.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
-            return this.resolveFalseKeyword();
-        }
-    }
-    resolveImportDeclaration(node) {
-        let variableArr = [];
-        node.importClause?.namedBindings?.forEachChild(child => {
-            if (typescript_1.default.isImportSpecifier(child)) {
-                variableArr.push(child.name.escapedText);
+            if (pageUrl === '') {
+                Logger_1.Logger.error(Logger_1.PluginError.ERR_NOT_EMPTY_STRING);
+                throw new Error('constant value cannot be an empty string');
             }
+            item.pageUrl = pageUrl;
         });
-        variableArr.push(node.importClause?.name?.text);
-        let key = node.moduleSpecifier;
-        if (typescript_1.default.isModuleName(key)) {
-            this.importMap.set(key.text, variableArr);
-        }
     }
-    resolveMissingDeclaration(node) {
-        this.analyzeResult = {};
-        node.forEachChild(child => this.resolveNode(child));
+    getAnalyzeResultSet() {
+        return this.analyzeResult;
     }
-    isDecoratedClass(node) {
-        return node.modifiers?.some((item) => Constant_1.HMRouterPluginConstant.CLASS_ANNOTATION_ARR.includes(item.expression?.expression?.text));
+}
+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;
     }
-    resolveClass(node) {
-        this.analyzeResult = {};
-        node.modifiers?.forEach(modifier => {
-            this.resolveNode(modifier);
+    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 (this.analyzeResult.annotation) {
-            this.analyzeResult.name = node.name?.text;
-        }
-    }
-    resolveClassMethod(node) {
-        this.classMethodAnalyzeResult = new Set([]);
-        node.members?.forEach((member) => {
-            this.analyzeResult = {};
-            if (typescript_1.default.isMethodDeclaration(member) && member.modifiers) {
-                member.modifiers?.forEach((modifier) => {
-                    this.resolveNode(modifier);
+        if (HMRouterNum > 1) {
+            Logger_1.Logger.error(Logger_1.PluginError.ERR_REPEAT_ANNOTATION, this.sourceFilePath);
+            throw new Error(`文件${this.sourceFilePath}中存在多个HMRouter注解`);
+        }
+        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) {
+                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.analyzeResult.functionName = member.name?.text;
-                this.analyzeResult.name = node.name?.text;
-                if (this.analyzeResult.annotation) {
-                    this.classMethodAnalyzeResult.add(this.analyzeResult);
-                }
-                this.analyzeResult = {};
+                this.importMap.set(moduleSpecifier, importNames);
             }
         });
     }
-    resolveDecorator(node) {
-        if (typescript_1.default.isCallExpression(node.expression)) {
-            const callExpression = node.expression;
-            if (typescript_1.default.isIdentifier(callExpression.expression)) {
-                this.switchIdentifier(callExpression);
-            }
-        }
-    }
-    switchIdentifier(callExpression) {
-        const identifier = callExpression.expression;
-        if (this.pluginConfig.annotation.some(item => item === identifier.text)) {
-            this.analyzeResult.annotation = identifier.text;
-            this.resolveNode(callExpression);
-        }
-    }
-    resolveCallExpression(node) {
-        let identifier = this.resolveNode(node.expression);
-        this.parseAnnotation(node.arguments, identifier);
-    }
-    resolveExpression(node) {
-        let identifier = this.resolveNode(node.expression);
-        if (identifier?.value === 'struct') {
-            this.keywordPos = node.end;
-        }
-        if (this.analyzeResult.annotation === 'HMRouter' && this.keywordPos === node.pos) {
-            this.analyzeResult.name = identifier?.value;
-        }
-    }
-    resolveBlock(node) {
-        node.statements.forEach(statement => {
-            this.resolveNode(statement);
+    analyzeRouter() {
+        let viewNameArr = this.sourceFile.getChildrenOfKind(ts_morph_1.SyntaxKind.ExpressionStatement).map((node) => {
+            return node.getText();
+        }).filter((text) => {
+            return text != 'struct';
         });
-    }
-    parseAnnotation(args, nodeInfo) {
-        if (this.pluginConfig.annotation.some(item => nodeInfo?.value === item)) {
-            args
-                .flatMap((e) => e.properties)
-                .forEach((e) => {
-                this.parseConfig(e, this.analyzeResult);
+        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]);
             });
-        }
-    }
-    parseConfig(node, result) {
-        let info = this.resolveNode(node);
-        Reflect.set(result, info?.value['key'], info?.value['value']);
+        });
     }
-    resolvePropertyAccess(node) {
-        let propertyName = this.resolveNode(node.name)?.value;
-        let propertyValue;
-        if (propertyName === 'pageUrl') {
-            if (node.initializer.kind === typescript_1.default.SyntaxKind.Identifier) {
-                propertyValue = {
-                    type: 'constant',
-                    value: this.resolveNode(node.initializer)?.value
-                };
+    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;
             }
-            else if (node.initializer.kind === typescript_1.default.SyntaxKind.PropertyAccessExpression) {
-                propertyValue = {
-                    type: 'object',
-                    className: this.resolveNode(node.initializer.expression)?.value,
-                    propertyName: this.resolveNode(node.initializer.name)?.value
-                };
-            }
-            else {
-                propertyValue = this.resolveNode(node.initializer)?.value;
+            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);
+                    }
+                });
             }
-        }
-        else {
-            propertyValue = this.resolveNode(node.initializer)?.value;
-        }
-        let info = new NodeInfo();
-        info.value = { key: propertyName, value: propertyValue };
-        return info;
-    }
-    resolveIdentifier(node) {
-        if (node.escapedText === 'NavDestination' && this.analyzeResult.annotation === 'HMRouter') {
-            Logger_1.Logger.error(Logger_1.PluginError.ERR_WRONG_DECORATION);
-            throw new Error('NavDestination is not allowed in HMRouter' + this.sourcePath);
-        }
-        let info = new NodeInfo();
-        info.value = node.escapedText.toString();
-        return info;
-    }
-    resolveArrayLiteral(node) {
-        let arrValue = node.elements.map(e => this.resolveNode(e)?.value);
-        let info = new NodeInfo();
-        info.value = arrValue;
-        return info;
-    }
-    resolveNumericLiteral(node) {
-        let info = new NodeInfo();
-        info.value = Number(node.text);
-        return info;
-    }
-    resolveStringLiteral(node) {
-        let info = new NodeInfo();
-        info.value = node.text;
-        return info;
-    }
-    resolveTrueKeyword() {
-        let info = new NodeInfo();
-        info.value = true;
-        return info;
-    }
-    resolveFalseKeyword() {
-        let info = new NodeInfo();
-        info.value = false;
-        return info;
-    }
-    getSourceFile(filePath) {
-        if (!hvigor_1.FileUtil.exist(filePath)) {
-            return null;
-        }
-        const sourceCode = hvigor_1.FileUtil.readFileSync(filePath).toString();
-        return typescript_1.default.createSourceFile(filePath, sourceCode, typescript_1.default.ScriptTarget.ES2021, false);
+        });
     }
-    findConstantValueInSourceFile(sourceFile, constantName) {
-        let nodeInfo = new NodeInfo();
-        typescript_1.default.forEachChild(sourceFile, node => {
-            if (!typescript_1.default.isVariableStatement(node)) {
-                return;
-            }
-            node.declarationList.declarations.forEach(declaration => {
-                let info = this.parseVariableDeclaration(declaration);
-                if (constantName === info?.value['key']) {
-                    nodeInfo = info;
+    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();
+                });
+            });
         });
-        return nodeInfo;
     }
-    findObjectValueInSourceFile(sourceFile, className, propertyName) {
-        let info = new NodeInfo();
-        typescript_1.default.forEachChild(sourceFile, node => {
-            if (!typescript_1.default.isClassDeclaration(node) || node.name?.escapedText.toString() !== className) {
-                return;
+    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 = propertyName === CommonConstants_1.default.PAGE_URL ?
+                        this.parsePageUrlValue(prop.getInitializer()) :
+                        this.parsePropertyValue(prop.getInitializer());
+                    Reflect.set(argResult, propertyName, propertyValue);
+                });
             }
-            node.members.forEach(member => {
-                if (member.name?.escapedText.toString() === propertyName) {
-                    info = this.parseVariableDeclaration(member);
-                }
-            });
         });
-        return info;
-    }
-    resolveConstantValue(constantName) {
-        const sourceFile = this.getSourceFile(this.resolvePath(constantName));
-        if (!sourceFile) {
-            return null;
-        }
-        const constantValueStr = this.findConstantValueInSourceFile(sourceFile, constantName).value['value'];
-        if (!constantValueStr) {
-            Logger_1.Logger.error(Logger_1.PluginError.ERR_NOT_EMPTY_STRING, constantName);
-            throw new Error('constant value cannot be an empty string');
-        }
-        return constantValueStr;
+        return argResult;
     }
-    resolveObjectValue(className, propertyName) {
-        const sourceFile = this.getSourceFile(this.resolvePath(className));
-        if (!sourceFile) {
-            return null;
-        }
-        const objectValueStr = this.findObjectValueInSourceFile(sourceFile, className, propertyName).value['value'];
-        if (!objectValueStr) {
-            Logger_1.Logger.error(Logger_1.PluginError.ERR_NOT_EMPTY_STRING, propertyName);
-            throw new Error('constant value cannot be an empty string');
+    parsePageUrlValue(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())
+                };
+            default:
+                return this.parsePropertyValue(value);
         }
-        return objectValueStr;
     }
-    resolvePath(variableName) {
-        let filePath = '';
-        this.importMap.forEach((value, key) => {
-            if (value.includes(variableName)) {
-                filePath = key;
-            }
+    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.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 classesNames = this.sourceFile.getClasses().map((classes) => {
+            return classes.getName();
         });
-        if (filePath) {
-            filePath =
-                hvigor_1.FileUtil.pathResolve(this.sourcePath.split(Constant_1.HMRouterPluginConstant.FILE_SEPARATOR).slice(0, -1)
-                    .join(Constant_1.HMRouterPluginConstant.FILE_SEPARATOR), filePath) + Constant_1.HMRouterPluginConstant.VIEW_NAME_SUFFIX;
+        let variableNames = this.sourceFile.getVariableDeclarations().map((variableDeclaration) => {
+            return variableDeclaration.getName();
+        });
+        if (classesNames.includes(variableName) || variableNames.includes(variableName)) {
+            return this.sourceFilePath;
         }
         else {
-            filePath = this.sourcePath;
-        }
-        return filePath;
-    }
-    parseVariableDeclaration(node) {
-        let variableName = this.resolveNode(node.name)?.value;
-        let variableValue = this.resolveNode(node.initializer)?.value;
-        if (typeof variableValue !== 'string') {
-            Logger_1.Logger.error(Logger_1.PluginError.ERR_INVALID_STRING_VALUE, variableName);
-            throw new Error('Invalid constant value');
+            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;
+                }
+            });
+            return filePath;
         }
-        let info = new NodeInfo();
-        info.value = { key: variableName, value: variableValue };
-        return info;
     }
 }
-exports.Analyzer = Analyzer;

package/dist/HMRouterHvigorPlugin.d.ts

@@ -4,12 +4,12 @@ export declare class HMRouterHvigorPlugin {
     config: HMRouterPluginConfig;
     routerMap: RouterInfo[];
     private scanFiles;
-    private HMRouterNum;
+    private analyzerController;
     constructor(config: HMRouterPluginConfig);
     analyzeAnnotation(): void;
+    generateRouterMap(): void;
     private pushRouterInfo;
     private generateBuilder;
-    generateRouterMap(): void;
     private deepScan;
     private stringToHashCode;
 }