@moluoxixi/create-app 2.0.436 → 2.0.437

package/dist/test.js

@@ -1,508 +0,0 @@
-/**
- * 测试脚本
- * 通过文件系统扫描自动生成所有测试用例组合
- */
-import path from 'node:path';
-import process from 'node:process';
-import { fileURLToPath } from 'node:url';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import { FILE_CONSTANTS, FRAMEWORKS, MICRO_FRONTEND_ENGINES, PACKAGE_MANAGERS, ROUTE_MODES, UI_LIBRARIES, } from "./constants/index.js";
-import { featureToConfig, getRouteModeFeatures, scanAllFeatures } from "./core/feature.js";
-import { generateProject } from "./generators/index.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/** 测试输出目录 */
-const TEST_OUTPUT_DIR = path.resolve(__dirname, '../test');
-/**
- * 测试配置
- * 集中管理测试选项，方便随时调整
- */
-const TEST_CONFIG = {
-    /** 是否使用 minimal 模式（只生成全量和最小配置） */
-    minimal: false,
-    /** 固定默认值（不参与组合测试） */
-    defaults: {
-        /** 项目名称（会自动生成，此处为描述） */
-        projectName: 'auto-generated',
-        /** 项目描述 */
-        description: 'A Vite project',
-        /** 作者 */
-        author: 'test',
-        /** 是否启用国际化 */
-        i18n: true,
-        /** 是否启用错误监控 */
-        sentry: false,
-        /** 是否启用 ESLint */
-        eslint: true,
-        /** 是否启用 Git Hooks */
-        husky: true,
-    },
-    /** 参与组合测试的选项 */
-    combinations: {
-        /** 框架列表（使用常量） */
-        frameworks: FRAMEWORKS,
-        /** UI 库配置（直接使用 UI_LIBRARIES） */
-        uiLibraries: {
-            vue: UI_LIBRARIES.vue,
-            react: UI_LIBRARIES.react,
-        },
-        /** 路由模式列表（空数组表示不启用） */
-        routeModes: ROUTE_MODES,
-        /** 微前端引擎列表（直接使用常量） */
-        microFrontendEngines: MICRO_FRONTEND_ENGINES,
-        /** 包管理器列表（直接使用常量） */
-        packageManagers: PACKAGE_MANAGERS,
-        /** 是否测试 i18n 的组合 */
-        i18n: false,
-        /** 是否测试 sentry 的组合 */
-        sentry: false,
-        /** 是否测试 eslint 的组合 */
-        eslint: false,
-        /** 是否测试 husky 的组合 */
-        husky: false,
-    },
-};
-/**
- * 生成所有可能的组合（包括全开、全关）
- */
-function generateAllCombinations(items) {
-    const n = items.length;
-    const combinations = [];
-    // 生成 2^n 种组合
-    for (let i = 0; i < 2 ** n; i++) {
-        const combination = [];
-        for (let j = 0; j < n; j++) {
-            combination.push((i & (1 << j)) !== 0);
-        }
-        combinations.push(combination);
-    }
-    return combinations;
-}
-/**
- * 自动生成测试用例配置（基于组合算法）
- */
-function generateTestConfigs() {
-    const configs = [];
-    // 框架列表（空数组表示不启用）
-    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
-        const uiLibraries = [];
-        const routeModes = [];
-        const booleanFeatures = [];
-        for (const feature of allFeatures) {
-            const config = featureToConfig(feature, framework);
-            if (!config)
-                continue;
-            if (config.key === 'uiLibrary') {
-                uiLibraries.push(feature);
-            }
-            else if (config.key === 'routeMode') {
-                routeModes.push(feature);
-            }
-            else {
-                booleanFeatures.push(feature);
-            }
-        }
-        if (uiLibraries.length === 0)
-            continue;
-        // 过滤掉不需要测试的布尔特性（根据 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;
-        }
-        // 只测试配置中指定的 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) {
-                    // 生成所有布尔特性的组合（2^n 种）
-                    const combinations = generateAllCombinations(filteredBooleanFeatures);
-                    // 包管理器列表（空数组表示不启用）
-                    const packageManagersToTest = TEST_CONFIG.combinations.packageManagers;
-                    if (packageManagersToTest.length === 0) {
-                        continue;
-                    }
-                    for (const packageManager of packageManagersToTest) {
-                        // 如果启用 minimal 模式，只生成全开和全关两种组合
-                        const combinationsToTest = TEST_CONFIG.minimal && filteredBooleanFeatures.length > 0
-                            ? [
-                                // 全关（minimal）
-                                Array.from({ length: filteredBooleanFeatures.length }).fill(false),
-                                // 全开（full）
-                                Array.from({ length: filteredBooleanFeatures.length }).fill(true),
-                            ]
-                            : combinations;
-                        for (const combination of combinationsToTest) {
-                            const config = {
-                                framework,
-                                uiLibrary: uiLibrary,
-                                routeMode: featureToConfig(routeModeFeature, framework).value,
-                                packageManager,
-                                microFrontend: microFrontendEngine !== null,
-                                microFrontendEngine: microFrontendEngine || undefined,
-                            };
-                            // 根据路由模式设置对应的布尔特性
-                            const routeModeFeatures = getRouteModeFeatures(routeModeFeature);
-                            config.manualRoutes = routeModeFeatures.manualRoutes;
-                            config.pageRoutes = routeModeFeatures.pageRoutes;
-                            // 应用布尔特性的组合
-                            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 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));
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return configs;
-}
-/**
- * 创建测试配置的辅助函数
- * @param framework 框架类型
- * @param uiLibrary UI 库名称
- * @param suffix 后缀名称
- * @param overrides 配置覆盖项
- * @returns 测试配置对象
- */
-function createTestConfig(framework, uiLibrary, suffix, overrides) {
-    const name = `${framework}-${uiLibrary}-${suffix}`;
-    return {
-        name,
-        config: {
-            // 固定默认值，不参与组合测试
-            projectName: name,
-            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,
-        },
-    };
-}
-/**
- * 生成测试项目
- * @returns Promise<void>
- */
-async function generateTestProjects() {
-    console.log(chalk.blue.bold('\n🧪 开始生成测试项目...\n'));
-    // 扫描并生成测试配置
-    const TEST_CONFIGS = generateTestConfigs();
-    console.log(chalk.cyan(`📋 扫描到 ${TEST_CONFIGS.length} 个测试用例\n`));
-    // 清理并创建测试目录
-    if (fs.existsSync(TEST_OUTPUT_DIR)) {
-        fs.removeSync(TEST_OUTPUT_DIR);
-    }
-    fs.ensureDirSync(TEST_OUTPUT_DIR);
-    // 创建 Vue 和 React 子目录
-    const vueOutputDir = path.join(TEST_OUTPUT_DIR, 'vue');
-    const reactOutputDir = path.join(TEST_OUTPUT_DIR, 'react');
-    fs.ensureDirSync(vueOutputDir);
-    fs.ensureDirSync(reactOutputDir);
-    for (const { name, config } of TEST_CONFIGS) {
-        console.log(chalk.cyan(`📦 生成 ${name}...`));
-        // 根据框架决定输出目录
-        const frameworkOutputDir = config.framework === 'vue' ? vueOutputDir : reactOutputDir;
-        const fullConfig = {
-            // 固定默认值（不参与组合测试）
-            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,
-            // 特性名称与目录名称一致
-            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 {
-            await generateProject(fullConfig);
-            console.log(chalk.green(`  ✅ ${name} 生成成功`));
-        }
-        catch (error) {
-            console.log(chalk.red(`  ❌ ${name} 生成失败:`), error);
-        }
-    }
-    console.log(chalk.green.bold('\n✅ 测试项目生成完成!\n'));
-}
-/**
- * 检查 package.json 中是否有 catalog 引用（应该已经全部替换为实际版本号）
- * @param projectDir 项目目录路径
- * @returns 检查是否通过（true 表示通过，false 表示失败）
- */
-function checkPackageJsonVersions(projectDir) {
-    const packageJsonPath = path.join(projectDir, FILE_CONSTANTS.PACKAGE_JSON);
-    if (!fs.existsSync(packageJsonPath)) {
-        console.log(chalk.red(`  ❌ package.json 不存在`));
-        return false;
-    }
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-    let hasError = false;
-    // 检查 dependencies 中是否还有 catalog 引用
-    if (packageJson.dependencies) {
-        for (const [dep, version] of Object.entries(packageJson.dependencies)) {
-            if (typeof version === 'string' && version.startsWith('catalog:')) {
-                console.log(chalk.red(`  ❌ dependencies.${dep}: "${version}" 应该使用实际版本号`));
-                hasError = true;
-            }
-        }
-    }
-    // 检查 devDependencies 中是否还有 catalog 引用
-    if (packageJson.devDependencies) {
-        for (const [dep, version] of Object.entries(packageJson.devDependencies)) {
-            if (typeof version === 'string' && version.startsWith('catalog:')) {
-                console.log(chalk.red(`  ❌ devDependencies.${dep}: "${version}" 应该使用实际版本号`));
-                hasError = true;
-            }
-        }
-    }
-    if (!hasError) {
-        console.log(chalk.green(`  ✅ package.json 版本号检查通过（无 catalog 引用）`));
-    }
-    return !hasError;
-}
-/**
- * 审计 @moluoxixi 依赖
- */
-async function auditMoluoxixiDeps() {
-    console.log(chalk.blue.bold('\n🔍 开始审计 @moluoxixi 依赖...\n'));
-    const TEST_CONFIGS = generateTestConfigs();
-    const requiredDeps = [
-        '@moluoxixi/vite-config',
-        '@moluoxixi/ajax-package',
-    ];
-    let hasError = false;
-    for (const { name, config } of TEST_CONFIGS) {
-        // 根据框架决定输出目录
-        const frameworkOutputDir = config.framework === 'vue'
-            ? path.join(TEST_OUTPUT_DIR, 'vue')
-            : path.join(TEST_OUTPUT_DIR, 'react');
-        const projectDir = path.join(frameworkOutputDir, name);
-        const packageJsonPath = path.join(projectDir, FILE_CONSTANTS.PACKAGE_JSON);
-        console.log(chalk.cyan(`📋 检查 ${name}...`));
-        // 根据配置决定需要检查的依赖
-        const depsToCheck = [...requiredDeps];
-        if (config.eslint) {
-            depsToCheck.push('@moluoxixi/eslint-config');
-        }
-        // 检查 package.json
-        if (fs.existsSync(packageJsonPath)) {
-            const packageJson = fs.readJsonSync(packageJsonPath);
-            const allDeps = {
-                ...packageJson.dependencies,
-                ...packageJson.devDependencies,
-            };
-            for (const dep of depsToCheck) {
-                if (!allDeps[dep]) {
-                    console.log(chalk.red(`  ❌ package.json 缺少 ${dep}`));
-                    hasError = true;
-                }
-                else {
-                    console.log(chalk.green(`  ✅ package.json 包含 ${dep}`));
-                }
-            }
-        }
-        else {
-            console.log(chalk.red(`  ❌ package.json 不存在`));
-            hasError = true;
-        }
-        // 检查可选特性文件
-        if (!config.eslint) {
-            const eslintConfig = path.join(projectDir, 'eslint.config.ts');
-            if (fs.existsSync(eslintConfig)) {
-                console.log(chalk.red(`  ❌ 不应存在 eslint.config.ts（ESLint 已禁用）`));
-                hasError = true;
-            }
-            else {
-                console.log(chalk.green(`  ✅ eslint.config.ts 已正确移除`));
-            }
-        }
-        if (!config.husky) {
-            const huskyDir = path.join(projectDir, '.husky');
-            if (fs.existsSync(huskyDir)) {
-                console.log(chalk.red(`  ❌ 不应存在 .husky/ 目录（Git Hooks 已禁用）`));
-                hasError = true;
-            }
-            else {
-                console.log(chalk.green(`  ✅ .husky/ 目录已正确移除`));
-            }
-        }
-        // 检查 package.json 版本号（确保没有 catalog 引用）
-        console.log(chalk.cyan(`  🔍 检查 package.json 版本号...`));
-        const packageJsonOk = checkPackageJsonVersions(projectDir);
-        if (!packageJsonOk) {
-            hasError = true;
-        }
-        console.log('');
-    }
-    if (hasError) {
-        console.log(chalk.red.bold('\n❌ 审计失败: 存在问题\n'));
-        process.exit(1);
-    }
-    else {
-        console.log(chalk.green.bold('\n✅ 审计通过: 所有检查项均通过\n'));
-    }
-}
-/**
- * 显示文件树
- */
-async function showFileTrees() {
-    console.log(chalk.blue.bold('\n📂 项目文件树...\n'));
-    const vueOutputDir = path.join(TEST_OUTPUT_DIR, 'vue');
-    const reactOutputDir = path.join(TEST_OUTPUT_DIR, 'react');
-    // 显示 Vue 项目
-    if (fs.existsSync(vueOutputDir)) {
-        console.log(chalk.cyan.bold('\n📁 Vue 项目:\n'));
-        const vueProjects = fs.readdirSync(vueOutputDir).filter((item) => {
-            const itemPath = path.join(vueOutputDir, item);
-            return fs.statSync(itemPath).isDirectory();
-        });
-        for (const projectName of vueProjects) {
-            const projectDir = path.join(vueOutputDir, projectName);
-            console.log(chalk.cyan(`\n${projectName}/`));
-            await printFileTree(projectDir, '  ');
-        }
-    }
-    // 显示 React 项目
-    if (fs.existsSync(reactOutputDir)) {
-        console.log(chalk.cyan.bold('\n📁 React 项目:\n'));
-        const reactProjects = fs.readdirSync(reactOutputDir).filter((item) => {
-            const itemPath = path.join(reactOutputDir, item);
-            return fs.statSync(itemPath).isDirectory();
-        });
-        for (const projectName of reactProjects) {
-            const projectDir = path.join(reactOutputDir, projectName);
-            console.log(chalk.cyan(`\n${projectName}/`));
-            await printFileTree(projectDir, '  ');
-        }
-    }
-}
-/**
- * 打印文件树
- * @param dir 目录路径
- * @param indent 缩进字符串
- * @returns Promise<void>
- */
-async function printFileTree(dir, indent) {
-    const items = fs.readdirSync(dir).sort();
-    for (const item of items) {
-        if (item === FILE_CONSTANTS.NODE_MODULES)
-            continue;
-        const itemPath = path.join(dir, item);
-        const stat = fs.statSync(itemPath);
-        if (stat.isDirectory()) {
-            console.log(chalk.gray(`${indent}📁 ${item}/`));
-            await printFileTree(itemPath, `${indent}  `);
-        }
-        else {
-            console.log(chalk.gray(`${indent}📄 ${item}`));
-        }
-    }
-}
-/**
- * 主函数
- * 执行测试项目生成、依赖审计和文件树显示
- * @returns Promise<void>
- */
-async function main() {
-    console.log(chalk.blue.bold(`\n${'='.repeat(60)}`));
-    console.log(chalk.blue.bold('  Vite CLI Next - 产物审计测试'));
-    console.log(chalk.blue.bold('='.repeat(60)));
-    if (TEST_CONFIG.minimal) {
-        console.log(chalk.yellow('  ⚠️  运行在 minimal 模式（只生成全量和最小配置）\n'));
-    }
-    // 1. 生成测试项目
-    await generateTestProjects();
-    // 2. 审计 @moluoxixi 依赖
-    await auditMoluoxixiDeps();
-    // 3. 显示文件树
-    await showFileTrees();
-    console.log(chalk.green.bold('\n✅ 全量产物审计完成!\n'));
-}
-main().catch(console.error);

package/templates/common/base/src/utils/index.ts

@@ -1,87 +0,0 @@
-/**
- * 工具函数
- * 通用工具方法
- */
-
-/**
- * 延迟执行
- * @param ms 延迟毫秒数
- * @returns Promise，在指定时间后 resolve
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-/**
- * 深拷贝
- * @param obj 要拷贝的对象
- * @returns 深拷贝后的新对象
- */
-export function deepClone<T>(obj: T): T {
-  return JSON.parse(JSON.stringify(obj))
-}
-
-/**
- * 防抖函数
- * @param fn 要防抖的函数
- * @param delay 延迟时间（毫秒）
- * @returns 防抖后的函数
- */
-export function debounce<T extends (...args: unknown[]) => unknown>(
-  fn: T,
-  delay: number,
-): (...args: Parameters<T>) => void {
-  let timer: ReturnType<typeof setTimeout> | null = null
-  return function (this: unknown, ...args: Parameters<T>) {
-    if (timer) {
-      clearTimeout(timer)
-    }
-    timer = setTimeout(() => {
-      fn.apply(this, args)
-    }, delay)
-  }
-}
-
-/**
- * 节流函数
- * @param fn 要节流的函数
- * @param delay 间隔时间（毫秒）
- * @returns 节流后的函数
- */
-export function throttle<T extends (...args: unknown[]) => unknown>(
-  fn: T,
-  delay: number,
-): (...args: Parameters<T>) => void {
-  let lastTime = 0
-  return function (this: unknown, ...args: Parameters<T>) {
-    const now = Date.now()
-    if (now - lastTime >= delay) {
-      lastTime = now
-      fn.apply(this, args)
-    }
-  }
-}
-
-/**
- * 格式化日期
- * @param date 日期（Date 对象、时间戳或日期字符串）
- * @param format 格式字符串，默认为 'YYYY-MM-DD HH:mm:ss'
- * @returns 格式化后的日期字符串
- */
-export function formatDate(date: Date | string | number, format = 'YYYY-MM-DD HH:mm:ss'): string {
-  const d = new Date(date)
-  const year = d.getFullYear()
-  const month = String(d.getMonth() + 1).padStart(2, '0')
-  const day = String(d.getDate()).padStart(2, '0')
-  const hours = String(d.getHours()).padStart(2, '0')
-  const minutes = String(d.getMinutes()).padStart(2, '0')
-  const seconds = String(d.getSeconds()).padStart(2, '0')
-
-  return format
-    .replace('YYYY', String(year))
-    .replace('MM', month)
-    .replace('DD', day)
-    .replace('HH', hours)
-    .replace('mm', minutes)
-    .replace('ss', seconds)
-}