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

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

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantResolver = void 0;
+const ts_morph_1 = require("ts-morph");
+const framework_1 = require("../../../framework");
+const constants_1 = require("../../constants");
+const ImportAnalyzer_1 = require("./ImportAnalyzer");
+const PluginError_1 = require("../../error/PluginError");
+class ConstantResolver {
+    constructor(modulePath) {
+        this.importMapCache = new Map();
+        this.modulePath = modulePath;
+    }
+    resolveConstant(value, sourceFile, filePath) {
+        if (value.type === 'constant') {
+            return this.parseConstantValue(framework_1.TsAstUtil.getSourceFile(value.variableFilePath), value.variableName);
+        }
+        else if (value.type === 'object') {
+            return this.parseConstantValue(framework_1.TsAstUtil.getSourceFile(value.variableFilePath), value.variableName, value.propertyName);
+        }
+        else if (value.type === 'array') {
+            return value.value.map((item) => {
+                return this.resolveConstant(item, sourceFile, filePath);
+            });
+        }
+        else {
+            return value;
+        }
+    }
+    resolvePropertyValue(value, sourceFile, filePath) {
+        switch (value.getKind()) {
+            case ts_morph_1.SyntaxKind.Identifier:
+                if (value.getText() === 'undefined') {
+                    throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.INVALID_STRING_VALUE, '', filePath);
+                }
+                return {
+                    type: 'constant',
+                    variableName: value.getText(),
+                    variableFilePath: this.getVariableFilePath(value.getText(), sourceFile, filePath),
+                };
+            case ts_morph_1.SyntaxKind.PropertyAccessExpression:
+                return {
+                    type: 'object',
+                    variableName: value.getExpression().getText(),
+                    propertyName: value?.getName(),
+                    variableFilePath: this.getVariableFilePath(value?.getExpression().getText(), sourceFile, filePath),
+                };
+            case ts_morph_1.SyntaxKind.ArrayLiteralExpression:
+                return {
+                    type: 'array',
+                    value: value
+                        .asKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression)
+                        ?.getElements()
+                        .map((item) => this.resolvePropertyValue(item, sourceFile, filePath)),
+                };
+            default:
+                return this.parsePrimitiveValue(value);
+        }
+    }
+    getVariableFilePath(variableName, sourceFile, filePath) {
+        let resultPath = '';
+        const classesNames = sourceFile.getClasses().map((classes) => classes.getName());
+        const variableNames = sourceFile
+            .getVariableDeclarations()
+            .map((variableDeclaration) => variableDeclaration.getName());
+        if (classesNames.includes(variableName) || variableNames.includes(variableName)) {
+            return filePath;
+        }
+        let importMap;
+        if (this.importMapCache.has(filePath)) {
+            importMap = this.importMapCache.get(filePath);
+        }
+        else {
+            importMap = ImportAnalyzer_1.ImportAnalyzer.analyzeImports(sourceFile);
+            this.importMapCache.set(filePath, importMap);
+        }
+        for (const [importPath, importNames] of importMap.entries()) {
+            if (importNames.includes(variableName)) {
+                const currentDir = framework_1.PluginFileUtil.pathResolve(filePath, constants_1.FilePathConstants.PARENT_DELIMITER);
+                const tempFilePath = framework_1.PluginFileUtil.pathResolve(currentDir, importPath + constants_1.FilePathConstants.ETS_SUFFIX);
+                if (framework_1.PluginFileUtil.exist(tempFilePath)) {
+                    resultPath = tempFilePath;
+                    break;
+                }
+            }
+        }
+        if (!resultPath) {
+            for (const [importPath, importNames] of importMap.entries()) {
+                if (importNames.includes(variableName)) {
+                    resultPath = this.getOtherModuleVariableFilePath(importPath, variableName, this.modulePath);
+                    break;
+                }
+            }
+        }
+        return resultPath;
+    }
+    getOtherModuleVariableFilePath(moduleName, variableName, modulePath) {
+        let moduleFilePath = framework_1.PluginFileUtil.pathResolve(modulePath, constants_1.FilePathConstants.OH_MODULE_PATH, moduleName, constants_1.FilePathConstants.DEFAULT_SCAN_DIR);
+        if (!framework_1.PluginFileUtil.exist(moduleFilePath)) {
+            moduleFilePath = framework_1.PluginFileUtil.pathResolve(framework_1.PluginStore.getInstance().get('projectFilePath'), constants_1.FilePathConstants.OH_MODULE_PATH, moduleName, constants_1.FilePathConstants.DEFAULT_SCAN_DIR);
+        }
+        const variableCache = framework_1.PluginStore.getInstance().get('variableCache');
+        if (!variableCache) {
+            framework_1.PluginStore.getInstance().set('variableCache', new Map());
+        }
+        let variableMap;
+        if (variableCache?.has(moduleName)) {
+            variableMap = variableCache.get(moduleName);
+        }
+        else {
+            variableMap = this.parseCrossModuleVariable(moduleFilePath);
+            variableCache?.set(moduleName, variableMap);
+        }
+        for (let [key, value] of variableMap) {
+            if (value.includes(variableName)) {
+                return key;
+            }
+        }
+        throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.UNKNOWN_VARIABLE, '', variableName);
+    }
+    parsePrimitiveValue(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;
+    }
+    parseConstantValue(sourceFile, variableName, propertyName) {
+        let result;
+        if (propertyName) {
+            let classInstance = sourceFile.getClasses().find((classes) => {
+                return classes.getName() === variableName;
+            });
+            if (!classInstance) {
+                throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.UNKNOWN_CLASS, '', variableName);
+            }
+            let property = classInstance.getProperties().find((properties) => {
+                return properties.getName() === propertyName;
+            });
+            if (!property) {
+                throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.UNKNOWN_PROPERTY, '', propertyName);
+            }
+            result = property.getInitializer();
+        }
+        else {
+            let constant = sourceFile.getVariableDeclarations().find((declaration) => {
+                return declaration.getName() === variableName;
+            });
+            if (!constant) {
+                throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.UNKNOWN_CONSTANT, '', variableName);
+            }
+            result = constant.getInitializer();
+        }
+        if (result.getKind() !== ts_morph_1.SyntaxKind.StringLiteral) {
+            throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.INVALID_STRING_VALUE, '', variableName);
+        }
+        const resultValue = result.asKind(ts_morph_1.SyntaxKind.StringLiteral)?.getLiteralValue();
+        if (!resultValue) {
+            throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.NOT_EMPTY_STRING, '', variableName);
+        }
+        return resultValue;
+    }
+    parseCrossModuleVariable(scanDir) {
+        let sourceFiles = framework_1.TsAstUtil.project.addSourceFilesAtPaths(`${scanDir}/**/*.ets`);
+        const exportMap = new Map();
+        for (let sourceFile of sourceFiles) {
+            const exportedNames = this.getExportedVariables(sourceFile);
+            if (exportedNames.length > 0) {
+                exportMap.set(sourceFile.getFilePath(), exportedNames);
+            }
+        }
+        return exportMap;
+    }
+    getExportedVariables(sourceFile) {
+        const exportSymbols = [];
+        let exportKeywordNodes = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ExportKeyword);
+        exportKeywordNodes.forEach((node) => {
+            let parentNodeKind = node.getParent()?.getKind();
+            switch (parentNodeKind) {
+                case ts_morph_1.SyntaxKind.VariableStatement:
+                    let variableStatement = node.getParent()?.asKind(ts_morph_1.SyntaxKind.VariableStatement);
+                    let variableNames = variableStatement
+                        .getDeclarationList()
+                        .getDeclarations()
+                        .map((declaration) => {
+                        return declaration.getName();
+                    });
+                    exportSymbols.push(...variableNames);
+                    break;
+                case ts_morph_1.SyntaxKind.ClassDeclaration:
+                    let classDeclaration = node.getParent();
+                    let className = classDeclaration?.asKind(ts_morph_1.SyntaxKind.ClassDeclaration)?.getName();
+                    exportSymbols.push(className);
+                    break;
+            }
+        });
+        return exportSymbols;
+    }
+}
+exports.ConstantResolver = ConstantResolver;

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

@@ -0,0 +1,7 @@
+import { Decorator, SourceFile } from 'ts-morph';
+import { IConstantResolver } from '../interface/IConstantResolver';
+import { BaseAnalyzeResult } from '../../../framework';
+export declare class DecoratorParser {
+    static parseDecorator(decorator: Decorator, constantResolver: IConstantResolver, sourceFile: SourceFile, filePath: string): BaseAnalyzeResult;
+    static parseDecoratorArguments(decorator: Decorator, constantResolver: IConstantResolver, sourceFile: SourceFile, filePath: string): BaseAnalyzeResult;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecoratorParser = void 0;
+const ts_morph_1 = require("ts-morph");
+class DecoratorParser {
+    static parseDecorator(decorator, constantResolver, sourceFile, filePath) {
+        const decoratorResult = {
+            annotation: decorator.getName(),
+            name: '',
+            sourceFilePath: ''
+        };
+        const args = this.parseDecoratorArguments(decorator, constantResolver, sourceFile, filePath);
+        Object.assign(decoratorResult, args);
+        return decoratorResult;
+    }
+    static parseDecoratorArguments(decorator, constantResolver, sourceFile, filePath) {
+        const argResult = {
+            annotation: decorator.getName(),
+            name: '',
+            sourceFilePath: '',
+        };
+        decorator.getArguments().forEach((arg) => {
+            const objLiteral = arg.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+            if (objLiteral) {
+                objLiteral.getProperties().forEach((prop) => {
+                    if (prop.getKind() === ts_morph_1.SyntaxKind.PropertyAssignment) {
+                        const propertyAssignment = prop;
+                        const propertyName = propertyAssignment.getName();
+                        const initializer = propertyAssignment.getInitializer();
+                        if (initializer) {
+                            const propertyValue = constantResolver.resolvePropertyValue(initializer, sourceFile, filePath);
+                            Reflect.set(argResult, propertyName, propertyValue);
+                        }
+                    }
+                });
+            }
+        });
+        return argResult;
+    }
+}
+exports.DecoratorParser = DecoratorParser;

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

@@ -0,0 +1,4 @@
+import { SourceFile } from 'ts-morph';
+export declare class ImportAnalyzer {
+    static analyzeImports(sourceFile: SourceFile): Map<string, string[]>;
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportAnalyzer = void 0;
+class ImportAnalyzer {
+    static analyzeImports(sourceFile) {
+        const importMap = new Map();
+        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) {
+                if (importMap.has(moduleSpecifier)) {
+                    const existingImports = importMap.get(moduleSpecifier);
+                    importMap.set(moduleSpecifier, [...new Set([...existingImports, ...importNames])]);
+                }
+                else {
+                    importMap.set(moduleSpecifier, importNames);
+                }
+            }
+        });
+        return importMap;
+    }
+}
+exports.ImportAnalyzer = ImportAnalyzer;

package/dist/hmrouter_extension/config/HMRouterPluginConfig.d.ts

@@ -0,0 +1,38 @@
+export declare class HMRouterPluginConfig {
+    moduleName: string;
+    modulePath: string;
+    configDir: string;
+    scanDir: string[];
+    routerMapDir: string;
+    builderDir: string;
+    defaultPageTemplate: string;
+    customPageTemplate: CustomPageTemplateImpl[];
+    saveGeneratedFile: boolean;
+    autoObfuscation: boolean;
+    constructor(moduleName: string, modulePath: string, configDir: string, param: HMRouterPluginConfigParam);
+    getScanPath(dir: string): string;
+    getRelativeSourcePath(filePath: string): string;
+    getRelativeBuilderPath(filePath: string): string;
+    getGeneratedFilePath(generatorViewName: string): string;
+    getBuilderDir(): string;
+    getBuilderFilePath(generatorViewName: string): string;
+    getRouterMapDir(): string;
+    getModuleRouterMapFilePath(routerMapFileName: string): string;
+    getRawFilePath(): string;
+    getDefaultTplFilePath(): string;
+    getObfuscationFilePath(): string;
+    getConsumerRulesFilePath(): string;
+}
+export interface HMRouterPluginConfigParam {
+    scanDir?: string[];
+    routerMapDir?: string;
+    builderDir?: string;
+    autoObfuscation?: boolean;
+    saveGeneratedFile?: boolean;
+    defaultPageTemplate?: string;
+    customPageTemplate?: CustomPageTemplateImpl[];
+}
+export interface CustomPageTemplateImpl {
+    srcPath: string[];
+    templatePath: string;
+}

package/dist/hmrouter_extension/config/HMRouterPluginConfig.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HMRouterPluginConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const framework_1 = require("../../framework");
+const constants_1 = require("../constants");
+class HMRouterPluginConfig {
+    constructor(moduleName, modulePath, configDir, param) {
+        this.moduleName = moduleName;
+        this.modulePath = modulePath;
+        this.configDir = configDir;
+        this.scanDir = param.scanDir ? [...new Set(param.scanDir)] : [];
+        this.routerMapDir = param.routerMapDir || '';
+        this.builderDir = param.builderDir || '';
+        this.defaultPageTemplate = param.defaultPageTemplate || '';
+        this.customPageTemplate = param.customPageTemplate || [];
+        this.saveGeneratedFile = !!param.saveGeneratedFile;
+        this.autoObfuscation = !!param.autoObfuscation;
+    }
+    getScanPath(dir) {
+        return framework_1.PluginFileUtil.pathResolve(this.modulePath, dir);
+    }
+    getRelativeSourcePath(filePath) {
+        return path_1.default.relative(this.modulePath, filePath);
+    }
+    getRelativeBuilderPath(filePath) {
+        return path_1.default.relative(this.builderDir, filePath);
+    }
+    getGeneratedFilePath(generatorViewName) {
+        return framework_1.PluginFileUtil.pathResolve(this.modulePath, this.builderDir, generatorViewName + constants_1.FilePathConstants.ETS_SUFFIX);
+    }
+    getBuilderDir() {
+        return framework_1.PluginFileUtil.pathResolve(this.modulePath, this.builderDir);
+    }
+    getBuilderFilePath(generatorViewName) {
+        return path_1.default.join(this.builderDir, generatorViewName + constants_1.FilePathConstants.ETS_SUFFIX);
+    }
+    getRouterMapDir() {
+        return framework_1.PluginFileUtil.pathResolve(this.modulePath, this.routerMapDir, constants_1.RouterMapConstants.ROUTER_MAP_NAME);
+    }
+    getModuleRouterMapFilePath(routerMapFileName) {
+        return framework_1.PluginFileUtil.pathResolve(this.modulePath, this.routerMapDir, routerMapFileName + constants_1.FilePathConstants.JSON_SUFFIX);
+    }
+    getRawFilePath() {
+        return framework_1.PluginFileUtil.pathResolve(this.modulePath, constants_1.FilePathConstants.RAWFILE_DIR);
+    }
+    getDefaultTplFilePath() {
+        let templateFilePath = framework_1.PluginFileUtil.pathResolve(this.configDir, this.defaultPageTemplate);
+        if (framework_1.PluginFileUtil.exist(templateFilePath)) {
+            return templateFilePath;
+        }
+        return framework_1.PluginFileUtil.pathResolve(__dirname, constants_1.FilePathConstants.PARENT_DELIMITER.repeat(3) + this.defaultPageTemplate);
+    }
+    getObfuscationFilePath() {
+        return framework_1.PluginFileUtil.pathResolve(this.modulePath, constants_1.FilePathConstants.OBFUSCATION_FILE_NAME);
+    }
+    getConsumerRulesFilePath() {
+        return framework_1.PluginFileUtil.pathResolve(this.modulePath, constants_1.FilePathConstants.CONSUMER_FILE_NAME);
+    }
+}
+exports.HMRouterPluginConfig = HMRouterPluginConfig;

package/dist/hmrouter_extension/constants/AnnotationConstants.d.ts

@@ -0,0 +1,8 @@
+export default class AnnotationConstants {
+    static readonly ROUTER_ANNOTATION = "HMRouter";
+    static readonly ANIMATOR_ANNOTATION = "HMAnimator";
+    static readonly INTERCEPTOR_ANNOTATION = "HMInterceptor";
+    static readonly LIFECYCLE_ANNOTATION = "HMLifecycle";
+    static readonly SERVICE_ANNOTATION = "HMService";
+    static readonly SERVICE_PROVIDE_ANNOTATION = "HMServiceProvider";
+}

package/dist/hmrouter_extension/constants/AnnotationConstants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AnnotationConstants {
+}
+exports.default = AnnotationConstants;
+AnnotationConstants.ROUTER_ANNOTATION = 'HMRouter';
+AnnotationConstants.ANIMATOR_ANNOTATION = 'HMAnimator';
+AnnotationConstants.INTERCEPTOR_ANNOTATION = 'HMInterceptor';
+AnnotationConstants.LIFECYCLE_ANNOTATION = 'HMLifecycle';
+AnnotationConstants.SERVICE_ANNOTATION = 'HMService';
+AnnotationConstants.SERVICE_PROVIDE_ANNOTATION = 'HMServiceProvider';

package/dist/hmrouter_extension/constants/FilePathConstants.d.ts

@@ -0,0 +1,19 @@
+export default class FilePathConstants {
+    static readonly OBFUSCATION_FILE_NAME = "hmrouter-obfuscation-rules.txt";
+    static readonly CONSUMER_FILE_NAME = "hmrouter-consumer-rules.txt";
+    static readonly FILE_SEPARATOR: "\\" | "/";
+    static readonly DELIMITER = "/";
+    static readonly TEMP_ROUTER_MAP_PATH = "../../intermediates/router_map";
+    static readonly RAWFILE_DIR = "src/main/resources/rawfile/hm_router_map.json";
+    static readonly ETS_SUFFIX = ".ets";
+    static readonly JSON_SUFFIX = ".json";
+    static readonly CONFIG_FILE_NAME = "hmrouter_config.json";
+    static readonly PARENT_DELIMITER = "../";
+    static readonly CURRENT_DELIMITER = "./";
+    static readonly OH_MODULE_PATH = "oh_modules";
+    static readonly OH_PACKAGE_FILE_NAME = "oh-package.json5";
+    static readonly LINE_BREAK = "\n";
+    static readonly DEFAULT_SCAN_DIR = "src/main/ets";
+    static readonly DEFAULT_ROUTER_MAP_DIR = "src/main/resources/base/profile";
+    static readonly DEFAULT_BUILD_DIR = "src/main/ets/generated";
+}

package/dist/hmrouter_extension/constants/FilePathConstants.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+class FilePathConstants {
+}
+exports.default = FilePathConstants;
+FilePathConstants.OBFUSCATION_FILE_NAME = 'hmrouter-obfuscation-rules.txt';
+FilePathConstants.CONSUMER_FILE_NAME = 'hmrouter-consumer-rules.txt';
+FilePathConstants.FILE_SEPARATOR = path_1.default.sep;
+FilePathConstants.DELIMITER = '/';
+FilePathConstants.TEMP_ROUTER_MAP_PATH = '../../intermediates/router_map';
+FilePathConstants.RAWFILE_DIR = 'src/main/resources/rawfile/hm_router_map.json';
+FilePathConstants.ETS_SUFFIX = '.ets';
+FilePathConstants.JSON_SUFFIX = '.json';
+FilePathConstants.CONFIG_FILE_NAME = 'hmrouter_config.json';
+FilePathConstants.PARENT_DELIMITER = '../';
+FilePathConstants.CURRENT_DELIMITER = './';
+FilePathConstants.OH_MODULE_PATH = 'oh_modules';
+FilePathConstants.OH_PACKAGE_FILE_NAME = 'oh-package.json5';
+FilePathConstants.LINE_BREAK = '\n';
+FilePathConstants.DEFAULT_SCAN_DIR = 'src/main/ets';
+FilePathConstants.DEFAULT_ROUTER_MAP_DIR = 'src/main/resources/base/profile';
+FilePathConstants.DEFAULT_BUILD_DIR = 'src/main/ets/generated';

package/dist/hmrouter_extension/constants/ObfuscationConstants.d.ts

@@ -0,0 +1,5 @@
+export default class ObfuscationConstants {
+    static readonly KEEP_FILE_NAME = "-keep-file-name";
+    static readonly KEEP_PROPERTY_NAME = "-keep-property-name";
+    static readonly KEEP_GLOBAL_NAME = "-keep-global-name";
+}

package/dist/hmrouter_extension/constants/ObfuscationConstants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ObfuscationConstants {
+}
+exports.default = ObfuscationConstants;
+ObfuscationConstants.KEEP_FILE_NAME = '-keep-file-name';
+ObfuscationConstants.KEEP_PROPERTY_NAME = '-keep-property-name';
+ObfuscationConstants.KEEP_GLOBAL_NAME = '-keep-global-name';

package/dist/hmrouter_extension/constants/PluginConstants.d.ts

@@ -0,0 +1,6 @@
+export default class PluginConstants {
+    static readonly HAP_PLUGIN_ID = "HAP_HMROUTER_PLUGIN";
+    static readonly HSP_PLUGIN_ID = "HSP_HMROUTER_PLUGIN";
+    static readonly HAR_PLUGIN_ID = "HAR_HMROUTER_PLUGIN";
+    static readonly HAR_MODULE_NAME = "har";
+}

package/dist/hmrouter_extension/constants/PluginConstants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PluginConstants {
+}
+exports.default = PluginConstants;
+PluginConstants.HAP_PLUGIN_ID = 'HAP_HMROUTER_PLUGIN';
+PluginConstants.HSP_PLUGIN_ID = 'HSP_HMROUTER_PLUGIN';
+PluginConstants.HAR_PLUGIN_ID = 'HAR_HMROUTER_PLUGIN';
+PluginConstants.HAR_MODULE_NAME = 'har';

package/dist/hmrouter_extension/constants/PrefixConstants.d.ts

@@ -0,0 +1,8 @@
+export default class PrefixConstants {
+    static readonly ANIMATOR_PREFIX = "__animator__";
+    static readonly INTERCEPTOR_PREFIX = "__interceptor__";
+    static readonly LIFECYCLE_PREFIX = "__lifecycle__";
+    static readonly SERVICE_PREFIX = "__service__";
+    static readonly SERVICE_PROVIDE_PREFIX = "__service_provider__";
+    static readonly VIEW_NAME_PREFIX = "HM";
+}

package/dist/hmrouter_extension/constants/PrefixConstants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PrefixConstants {
+}
+exports.default = PrefixConstants;
+PrefixConstants.ANIMATOR_PREFIX = '__animator__';
+PrefixConstants.INTERCEPTOR_PREFIX = '__interceptor__';
+PrefixConstants.LIFECYCLE_PREFIX = '__lifecycle__';
+PrefixConstants.SERVICE_PREFIX = '__service__';
+PrefixConstants.SERVICE_PROVIDE_PREFIX = '__service_provider__';
+PrefixConstants.VIEW_NAME_PREFIX = 'HM';

package/dist/hmrouter_extension/constants/RouterMapConstants.d.ts

@@ -0,0 +1,5 @@
+export default class RouterMapConstants {
+    static readonly ROUTER_MAP_KEY = "routerMap";
+    static readonly MODULE_ROUTER_MAP_NAME = "$profile:hm_router_map";
+    static readonly ROUTER_MAP_NAME = "hm_router_map.json";
+}

package/dist/hmrouter_extension/constants/RouterMapConstants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RouterMapConstants {
+}
+exports.default = RouterMapConstants;
+RouterMapConstants.ROUTER_MAP_KEY = 'routerMap';
+RouterMapConstants.MODULE_ROUTER_MAP_NAME = '$profile:hm_router_map';
+RouterMapConstants.ROUTER_MAP_NAME = 'hm_router_map.json';

package/dist/hmrouter_extension/constants/TemplateConstants.d.ts

@@ -0,0 +1,6 @@
+export default class TemplateConstants {
+    static readonly CUSTOM_BUILDER_TEMPLATE = "template/customBuilder.ejs";
+    static readonly VIEW_BUILDER_TEMPLATE = "template/viewBuilder.ejs";
+    static readonly V1_TEMPLATE = "template/viewBuilder_v1.ejs";
+    static readonly WARP_BUILDER = "WrapBuilder";
+}

package/dist/hmrouter_extension/constants/TemplateConstants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TemplateConstants {
+}
+exports.default = TemplateConstants;
+TemplateConstants.CUSTOM_BUILDER_TEMPLATE = 'template/customBuilder.ejs';
+TemplateConstants.VIEW_BUILDER_TEMPLATE = 'template/viewBuilder.ejs';
+TemplateConstants.V1_TEMPLATE = 'template/viewBuilder_v1.ejs';
+TemplateConstants.WARP_BUILDER = 'WrapBuilder';

package/dist/hmrouter_extension/constants/VersionConstants.d.ts

@@ -0,0 +1,6 @@
+export default class VersionConstants {
+    static readonly HMROUTER_ORGANIZATION = "@hadss";
+    static readonly HMROUTER_LIB_NAME = "hmrouter";
+    static readonly HMROUTER_VERSION_KEY = "version";
+    static readonly HMROUTER_VERSION_V1 = "1.0.0";
+}

package/dist/hmrouter_extension/constants/VersionConstants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class VersionConstants {
+}
+exports.default = VersionConstants;
+VersionConstants.HMROUTER_ORGANIZATION = '@hadss';
+VersionConstants.HMROUTER_LIB_NAME = 'hmrouter';
+VersionConstants.HMROUTER_VERSION_KEY = 'version';
+VersionConstants.HMROUTER_VERSION_V1 = '1.0.0';

package/dist/hmrouter_extension/constants/index.d.ts

@@ -0,0 +1,8 @@
+export { default as AnnotationConstants } from './AnnotationConstants';
+export { default as PrefixConstants } from './PrefixConstants';
+export { default as FilePathConstants } from './FilePathConstants';
+export { default as TemplateConstants } from './TemplateConstants';
+export { default as RouterMapConstants } from './RouterMapConstants';
+export { default as PluginConstants } from './PluginConstants';
+export { default as ObfuscationConstants } from './ObfuscationConstants';
+export { default as VersionConstants } from './VersionConstants';

package/dist/hmrouter_extension/constants/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionConstants = exports.ObfuscationConstants = exports.PluginConstants = exports.RouterMapConstants = exports.TemplateConstants = exports.FilePathConstants = exports.PrefixConstants = exports.AnnotationConstants = void 0;
+var AnnotationConstants_1 = require("./AnnotationConstants");
+Object.defineProperty(exports, "AnnotationConstants", { enumerable: true, get: function () { return __importDefault(AnnotationConstants_1).default; } });
+var PrefixConstants_1 = require("./PrefixConstants");
+Object.defineProperty(exports, "PrefixConstants", { enumerable: true, get: function () { return __importDefault(PrefixConstants_1).default; } });
+var FilePathConstants_1 = require("./FilePathConstants");
+Object.defineProperty(exports, "FilePathConstants", { enumerable: true, get: function () { return __importDefault(FilePathConstants_1).default; } });
+var TemplateConstants_1 = require("./TemplateConstants");
+Object.defineProperty(exports, "TemplateConstants", { enumerable: true, get: function () { return __importDefault(TemplateConstants_1).default; } });
+var RouterMapConstants_1 = require("./RouterMapConstants");
+Object.defineProperty(exports, "RouterMapConstants", { enumerable: true, get: function () { return __importDefault(RouterMapConstants_1).default; } });
+var PluginConstants_1 = require("./PluginConstants");
+Object.defineProperty(exports, "PluginConstants", { enumerable: true, get: function () { return __importDefault(PluginConstants_1).default; } });
+var ObfuscationConstants_1 = require("./ObfuscationConstants");
+Object.defineProperty(exports, "ObfuscationConstants", { enumerable: true, get: function () { return __importDefault(ObfuscationConstants_1).default; } });
+var VersionConstants_1 = require("./VersionConstants");
+Object.defineProperty(exports, "VersionConstants", { enumerable: true, get: function () { return __importDefault(VersionConstants_1).default; } });