@hadss/hmrouter-plugin/dist/hmrouter_extension/HMRouterExtension.js

HMRouter Compiler Plugin

"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;