@moluoxixi/create-app 2.0.408 → 2.0.410

package/dist/test.js

@@ -14,18 +14,58 @@ import fs from 'fs-extra';
 import { FILE_CONSTANTS } from "./constants/index.js";
 import { generateProject } from "./generators/index.js";
 import { featureToConfig, scanAllFeatures } from "./utils/featureMapping.js";
+import { getRouteModeFeatures } from "./utils/routeModeMapping.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /** 测试输出目录 */
 const TEST_OUTPUT_DIR = path.resolve(__dirname, '../test');
 /**
- * 解析命令行参数
+ * 测试配置
+ * 集中管理测试选项，方便随时调整
  */
-function parseArgs() {
-    const args = process.argv.slice(2);
-    const minimalOnly = args.includes('--minimal') || args.includes('--min') || args.includes('-m');
-    return { minimalOnly };
-}
+const TEST_CONFIG = {
+    /** 固定默认值（不参与组合测试） */
+    defaults: {
+        /** 项目名称（会自动生成，此处为描述） */
+        projectName: 'auto-generated',
+        /** 项目描述 */
+        description: 'A Vite project',
+        /** 作者 */
+        author: 'test',
+        /** 是否启用国际化 */
+        i18n: true,
+        /** 是否启用错误监控 */
+        sentry: false,
+        /** 是否启用 ESLint */
+        eslint: true,
+        /** 是否启用 Git Hooks */
+        husky: true,
+    },
+    /** 参与组合测试的选项 */
+    combinations: {
+        /** 框架列表（空数组表示不启用） */
+        frameworks: ['vue', 'react'],
+        /** UI 库配置（按框架分组，空数组表示不启用，需要明确配置才启用） */
+        uiLibraries: {
+            vue: ['element-plus', 'ant-design-vue'], // Vue 可用的 UI 库
+            react: ['ant-design'], // React 可用的 UI 库
+        },
+        /** 路由模式列表（空数组表示不启用） */
+        routeModes: ['manualRoutes', 'pageRoutes'],
+        /** 微前端引擎列表（空数组表示不启用） */
+        microFrontendEngines: ['qiankun'],
+        /** 包管理器列表（空数组表示不启用） */
+        packageManagers: ['pnpm'],
+        /** 是否测试 i18n 的组合 */
+        i18n: false,
+        /** 是否测试 sentry 的组合 */
+        sentry: false,
+        /** 是否测试 eslint 的组合 */
+        eslint: false,
+        /** 是否测试 husky 的组合 */
+        husky: false,
+    },
+};
 /**
  * 生成所有可能的组合（包括全开、全关）
  */
@@ -44,11 +84,16 @@ function generateAllCombinations(items) {
 }
 /**
  * 自动生成测试用例配置（基于组合算法）
- * @param minimalOnly 是否只生成全量和最小配置
  */
-function generateTestConfigs(minimalOnly = false) {
+function generateTestConfigs() {
     const configs = [];
-    const frameworks = ['vue', 'react'];
+    // 框架列表（空数组表示不启用）
+    const frameworks = TEST_CONFIG.combinations.frameworks.length > 0
+        ? TEST_CONFIG.combinations.frameworks
+        : [];
+    if (frameworks.length === 0) {
+        return configs;
+    }
     for (const framework of frameworks) {
         const allFeatures = scanAllFeatures(framework);
         // 分离不同类型的 features
@@ -71,74 +116,104 @@ function generateTestConfigs(minimalOnly = false) {
         }
         if (uiLibraries.length === 0)
             continue;
-        if (minimalOnly) {
-            // 只生成全量和最小配置：每个框架只选择一个 UI 库和一个路由模式
-            const uiLibrary = uiLibraries[0]; // 只选择第一个 UI 库
-            const routeModeFeature = routeModes.length > 0 ? routeModes[0] : 'manualRoutes'; // 只选择第一个路由模式
-            // 只生成全量和最小两种配置
-            const allFalse = Array.from({ length: booleanFeatures.length }, () => false);
-            const allTrue = Array.from({ length: booleanFeatures.length }, () => true);
-            const combinations = [allFalse, allTrue];
-            // 为每种包管理器生成测试用例
-            const packageManagers = ['pnpm', 'npm', 'yarn'];
-            for (const packageManager of packageManagers) {
-                for (const combination of combinations) {
-                    const config = {
-                        framework,
-                        uiLibrary: uiLibrary,
-                        routeMode: featureToConfig(routeModeFeature, framework).value,
-                        packageManager,
-                    };
-                    // 应用布尔 features 的组合
-                    for (let i = 0; i < booleanFeatures.length; i++) {
-                        const feature = booleanFeatures[i];
-                        const enabled = combination[i];
-                        const featureConfig = featureToConfig(feature, framework);
-                        if (featureConfig && featureConfig.key !== 'uiLibrary' && featureConfig.key !== 'routeMode') {
-                            config[featureConfig.key] = enabled;
-                        }
-                    }
-                    // 生成测试用例名称（包含包管理器）
-                    const suffix = combination.every(v => !v) ? 'minimal' : 'full';
-                    configs.push(createTestConfig(framework, uiLibrary, `${packageManager}-${suffix}`, config));
+        // 过滤掉不需要测试的布尔特性（根据 combinations 配置决定）
+        // 过滤掉根据框架自动选择的特性（pinia/zustand）
+        const autoSelectedFeatures = framework === 'vue' ? ['pinia'] : ['zustand'];
+        const filteredBooleanFeatures = booleanFeatures.filter((feature) => {
+            // 排除自动选择的特性
+            if (autoSelectedFeatures.includes(feature)) {
+                return false;
+            }
+            // 根据 combinations 配置决定是否参与组合测试
+            const featureConfig = featureToConfig(feature, framework);
+            if (featureConfig && featureConfig.key in TEST_CONFIG.combinations) {
+                const combinationValue = TEST_CONFIG.combinations[featureConfig.key];
+                // 如果是数组（frameworks, uiLibraries, routeModes, packageManagers），跳过
+                if (Array.isArray(combinationValue)) {
+                    return true;
                 }
+                // 其他布尔特性根据配置决定（i18n, sentry, eslint, husky）
+                // 使用 Boolean() 转换，避免类型检查问题
+                return Boolean(combinationValue);
             }
+            // 默认参与组合测试
+            return true;
+        });
+        // 生成所有组合
+        // UI 库列表（按框架分组配置，空数组表示不启用）
+        const frameworkUiLibraries = TEST_CONFIG.combinations.uiLibraries[framework] || [];
+        // 如果配置为空数组，表示不启用该框架的 UI 库测试
+        if (frameworkUiLibraries.length === 0) {
+            continue;
         }
-        else {
-            // 生成所有组合
-            for (const uiLibrary of uiLibraries) {
-                // 为每个路由模式生成测试用例
-                const routeModesToTest = routeModes.length > 0 ? routeModes : ['manualRoutes']; // 默认
-                for (const routeModeFeature of routeModesToTest) {
+        // 只测试配置中指定的 UI 库
+        const uiLibrariesToTest = uiLibraries.filter(uiLib => frameworkUiLibraries.includes(uiLib));
+        if (uiLibrariesToTest.length === 0) {
+            continue;
+        }
+        for (const uiLibrary of uiLibrariesToTest) {
+            // 路由模式列表（空数组表示不启用，使用默认值）
+            const routeModesToTest = TEST_CONFIG.combinations.routeModes.length > 0
+                ? routeModes.filter(routeMode => TEST_CONFIG.combinations.routeModes.includes(routeMode))
+                : (routeModes.length > 0 ? routeModes : ['manualRoutes']); // 默认
+            if (routeModesToTest.length === 0) {
+                continue;
+            }
+            for (const routeModeFeature of routeModesToTest) {
+                // 微前端引擎列表（空数组表示不启用）
+                const microFrontendEnginesToTest = TEST_CONFIG.combinations.microFrontendEngines;
+                // 如果配置了微前端引擎，生成两种组合：不带微前端（null）和带微前端（配置的引擎）
+                // 如果没配置，只生成不带微前端的组合
+                const microFrontendOptions = microFrontendEnginesToTest.length > 0
+                    ? [null, ...microFrontendEnginesToTest] // 总是包含 null（不带），再加上配置的引擎
+                    : [null]; // 如果没配置，只生成不带微前端的
+                for (const microFrontendEngine of microFrontendOptions) {
                     // 生成所有布尔 features 的组合（2^n 种）
-                    const combinations = generateAllCombinations(booleanFeatures);
-                    // 为每种包管理器生成测试用例
-                    const packageManagers = ['pnpm', 'npm', 'yarn'];
-                    for (const packageManager of packageManagers) {
+                    const combinations = generateAllCombinations(filteredBooleanFeatures);
+                    // 包管理器列表（空数组表示不启用）
+                    const packageManagersToTest = TEST_CONFIG.combinations.packageManagers;
+                    if (packageManagersToTest.length === 0) {
+                        continue;
+                    }
+                    for (const packageManager of packageManagersToTest) {
                         for (const combination of combinations) {
                             const config = {
                                 framework,
                                 uiLibrary: uiLibrary,
                                 routeMode: featureToConfig(routeModeFeature, framework).value,
                                 packageManager,
+                                microFrontend: microFrontendEngine !== null,
+                                microFrontendEngine: microFrontendEngine || undefined,
                             };
+                            // 根据 routeMode 设置对应的布尔 feature
+                            const routeModeFeatures = getRouteModeFeatures(routeModeFeature);
+                            config.manualRoutes = routeModeFeatures.manualRoutes;
+                            config.pageRoutes = routeModeFeatures.pageRoutes;
                             // 应用布尔 features 的组合
-                            for (let i = 0; i < booleanFeatures.length; i++) {
-                                const feature = booleanFeatures[i];
+                            for (let i = 0; i < filteredBooleanFeatures.length; i++) {
+                                const feature = filteredBooleanFeatures[i];
                                 const enabled = combination[i];
                                 const featureConfig = featureToConfig(feature, framework);
                                 if (featureConfig && featureConfig.key !== 'uiLibrary' && featureConfig.key !== 'routeMode') {
                                     config[featureConfig.key] = enabled;
                                 }
                             }
-                            // 生成测试用例名称（包含包管理器）
-                            const enabledFeatures = booleanFeatures.filter((_, i) => combination[i]);
-                            const suffix = enabledFeatures.length === 0
-                                ? 'minimal'
-                                : enabledFeatures.length === booleanFeatures.length
-                                    ? 'full'
-                                    : enabledFeatures.join('-');
-                            configs.push(createTestConfig(framework, uiLibrary, `${packageManager}-${routeModeFeature}-${suffix}`, config));
+                            // 生成测试用例名称
+                            // 如果没有布尔特性组合，使用固定后缀
+                            const suffix = filteredBooleanFeatures.length === 0
+                                ? 'default'
+                                : (() => {
+                                    const enabledFeatures = filteredBooleanFeatures.filter((_, i) => combination[i]);
+                                    return enabledFeatures.length === 0
+                                        ? 'minimal'
+                                        : enabledFeatures.length === filteredBooleanFeatures.length
+                                            ? 'full'
+                                            : enabledFeatures.join('-');
+                                })();
+                            // 生成测试用例名称
+                            const packageManagerSuffix = TEST_CONFIG.combinations.packageManagers.length > 1 ? `${packageManager}-` : '';
+                            const microFrontendSuffix = microFrontendEngine ? `${microFrontendEngine}-` : '';
+                            configs.push(createTestConfig(framework, uiLibrary, `${packageManagerSuffix}${microFrontendSuffix}${routeModeFeature}-${suffix}`, config));
                         }
                     }
                 }
@@ -160,23 +235,28 @@ function createTestConfig(framework, uiLibrary, suffix, overrides) {
     return {
         name,
         config: {
+            // 固定默认值，不参与组合测试
             projectName: name,
-            description: `${framework === 'vue' ? 'Vue' : 'React'} + ${uiLibrary} ${suffix}`,
-            author: 'test',
+            description: TEST_CONFIG.defaults.description,
+            author: TEST_CONFIG.defaults.author,
+            // 固定默认值，不参与组合测试（避免几何级增长）
+            i18n: TEST_CONFIG.defaults.i18n,
+            sentry: TEST_CONFIG.defaults.sentry,
+            eslint: TEST_CONFIG.defaults.eslint,
+            husky: TEST_CONFIG.defaults.husky,
+            packageManager: TEST_CONFIG.combinations.packageManagers[0],
             ...overrides,
         },
     };
 }
 /**
  * 生成测试项目
- * @param minimalOnly 是否只生成全量和最小配置
  * @returns Promise<void>
  */
-async function generateTestProjects(minimalOnly = false) {
-    const mode = minimalOnly ? '（仅全量和最小配置）' : '（全部组合）';
-    console.log(chalk.blue.bold(`\n🧪 开始生成测试项目${mode}...\n`));
+async function generateTestProjects() {
+    console.log(chalk.blue.bold('\n🧪 开始生成测试项目...\n'));
     // 扫描并生成测试配置
-    const TEST_CONFIGS = generateTestConfigs(minimalOnly);
+    const TEST_CONFIGS = generateTestConfigs();
     console.log(chalk.cyan(`📋 扫描到 ${TEST_CONFIGS.length} 个测试用例\n`));
     // 清理并创建测试目录
     if (fs.existsSync(TEST_OUTPUT_DIR)) {
@@ -193,20 +273,26 @@ async function generateTestProjects(minimalOnly = false) {
         // 根据框架决定输出目录
         const frameworkOutputDir = config.framework === 'vue' ? vueOutputDir : reactOutputDir;
         const fullConfig = {
-            projectName: config.projectName,
-            description: config.description,
-            author: config.author,
+            // 固定默认值（不参与组合测试）
+            projectName: config.projectName || name,
+            description: config.description || TEST_CONFIG.defaults.description,
+            author: config.author || TEST_CONFIG.defaults.author,
             framework: config.framework,
             uiLibrary: config.uiLibrary,
             routeMode: config.routeMode,
-            router: config.router ?? true,
-            stateManagement: config.stateManagement ?? true,
-            i18n: config.i18n,
-            qiankun: config.qiankun,
-            sentry: config.sentry,
-            eslint: config.eslint,
-            gitHooks: config.gitHooks,
-            packageManager: config.packageManager,
+            // feature 名称与目录名称一致
+            pinia: config.framework === 'vue',
+            zustand: config.framework === 'react',
+            ...getRouteModeFeatures(config.routeMode),
+            // 固定默认值（不参与组合测试，避免几何级增长）
+            i18n: config.i18n ?? TEST_CONFIG.defaults.i18n,
+            sentry: config.sentry ?? TEST_CONFIG.defaults.sentry,
+            eslint: config.eslint ?? TEST_CONFIG.defaults.eslint,
+            husky: config.husky ?? TEST_CONFIG.defaults.husky,
+            // 参与组合测试的特性
+            microFrontend: config.microFrontend ?? false,
+            microFrontendEngine: config.microFrontendEngine,
+            packageManager: config.packageManager ?? TEST_CONFIG.combinations.packageManagers[0],
             targetDir: path.join(frameworkOutputDir, name),
         };
         try {
@@ -257,11 +343,10 @@ function checkPackageJsonVersions(projectDir) {
 }
 /**
  * 审计 @moluoxixi 依赖
- * @param minimalOnly 是否只生成全量和最小配置
  */
-async function auditMoluoxixiDeps(minimalOnly = false) {
+async function auditMoluoxixiDeps() {
     console.log(chalk.blue.bold('\n🔍 开始审计 @moluoxixi 依赖...\n'));
-    const TEST_CONFIGS = generateTestConfigs(minimalOnly);
+    const TEST_CONFIGS = generateTestConfigs();
     const requiredDeps = [
         '@moluoxixi/vite-config',
         '@moluoxixi/ajax-package',
@@ -312,7 +397,7 @@ async function auditMoluoxixiDeps(minimalOnly = false) {
                 console.log(chalk.green(`  ✅ eslint.config.ts 已正确移除`));
             }
         }
-        if (!config.gitHooks) {
+        if (!config.husky) {
             const huskyDir = path.join(projectDir, '.husky');
             if (fs.existsSync(huskyDir)) {
                 console.log(chalk.red(`  ❌ 不应存在 .husky/ 目录（Git Hooks 已禁用）`));
@@ -400,17 +485,13 @@ async function printFileTree(dir, indent) {
  * @returns Promise<void>
  */
 async function main() {
-    const { minimalOnly } = parseArgs();
     console.log(chalk.blue.bold(`\n${'='.repeat(60)}`));
     console.log(chalk.blue.bold('  Vite CLI Next - 产物审计测试'));
-    if (minimalOnly) {
-        console.log(chalk.yellow.bold('  模式: 仅全量和最小配置'));
-    }
     console.log(chalk.blue.bold('='.repeat(60)));
     // 1. 生成测试项目
-    await generateTestProjects(minimalOnly);
+    await generateTestProjects();
     // 2. 审计 @moluoxixi 依赖
-    await auditMoluoxixiDeps(minimalOnly);
+    await auditMoluoxixiDeps();
     // 3. 显示文件树
     await showFileTrees();
     console.log(chalk.green.bold('\n✅ 全量产物审计完成!\n'));

package/dist/types/features.d.ts

@@ -1,6 +1,9 @@
 /**
  * 特性配置定义
- * 定义所有可用特性的 ID
+ * 核心依赖和微前端引擎类型定义
+ *
+ * 注意：Features 现在通过文件系统扫描自动发现，无需在此维护常量列表
+ * 参考：src/utils/renderFeatures.ts
  */
 /**
  * @moluoxixi 核心依赖配置
@@ -14,12 +17,7 @@ export declare const MOLUOXIXI_DEPS: {
     readonly '@moluoxixi/css-module-global-root-plugin': "latest";
 };
 /**
- * Vue 特性 ID
+ * 微前端引擎类型
  */
-export declare const VUE_FEATURES: readonly ["router", "pinia", "eslint", "i18n", "sentry", "qiankun", "pageRoutes", "element-plus", "ant-design-vue"];
-/**
- * React 特性 ID
- */
-export declare const REACT_FEATURES: readonly ["router", "zustand", "eslint", "i18n", "sentry", "qiankun", "ant-design"];
-export type VueFeatureId = typeof VUE_FEATURES[number];
-export type ReactFeatureId = typeof REACT_FEATURES[number];
+export declare const MICRO_FRONTEND_ENGINES: readonly ["qiankun", "micro-app"];
+export type MicroFrontendEngine = typeof MICRO_FRONTEND_ENGINES[number];

package/dist/types/features.js

@@ -1,6 +1,9 @@
 /**
  * 特性配置定义
- * 定义所有可用特性的 ID
+ * 核心依赖和微前端引擎类型定义
+ *
+ * 注意：Features 现在通过文件系统扫描自动发现，无需在此维护常量列表
+ * 参考：src/utils/renderFeatures.ts
  */
 /**
  * @moluoxixi 核心依赖配置
@@ -14,28 +17,6 @@ export const MOLUOXIXI_DEPS = {
     '@moluoxixi/css-module-global-root-plugin': 'latest',
 };
 /**
- * Vue 特性 ID
+ * 微前端引擎类型
  */
-export const VUE_FEATURES = [
-    'router',
-    'pinia',
-    'eslint',
-    'i18n',
-    'sentry',
-    'qiankun',
-    'pageRoutes',
-    'element-plus',
-    'ant-design-vue',
-];
-/**
- * React 特性 ID
- */
-export const REACT_FEATURES = [
-    'router',
-    'zustand',
-    'eslint',
-    'i18n',
-    'sentry',
-    'qiankun',
-    'ant-design',
-];
+export const MICRO_FRONTEND_ENGINES = ['qiankun', 'micro-app'];

package/dist/types/index.d.ts

@@ -2,6 +2,7 @@
  * CLI 类型定义
  * 定义项目配置、模板层级等核心类型
  */
+import type { MicroFrontendEngine } from './features.ts';
 export * from './ejs.ts';
 export * from './features.ts';
 /**
@@ -15,7 +16,7 @@ export type UILibraryType = 'element-plus' | 'ant-design-vue' | 'ant-design';
 /**
  * 路由模式类型
  */
-export type RouteModeType = 'file-system' | 'manual';
+export type RouteModeType = 'manualRoutes' | 'pageRoutes';
 /**
  * 包管理器类型
  */
@@ -32,24 +33,30 @@ export interface ProjectConfigType {
     author: string;
     /** 框架类型 */
     framework: FrameworkType;
-    /** UI 库 */
+    /** UI 库（feature 名称：element-plus | ant-design-vue | ant-design） */
     uiLibrary: UILibraryType;
-    /** 路由模式 */
+    /** 路由模式（决定使用 manualRoutes 还是 pageRoutes feature） */
     routeMode: RouteModeType;
-    /** 是否启用路由 */
-    router: boolean;
-    /** 是否启用状态管理 (Vue: pinia, React: zustand) */
-    stateManagement: boolean;
-    /** 是否启用国际化 */
+    /** 是否启用 pinia/zustand feature */
+    pinia?: boolean;
+    /** 是否启用 zustand feature (React) */
+    zustand?: boolean;
+    /** 是否启用 manualRoutes feature */
+    manualRoutes?: boolean;
+    /** 是否启用 pageRoutes feature */
+    pageRoutes?: boolean;
+    /** 是否启用 i18n feature */
     i18n: boolean;
     /** 是否启用微前端支持 */
-    qiankun: boolean;
-    /** 是否启用错误监控 */
+    microFrontend: boolean;
+    /** 微前端引擎（qiankun、micro-app 等）- 当 microFrontend 为 true 时有效 */
+    microFrontendEngine?: MicroFrontendEngine;
+    /** 是否启用 sentry feature */
     sentry: boolean;
-    /** 是否启用 ESLint */
+    /** 是否启用 eslint feature */
     eslint: boolean;
-    /** 是否启用 Git Hooks (husky + commitlint + lint-staged) */
-    gitHooks: boolean;
+    /** 是否启用 husky feature (Git Hooks) */
+    husky: boolean;
     /** 包管理器 */
     packageManager: PackageManagerType;
     /** 目标目录 */

package/dist/utils/featureMapping.d.ts

@@ -1,6 +1,7 @@
 /**
  * Features 映射工具
- * 统一管理配置项到 feature 目录的映射关系
+ * 用于测试用例生成和 feature 扫描
+ * 注意：配置名称与 feature 目录名称完全一致，无需额外映射
  */
 import type { FrameworkType } from '../types/index.ts';
 /**
@@ -9,36 +10,14 @@ import type { FrameworkType } from '../types/index.ts';
  * @returns 所有 feature 名称数组（UI 库按优先级排序）
  */
 export declare function scanAllFeatures(framework: FrameworkType): string[];
-/**
- * 配置项到 feature 目录的映射（从 renderFeatures 提取）
- * @param _framework 框架类型（已不再使用，保留以保持接口兼容性）
- * @returns 配置键到 feature 名称的映射对象
- */
-export declare function getConfigToFeatureMap(_framework: FrameworkType): Record<string, string>;
-/**
- * 公共 features 映射
- * @returns 公共配置键到 feature 名称的映射对象
- */
-export declare function getCommonFeatureMap(): Record<string, string>;
-/**
- * 路由模式映射
- * @param routeMode 路由模式（'manual' 或 'file-system'）
- * @returns feature 名称
- */
-export declare function getRouteModeFeature(routeMode: string): string;
-/**
- * UI 库映射
- * @param uiLibrary UI 库名称
- * @returns feature 名称（通常与 UI 库名称相同）
- */
-export declare function getUILibraryFeature(uiLibrary: string): string;
 /**
  * Feature 名称转换为配置键和值（用于测试用例生成）
+ * 注意：大部分情况下 feature 名称 === 配置名称
  * @param feature feature 名称
- * @param framework 框架类型
+ * @param _framework 框架类型（保留参数以保持接口兼容性）
  * @returns 配置键值对，如果无法映射则返回 null
  */
-export declare function featureToConfig(feature: string, framework: FrameworkType): {
+export declare function featureToConfig(feature: string, _framework: FrameworkType): {
     key: string;
     value: string | boolean;
 } | null;

package/dist/utils/featureMapping.js

@@ -1,6 +1,7 @@
 /**
  * Features 映射工具
- * 统一管理配置项到 feature 目录的映射关系
+ * 用于测试用例生成和 feature 扫描
+ * 注意：配置名称与 feature 目录名称完全一致，无需额外映射
  */
 import fs from 'fs-extra';
 import path from 'node:path';
@@ -39,79 +40,34 @@ export function scanAllFeatures(framework) {
         return a.localeCompare(b);
     });
 }
-/**
- * 配置项到 feature 目录的映射（从 renderFeatures 提取）
- * @param _framework 框架类型（已不再使用，保留以保持接口兼容性）
- * @returns 配置键到 feature 名称的映射对象
- */
-export function getConfigToFeatureMap(_framework) {
-    return {
-        // router、stateManagement、qiankun 已内置到 base，不再作为 feature
-        eslint: 'eslint',
-        i18n: 'i18n',
-        sentry: 'sentry',
-    };
-}
-/**
- * 公共 features 映射
- * @returns 公共配置键到 feature 名称的映射对象
- */
-export function getCommonFeatureMap() {
-    return {
-        gitHooks: 'husky',
-    };
-}
-/**
- * 路由模式映射
- * @param routeMode 路由模式（'manual' 或 'file-system'）
- * @returns feature 名称
- */
-export function getRouteModeFeature(routeMode) {
-    return routeMode === 'manual' ? 'manualRoutes' : 'pageRoutes';
-}
-/**
- * UI 库映射
- * @param uiLibrary UI 库名称
- * @returns feature 名称（通常与 UI 库名称相同）
- */
-export function getUILibraryFeature(uiLibrary) {
-    return uiLibrary;
-}
 /**
  * Feature 名称转换为配置键和值（用于测试用例生成）
+ * 注意：大部分情况下 feature 名称 === 配置名称
  * @param feature feature 名称
- * @param framework 框架类型
+ * @param _framework 框架类型（保留参数以保持接口兼容性）
  * @returns 配置键值对，如果无法映射则返回 null
  */
-export function featureToConfig(feature, framework) {
-    // 路由模式
-    if (feature === 'manualRoutes')
-        return { key: 'routeMode', value: 'manual' };
-    if (feature === 'pageRoutes')
-        return { key: 'routeMode', value: 'file-system' };
-    // UI 库
+export function featureToConfig(feature, _framework) {
+    // UI 库：配置键是 uiLibrary，值是 feature 名称
     const uiLibraries = ['element-plus', 'ant-design-vue', 'ant-design'];
-    if (uiLibraries.includes(feature))
+    if (uiLibraries.includes(feature)) {
         return { key: 'uiLibrary', value: feature };
-    // 状态管理（反向映射）
-    const stateManagementMap = {
-        pinia: 'stateManagement',
-        zustand: 'stateManagement',
-    };
-    if (stateManagementMap[feature])
-        return { key: stateManagementMap[feature], value: true };
-    // Git Hooks（公共 feature）
-    if (feature === 'husky')
-        return { key: 'gitHooks', value: true };
-    // 其他布尔 features（通过映射查找）
-    const configMap = getConfigToFeatureMap(framework);
-    const configKey = Object.keys(configMap).find(key => configMap[key] === feature);
-    if (configKey)
-        return { key: configKey, value: true };
-    // 公共 features
-    const commonMap = getCommonFeatureMap();
-    const commonKey = Object.keys(commonMap).find(key => commonMap[key] === feature);
-    if (commonKey)
-        return { key: commonKey, value: true };
+    }
+    // 路由模式 features：用于测试分类
+    if (feature === 'manualRoutes' || feature === 'pageRoutes') {
+        return { key: 'routeMode', value: feature };
+    }
+    // 布尔类型的 features：配置名 === feature 名
+    const booleanFeatures = [
+        'eslint',
+        'i18n',
+        'sentry',
+        'pinia',
+        'zustand',
+        'husky',
+    ];
+    if (booleanFeatures.includes(feature)) {
+        return { key: feature, value: true };
+    }
     return null;
 }