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

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,14 @@
+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;
+    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,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HMRouterDefaultExtension = void 0;
+const framework_1 = require("../framework");
+const AnnotationAnalyzerRegistry_1 = require("./analyzer/AnnotationAnalyzerRegistry");
+const processor_1 = require("./processor");
+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);
+        }
+    }
+    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,52 @@
+"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.SERVICE_ANNOTATION,
+                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,11 @@
+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;
+}

package/dist/hmrouter_extension/analyzer/RouterAnalyzer.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterAnalyzer = void 0;
+const ts_morph_1 = require("ts-morph");
+const AbstractAnnotationAnalyzer_1 = require("./interface/AbstractAnnotationAnalyzer");
+const DecoratorParser_1 = require("./utils/DecoratorParser");
+const constants_1 = require("../constants");
+const framework_1 = require("../../framework");
+const PluginError_1 = require("../error/PluginError");
+class RouterAnalyzer extends AbstractAnnotationAnalyzer_1.AbstractAnnotationAnalyzer {
+    constructor(constantResolver) {
+        super(constantResolver);
+        this.name = 'RouterAnalyzer';
+    }
+    analyze(sourceFile, filePath, context) {
+        framework_1.Logger.debug('', `Start to analyze source file: ${filePath}`);
+        const viewNameArr = sourceFile
+            .getChildrenOfKind(ts_morph_1.SyntaxKind.ExpressionStatement)
+            .map((node) => node.getText())
+            .filter((text) => text !== 'struct');
+        sourceFile.getChildrenOfKind(ts_morph_1.SyntaxKind.MissingDeclaration).forEach((node, index) => {
+            node.getChildrenOfKind(ts_morph_1.SyntaxKind.Decorator).forEach((decorator) => {
+                if (decorator.getName() === constants_1.AnnotationConstants.ROUTER_ANNOTATION) {
+                    const result = this.addToResultSet(decorator, viewNameArr[index], filePath, sourceFile);
+                    context.addAnalyzeResults(result);
+                }
+            });
+        });
+        sourceFile.getExportAssignments().forEach((exportAssignment, index) => {
+            exportAssignment.getDescendantsOfKind(ts_morph_1.SyntaxKind.Decorator).forEach((decorator) => {
+                if (decorator.getName() === constants_1.AnnotationConstants.ROUTER_ANNOTATION) {
+                    const result = this.addToResultSet(decorator, viewNameArr[index], filePath, sourceFile);
+                    context.addAnalyzeResults(result);
+                    context.addTemplateData(result.name, { isDefaultExport: 'true' });
+                }
+            });
+        });
+        this.checkNavDestinationUsage(sourceFile, filePath);
+    }
+    addToResultSet(decorator, componentName, filePath, sourceFile) {
+        const decoratorResult = DecoratorParser_1.DecoratorParser.parseDecorator(decorator, this.constantResolver, sourceFile, filePath);
+        decoratorResult.name = componentName;
+        decoratorResult.sourceFilePath = filePath;
+        return decoratorResult;
+    }
+    checkNavDestinationUsage(sourceFile, filePath) {
+        const statements = sourceFile.getStatements();
+        const sortedStatements = statements.sort((a, b) => a.getStart() - b.getStart());
+        let HMRouterExists = false;
+        let useNavDst = false;
+        sortedStatements.forEach((statement) => {
+            if (statement.getKind() === ts_morph_1.SyntaxKind.MissingDeclaration &&
+                statement.getText().includes(constants_1.AnnotationConstants.ROUTER_ANNOTATION)) {
+                HMRouterExists = true;
+                useNavDst = false;
+                const text = statement.getText();
+                if (/(useNavDst\s*:\s*true)/.test(text)) {
+                    framework_1.Logger.debug('', `Found useNavDst: true in @HMRouter annotation, skip NavDestination check, filePath: ${filePath}`);
+                    useNavDst = true;
+                }
+            }
+            if (statement.getKind() === ts_morph_1.SyntaxKind.Block && HMRouterExists) {
+                HMRouterExists = false;
+                if (useNavDst) {
+                    return;
+                }
+                const reg = new RegExp(/NavDestination\s*\(\s*\)/);
+                const text = statement.getText();
+                const cleanedCodeBlock = text
+                    .replace(/(["'`]).*?\1/g, '')
+                    .replace(/\/\/.*|\/\*[\s\S]*?\*\//g, '');
+                if (reg.test(cleanedCodeBlock)) {
+                    throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.WRONG_DECORATION, '', filePath);
+                }
+            }
+        });
+    }
+}
+exports.RouterAnalyzer = RouterAnalyzer;

package/dist/hmrouter_extension/analyzer/interface/AbstractAnnotationAnalyzer.d.ts

@@ -0,0 +1,9 @@
+import { SourceFile } from 'ts-morph';
+import { IConstantResolver } from './IConstantResolver';
+import { HMRouterExtensionContext } from '../../HMRouterExtensionContext';
+export declare abstract class AbstractAnnotationAnalyzer {
+    abstract readonly name: string;
+    protected constantResolver: IConstantResolver;
+    protected constructor(constantResolver: IConstantResolver);
+    abstract analyze(sourceFile: SourceFile, filePath: string, context: HMRouterExtensionContext): void;
+}

package/dist/hmrouter_extension/analyzer/interface/AbstractAnnotationAnalyzer.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAnnotationAnalyzer = void 0;
+class AbstractAnnotationAnalyzer {
+    constructor(constantResolver) {
+        this.constantResolver = constantResolver;
+    }
+}
+exports.AbstractAnnotationAnalyzer = AbstractAnnotationAnalyzer;

package/dist/hmrouter_extension/analyzer/interface/IConstantResolver.d.ts

@@ -0,0 +1,7 @@
+import { Expression, SourceFile } from 'ts-morph';
+export interface IConstantResolver {
+    resolveConstant(value: any, sourceFile: SourceFile, filePath: string): any;
+    resolvePropertyValue(value: Expression, sourceFile: SourceFile, filePath: string): any;
+    getVariableFilePath(variableName: string, sourceFile: SourceFile, filePath: string): string;
+    getOtherModuleVariableFilePath(moduleName: string, variableName: string, modulePath: string): string;
+}

package/dist/hmrouter_extension/analyzer/interface/IConstantResolver.js

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

package/dist/hmrouter_extension/analyzer/utils/ConstantAnalyzer.d.ts

@@ -0,0 +1,9 @@
+import { IConstantResolver } from '../interface/IConstantResolver';
+import { BaseAnalyzeResult } from '../../../framework';
+export declare class ConstantAnalyzer {
+    private constantResolver;
+    constructor(constantResolver: IConstantResolver);
+    parseConstants(analyzeResults: Set<BaseAnalyzeResult>): void;
+    private parseResult;
+    private parsePropertyValue;
+}

package/dist/hmrouter_extension/analyzer/utils/ConstantAnalyzer.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantAnalyzer = void 0;
+const framework_1 = require("../../../framework");
+class ConstantAnalyzer {
+    constructor(constantResolver) {
+        this.constantResolver = constantResolver;
+    }
+    parseConstants(analyzeResults) {
+        analyzeResults.forEach((item) => {
+            this.parseResult(item);
+        });
+    }
+    parseResult(result) {
+        if (!result.sourceFilePath) {
+            return;
+        }
+        Object.getOwnPropertyNames(result).forEach((key) => {
+            let propertyValue = Reflect.get(result, key);
+            propertyValue = this.parsePropertyValue(result.sourceFilePath, propertyValue);
+            if (propertyValue === '') {
+                throw new Error(`Constants value cannot be an empty string, filePath: ${result.sourceFilePath}`);
+            }
+            Reflect.set(result, key, propertyValue);
+        });
+    }
+    parsePropertyValue(filePath, propertyValue) {
+        const sourceFile = framework_1.TsAstUtil.getSourceFile(filePath);
+        return this.constantResolver.resolveConstant(propertyValue, sourceFile, filePath);
+    }
+}
+exports.ConstantAnalyzer = ConstantAnalyzer;

package/dist/hmrouter_extension/analyzer/utils/ConstantResolver.d.ts

@@ -0,0 +1,15 @@
+import { Expression, SourceFile } from 'ts-morph';
+import { IConstantResolver } from '../interface/IConstantResolver';
+export declare class ConstantResolver implements IConstantResolver {
+    private importMapCache;
+    private readonly modulePath;
+    constructor(modulePath: string);
+    resolveConstant(value: any, sourceFile: SourceFile, filePath: string): any;
+    resolvePropertyValue(value: Expression, sourceFile: SourceFile, filePath: string): any;
+    getVariableFilePath(variableName: string, sourceFile: SourceFile, filePath: string): string;
+    getOtherModuleVariableFilePath(moduleName: string, variableName: string, modulePath: string): string;
+    private parsePrimitiveValue;
+    private parseConstantValue;
+    private parseCrossModuleVariable;
+    getExportedVariables(sourceFile: SourceFile): string[];
+}