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

package/dist/framework/extension/context/TemplateMetadataImpl.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateMetadataImpl = void 0;
+class TemplateMetadataImpl {
+    constructor() {
+        this.currentFilePath = '';
+        this.templateDataMap = new Map();
+    }
+    addTemplateData(componentName, data) {
+        if (this.templateDataMap.has(componentName)) {
+            const existing = this.templateDataMap.get(componentName) || {};
+            this.templateDataMap.set(componentName, { ...existing, ...data });
+        }
+        else {
+            this.templateDataMap.set(componentName, data);
+        }
+    }
+    getTemplateData(componentName) {
+        return this.templateDataMap.get(componentName);
+    }
+}
+exports.TemplateMetadataImpl = TemplateMetadataImpl;

package/dist/framework/extension/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ExtensionManager';
+export * from './PluginExtension';
+export * from './context/Interface';
+export * from './context/ExtensionContextImpl';

package/dist/framework/extension/index.js

@@ -0,0 +1,20 @@
+"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("./ExtensionManager"), exports);
+__exportStar(require("./PluginExtension"), exports);
+__exportStar(require("./context/Interface"), exports);
+__exportStar(require("./context/ExtensionContextImpl"), exports);

package/dist/framework/index.d.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './extension';
+export * from './utils';
+export * from './constants';

package/dist/framework/index.js

@@ -0,0 +1,20 @@
+"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("./core"), exports);
+__exportStar(require("./extension"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);

package/dist/framework/utils/FileUtil.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { FileUtil } from '@ohos/hvigor';
+import fs from 'fs';
+export declare class PluginFileUtil extends FileUtil {
+    static rmSync(path: fs.PathLike, options?: fs.RmOptions): void;
+    static unlinkSync(path: fs.PathLike): void;
+    static readdirSync(path: fs.PathLike, options?: {
+        encoding: BufferEncoding | null;
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }): string[];
+}

package/dist/framework/utils/FileUtil.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginFileUtil = void 0;
+const hvigor_1 = require("@ohos/hvigor");
+const fs_1 = __importDefault(require("fs"));
+class PluginFileUtil extends hvigor_1.FileUtil {
+    static rmSync(path, options) {
+        return fs_1.default.rmSync(path, options);
+    }
+    static unlinkSync(path) {
+        return fs_1.default.unlinkSync(path);
+    }
+    static readdirSync(path, options) {
+        return fs_1.default.readdirSync(path, options);
+    }
+}
+exports.PluginFileUtil = PluginFileUtil;

package/dist/framework/utils/Logger.d.ts

@@ -0,0 +1,12 @@
+export declare class Logger {
+    static error(module: string, msg: string, ...args: unknown[]): void;
+    static info(module: string, msg: string, ...args: unknown[]): void;
+    static warn(module: string, msg: string, ...args: unknown[]): void;
+    static debug(module: string, msg: string, ...args: unknown[]): void;
+    static withContext(module: string, operation: string): {
+        error: (msg: string, ...args: unknown[]) => void;
+        info: (msg: string, ...args: unknown[]) => void;
+        warn: (msg: string, ...args: unknown[]) => void;
+        debug: (msg: string, ...args: unknown[]) => void;
+    };
+}

package/dist/framework/utils/Logger.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const hvigor_1 = require("@ohos/hvigor");
+class Logger {
+    static error(module, msg, ...args) {
+        const prefix = `[HMRouterPlugin][${module}]:`;
+        hvigor_1.HvigorLogger.getLogger().error(`${prefix} ${msg}`, ...args);
+    }
+    static info(module, msg, ...args) {
+        const prefix = `[HMRouterPlugin][${module}]:`;
+        hvigor_1.HvigorLogger.getLogger().info(`${prefix} ${msg}`, ...args);
+    }
+    static warn(module, msg, ...args) {
+        const prefix = `[HMRouterPlugin][${module}]:`;
+        hvigor_1.HvigorLogger.getLogger().warn(`${prefix} ${msg}`, ...args);
+    }
+    static debug(module, msg, ...args) {
+        const prefix = `[HMRouterPlugin][${module}]:`;
+        hvigor_1.HvigorLogger.getLogger().debug(`${prefix} ${msg}`, ...args);
+    }
+    static withContext(module, operation) {
+        return {
+            error: (msg, ...args) => Logger.error(module, `${operation} - ${msg}`, ...args),
+            info: (msg, ...args) => Logger.info(module, `${operation} - ${msg}`, ...args),
+            warn: (msg, ...args) => Logger.warn(module, `${operation} - ${msg}`, ...args),
+            debug: (msg, ...args) => Logger.debug(module, `${operation} - ${msg}`, ...args),
+        };
+    }
+}
+exports.Logger = Logger;

package/dist/framework/utils/ModuleTypeUtil.d.ts

@@ -0,0 +1,4 @@
+import { HvigorNode } from '@ohos/hvigor';
+export declare function isHapModule(node: HvigorNode): boolean;
+export declare function isHarModule(node: HvigorNode): boolean;
+export declare function isHspModule(node: HvigorNode): boolean;

package/dist/framework/utils/ModuleTypeUtil.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHspModule = exports.isHarModule = exports.isHapModule = void 0;
+const hvigor_ohos_plugin_1 = require("@ohos/hvigor-ohos-plugin");
+function isHapModule(node) {
+    return node.getAllPluginIds().includes(hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAP_PLUGIN);
+}
+exports.isHapModule = isHapModule;
+function isHarModule(node) {
+    return node.getAllPluginIds().includes(hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAR_PLUGIN);
+}
+exports.isHarModule = isHarModule;
+function isHspModule(node) {
+    return node.getAllPluginIds().includes(hvigor_ohos_plugin_1.OhosPluginId.OHOS_HSP_PLUGIN);
+}
+exports.isHspModule = isHspModule;

package/dist/framework/utils/ObjectUtils.d.ts

@@ -0,0 +1,3 @@
+export declare class ObjectUtils {
+    static ensureNestedObject(obj: any, path: string[]): any;
+}

package/dist/framework/utils/ObjectUtils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectUtils = void 0;
+class ObjectUtils {
+    static ensureNestedObject(obj, path) {
+        return path.reduce((acc, key) => {
+            if (!acc[key]) {
+                acc[key] = {};
+            }
+            return acc[key];
+        }, obj);
+    }
+}
+exports.ObjectUtils = ObjectUtils;

package/dist/framework/utils/PluginStore.d.ts

@@ -0,0 +1,10 @@
+export declare class PluginStore {
+    private static instance;
+    private dataMap;
+    private constructor();
+    set(key: string, value: any): void;
+    get<T>(key: string): T | undefined;
+    private clear;
+    static destroy(): void;
+    static getInstance(): PluginStore;
+}

package/dist/framework/utils/PluginStore.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginStore = void 0;
+class PluginStore {
+    constructor() {
+        this.dataMap = new Map();
+    }
+    set(key, value) {
+        this.dataMap.set(key, value);
+    }
+    get(key) {
+        return this.dataMap.get(key);
+    }
+    clear() {
+        this.dataMap.clear();
+    }
+    static destroy() {
+        this.getInstance().clear();
+        this.instance = null;
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new PluginStore();
+        }
+        return this.instance;
+    }
+}
+exports.PluginStore = PluginStore;
+PluginStore.instance = null;

package/dist/framework/utils/StringUtil.d.ts

@@ -0,0 +1,3 @@
+export declare class StringUtil {
+    static stringToHashCode(str: string): number;
+}

package/dist/framework/utils/StringUtil.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringUtil = void 0;
+class StringUtil {
+    static stringToHashCode(str) {
+        let hash = 0;
+        if (str.length === 0) {
+            return hash;
+        }
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash |= 0;
+        }
+        return hash;
+    }
+}
+exports.StringUtil = StringUtil;

package/dist/framework/utils/TsAstUtil.d.ts

@@ -0,0 +1,6 @@
+import { Project, SourceFile } from 'ts-morph';
+export declare class TsAstUtil {
+    static project: Project | null;
+    static getSourceFile(filePath: string): SourceFile;
+    static clearProject(): void;
+}

package/dist/framework/utils/TsAstUtil.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsAstUtil = void 0;
+const ts_morph_1 = require("ts-morph");
+class TsAstUtil {
+    static getSourceFile(filePath) {
+        if (!this.project) {
+            this.project = new ts_morph_1.Project({
+                compilerOptions: { target: ts_morph_1.ScriptTarget.ES2021 },
+            });
+        }
+        return this.project.addSourceFileAtPath(filePath);
+    }
+    static clearProject() {
+        this.project = null;
+    }
+}
+exports.TsAstUtil = TsAstUtil;
+TsAstUtil.project = null;

package/dist/framework/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './PluginStore';
+export * from './TsAstUtil';
+export * from './FileUtil';
+export * from './ModuleTypeUtil';
+export * from './StringUtil';
+export * from './ObjectUtils';
+export * from './Logger';

package/dist/framework/utils/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PluginStore"), exports);
+__exportStar(require("./TsAstUtil"), exports);
+__exportStar(require("./FileUtil"), exports);
+__exportStar(require("./ModuleTypeUtil"), exports);
+__exportStar(require("./StringUtil"), exports);
+__exportStar(require("./ObjectUtils"), exports);
+__exportStar(require("./Logger"), exports);

package/dist/hmrouter_extension/HMRouterExtension.d.ts

@@ -0,0 +1,15 @@
+import { PluginExtension } from '../framework';
+import { HMRouterExtensionContext } from './HMRouterExtensionContext';
+import { SourceFile } from 'ts-morph';
+export declare class HMRouterDefaultExtension extends PluginExtension<HMRouterExtensionContext> {
+    get name(): string;
+    afterInitialize(context: HMRouterExtensionContext): void;
+    afterAnnotationAnalysis(sourceFile: SourceFile, filePath: string, context: HMRouterExtensionContext): void;
+    private executeConstantParsing;
+    afterCodeGeneration(context: HMRouterExtensionContext): void;
+    afterRouterMapBuilding(context: HMRouterExtensionContext): void;
+    afterConfigUpdate(context: HMRouterExtensionContext): void;
+    afterObfuscationProcess(context: HMRouterExtensionContext): void;
+    afterResourceProcess(context: HMRouterExtensionContext): void;
+    afterCompletion(context: HMRouterExtensionContext): void;
+}

package/dist/hmrouter_extension/HMRouterExtension.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HMRouterDefaultExtension = void 0;
+const framework_1 = require("../framework");
+const AnnotationAnalyzerRegistry_1 = require("./analyzer/AnnotationAnalyzerRegistry");
+const ConstantAnalyzer_1 = require("./analyzer/utils/ConstantAnalyzer");
+const processor_1 = require("./processor");
+const framework_2 = require("../framework");
+class HMRouterDefaultExtension extends framework_1.PluginExtension {
+    get name() {
+        return 'HMRouterExtension';
+    }
+    afterInitialize(context) {
+        const initializer = new processor_1.InitializerProcessor(context);
+        initializer.execute();
+    }
+    afterAnnotationAnalysis(sourceFile, filePath, context) {
+        AnnotationAnalyzerRegistry_1.AnnotationAnalyzerRegistry.getInstance().initialize(context.config.modulePath);
+        const analyzers = AnnotationAnalyzerRegistry_1.AnnotationAnalyzerRegistry.getInstance().getAnalyzers();
+        for (const analyzer of analyzers) {
+            analyzer.analyze(sourceFile, filePath, context);
+        }
+        this.executeConstantParsing(filePath, context);
+    }
+    executeConstantParsing(filePath, context) {
+        try {
+            const contextImpl = context;
+            const analyzeResults = contextImpl.analyzeResults;
+            const currentView = contextImpl._currentView;
+            const currentFilePath = contextImpl._currentFilePath;
+            const currentFileResults = [];
+            analyzeResults.forEach((result) => {
+                if (result.sourceFilePath === currentFilePath) {
+                    currentFileResults.push(result);
+                }
+            });
+            if (currentFileResults.length === 0) {
+                return;
+            }
+            framework_2.Logger.debug(this.name, `Start constant parsing for ${currentFileResults.length} results in file: ${filePath}`);
+            const constantResolver = AnnotationAnalyzerRegistry_1.AnnotationAnalyzerRegistry.getInstance().getConstantResolver();
+            if (!constantResolver) {
+                framework_2.Logger.warn(this.name, `Constant resolver not available, skip constant parsing for file: ${filePath}`);
+                return;
+            }
+            const constantAnalyzer = new ConstantAnalyzer_1.ConstantAnalyzer(constantResolver);
+            const currentFileResultsCopy = currentFileResults.map((result) => ({ ...result }));
+            const resultsSet = new Set(currentFileResultsCopy);
+            constantAnalyzer.parseConstants(resultsSet);
+            const updatedResults = new Set();
+            analyzeResults.forEach((result) => {
+                if (result.sourceFilePath !== currentFilePath) {
+                    updatedResults.add(result);
+                }
+            });
+            resultsSet.forEach((parsedResult) => {
+                updatedResults.add(parsedResult);
+            });
+            contextImpl.analyzeResults = updatedResults;
+            for (let i = 0; i < currentView.length; i++) {
+                const viewResult = currentView[i];
+                if (viewResult.sourceFilePath === currentFilePath) {
+                    for (const parsedResult of resultsSet) {
+                        if (parsedResult.name === viewResult.name && parsedResult.sourceFilePath === viewResult.sourceFilePath) {
+                            currentView[i] = parsedResult;
+                            break;
+                        }
+                    }
+                }
+            }
+            framework_2.Logger.debug(this.name, `Constant parsing completed for file: ${filePath}`);
+        }
+        catch (error) {
+            framework_2.Logger.warn(this.name, `Failed to execute constant parsing for file ${filePath}: ${error}`);
+        }
+    }
+    afterCodeGeneration(context) {
+        const generator = new processor_1.CodeGenerationProcessor(context);
+        generator.execute();
+    }
+    afterRouterMapBuilding(context) {
+        const builder = new processor_1.RouterMapBuildingProcessor(context);
+        builder.execute();
+    }
+    afterConfigUpdate(context) {
+        const processor = new processor_1.ConfigUpdateProcessor(context);
+        processor.execute();
+    }
+    afterObfuscationProcess(context) {
+        const processor = new processor_1.ObfuscationProcessor(context);
+        processor.execute();
+    }
+    afterResourceProcess(context) {
+        const processor = new processor_1.ResourceProcessProcessor(context);
+        processor.execute();
+    }
+    afterCompletion(context) {
+        const processor = new processor_1.CompletionProcessor(context);
+        processor.execute();
+    }
+}
+exports.HMRouterDefaultExtension = HMRouterDefaultExtension;

package/dist/hmrouter_extension/HMRouterExtensionContext.d.ts

@@ -0,0 +1,8 @@
+import { ExtensionContext } from '../framework';
+import { HMRouterPluginConfig } from './config/HMRouterPluginConfig';
+import { RouterInfo } from './model';
+export interface HMRouterExtensionContext extends ExtensionContext {
+    config: HMRouterPluginConfig;
+    routerMap: RouterInfo[];
+    generatedPaths: Map<string, string>;
+}

package/dist/hmrouter_extension/HMRouterExtensionContext.js

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

package/dist/hmrouter_extension/analyzer/AnnotationAnalyzerRegistry.d.ts

@@ -0,0 +1,14 @@
+import { IConstantResolver } from './interface/IConstantResolver';
+import { AbstractAnnotationAnalyzer } from './interface/AbstractAnnotationAnalyzer';
+export declare class AnnotationAnalyzerRegistry {
+    private static instance;
+    private analyzers;
+    private constantResolver;
+    private constructor();
+    static getInstance(): AnnotationAnalyzerRegistry;
+    initialize(modulePath: string): void;
+    registerAnalyzer(analyzer: AbstractAnnotationAnalyzer): void;
+    getAnalyzers(): AbstractAnnotationAnalyzer[];
+    getConstantResolver(): IConstantResolver;
+    private registerDefaultAnalyzers;
+}

package/dist/hmrouter_extension/analyzer/AnnotationAnalyzerRegistry.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnotationAnalyzerRegistry = void 0;
+const RouterAnalyzer_1 = require("./RouterAnalyzer");
+const ComponentAnalyzer_1 = require("./ComponentAnalyzer");
+const ConstantResolver_1 = require("./utils/ConstantResolver");
+class AnnotationAnalyzerRegistry {
+    constructor() {
+        this.analyzers = new Set();
+        this.constantResolver = null;
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new AnnotationAnalyzerRegistry();
+        }
+        return this.instance;
+    }
+    initialize(modulePath) {
+        if (this.constantResolver) {
+            return;
+        }
+        this.constantResolver = new ConstantResolver_1.ConstantResolver(modulePath);
+        this.registerDefaultAnalyzers();
+    }
+    registerAnalyzer(analyzer) {
+        this.analyzers.add(analyzer);
+    }
+    getAnalyzers() {
+        return Array.from(this.analyzers);
+    }
+    getConstantResolver() {
+        if (!this.constantResolver) {
+            throw new Error('AnnotationAnalyzerRegistry not initialized. Call initialize() first.');
+        }
+        return this.constantResolver;
+    }
+    registerDefaultAnalyzers() {
+        if (!this.constantResolver) {
+            throw new Error('AnnotationAnalyzerRegistry not initialized properly.');
+        }
+        this.registerAnalyzer(new RouterAnalyzer_1.RouterAnalyzer(this.constantResolver));
+        this.registerAnalyzer(new ComponentAnalyzer_1.ComponentAnalyzer(this.constantResolver));
+    }
+}
+exports.AnnotationAnalyzerRegistry = AnnotationAnalyzerRegistry;

package/dist/hmrouter_extension/analyzer/ComponentAnalyzer.d.ts

@@ -0,0 +1,12 @@
+import { SourceFile } from 'ts-morph';
+import { AbstractAnnotationAnalyzer } from './interface/AbstractAnnotationAnalyzer';
+import { IConstantResolver } from './interface/IConstantResolver';
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class ComponentAnalyzer extends AbstractAnnotationAnalyzer {
+    readonly name = "ComponentAnalyzer";
+    constructor(constantResolver: IConstantResolver);
+    analyze(sourceFile: SourceFile, filePath: string, context: HMRouterExtensionContext): void;
+    private analyzeClassDecorators;
+    private analyzeMethodDecorators;
+    private addToResultSet;
+}

package/dist/hmrouter_extension/analyzer/ComponentAnalyzer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentAnalyzer = void 0;
+const AbstractAnnotationAnalyzer_1 = require("./interface/AbstractAnnotationAnalyzer");
+const DecoratorParser_1 = require("./utils/DecoratorParser");
+const constants_1 = require("../constants");
+class ComponentAnalyzer extends AbstractAnnotationAnalyzer_1.AbstractAnnotationAnalyzer {
+    constructor(constantResolver) {
+        super(constantResolver);
+        this.name = 'ComponentAnalyzer';
+    }
+    analyze(sourceFile, filePath, context) {
+        const results = [];
+        sourceFile.getClasses().forEach((cls) => {
+            this.analyzeClassDecorators(cls, filePath, sourceFile, results);
+            this.analyzeMethodDecorators(cls, filePath, sourceFile, results);
+        });
+        context.addAnalyzeResults(results);
+    }
+    analyzeClassDecorators(cls, filePath, sourceFile, results) {
+        cls.getDecorators().forEach((decorator) => {
+            if ([
+                constants_1.AnnotationConstants.INTERCEPTOR_ANNOTATION,
+                constants_1.AnnotationConstants.LIFECYCLE_ANNOTATION,
+                constants_1.AnnotationConstants.ANIMATOR_ANNOTATION,
+                constants_1.AnnotationConstants.SERVICE_PROVIDE_ANNOTATION,
+            ].includes(decorator.getName())) {
+                const result = this.addToResultSet(decorator, cls.getName(), filePath, sourceFile);
+                results.push(result);
+            }
+        });
+    }
+    analyzeMethodDecorators(cls, filePath, sourceFile, results) {
+        cls.getMethods().forEach((method) => {
+            method.getDecorators().forEach((decorator) => {
+                if (decorator.getName() === constants_1.AnnotationConstants.SERVICE_ANNOTATION) {
+                    const serviceResult = this.addToResultSet(decorator, cls.getName(), filePath, sourceFile);
+                    serviceResult.functionName = method.getName();
+                    results.push(serviceResult);
+                }
+            });
+        });
+    }
+    addToResultSet(decorator, componentName, filePath, sourceFile) {
+        const decoratorResult = DecoratorParser_1.DecoratorParser.parseDecorator(decorator, this.constantResolver, sourceFile, filePath);
+        decoratorResult.name = componentName;
+        decoratorResult.sourceFilePath = filePath;
+        return decoratorResult;
+    }
+}
+exports.ComponentAnalyzer = ComponentAnalyzer;

package/dist/hmrouter_extension/analyzer/RouterAnalyzer.d.ts

@@ -0,0 +1,12 @@
+import { SourceFile } from 'ts-morph';
+import { AbstractAnnotationAnalyzer } from './interface/AbstractAnnotationAnalyzer';
+import { IConstantResolver } from './interface/IConstantResolver';
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class RouterAnalyzer extends AbstractAnnotationAnalyzer {
+    readonly name = "RouterAnalyzer";
+    constructor(constantResolver: IConstantResolver);
+    analyze(sourceFile: SourceFile, filePath: string, context: HMRouterExtensionContext): void;
+    private addToResultSet;
+    private checkNavDestinationUsage;
+    private extractComponentNameFromNode;
+}