@apdesign/code-style-react 1.1.5 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apdesign/code-style-react",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "scripts": {},
   "bin": {
     "apdesign-code-style": "cli.js"

package/scripts/runEslint.js

@@ -1,66 +1,68 @@
 #!/usr/bin/env node
 
 let spawnSync;
-let spawn;
 let path;
 let fs;
 let os;
 let glob;
+let ESLint;
 
 async function runEslint() {
   try {
     if (typeof require !== 'undefined') {
       // CommonJS
-      ({ spawnSync, spawn } = require('child_process'));
+      spawnSync = require('child_process').spawnSync;
       path = require('path');
       fs = require('fs');
       os = require('os');
       glob = require('glob');
+      ESLint = require('eslint').ESLint;
     } else {
       // ESM
-      ({ spawnSync, spawn } = await import('node:child_process'));
+      spawnSync = await import('node:child_process').spawnSync;
       path = await import('node:path');
       fs = await import('node:fs');
       os = await import('node:os');
       glob = (await import('glob')).default;
+      ESLint = (await import('eslint')).ESLint;
     }
 
     // 参数解析
     const args = process.argv.slice(2);
 
-    // 默认并发数为 CPU 核心数，但不超过 8
-    let maxWorkers = Math.min(os.cpus().length, 8);
-
-    let branchArg = null;
-
-    // 找到 --max-workers 参数
+    let maxWorkers = null; // 默认由 ESLint API 决定
     const maxWorkersArgIndex = args.indexOf('--max-workers');
     if (maxWorkersArgIndex !== -1 && args[maxWorkersArgIndex + 1]) {
       const val = parseInt(args[maxWorkersArgIndex + 1], 10);
       if (!isNaN(val) && val > 0) {
-        maxWorkers = Math.min(val, 8); // 限制最大值为 8
-      }
-    }
-
-    // targetPath 是第一个不是 --max-workers 的参数
-    let targetPath = process.cwd();
-    for (let i = 0; i < args.length; i++) {
-      if (i === maxWorkersArgIndex || i === maxWorkersArgIndex + 1) continue;
-      if (!targetPath || targetPath === process.cwd()) {
-        targetPath = args[i];
-        continue;
+        maxWorkers = val;
       }
     }
 
     // 检查是否有分支参数 (--branch <branchName>)
+    let branchArg = null;
     const branchIndex = args.indexOf('--branch');
     if (branchIndex !== -1 && args[branchIndex + 1]) {
       branchArg = args[branchIndex + 1];
     }
 
-    console.log(`\n[ESLint 启动配置]`);
-    console.log(`- 检查路径: ${targetPath}`);
-    console.log(`- 并发进程数: ${maxWorkers}`);
+    // targetPath 是第一个不是 --max-workers 的参数
+    let targetPath = process.cwd();
+    for (let i = 0; i < args.length; i++) {
+      if (
+        i === maxWorkersArgIndex ||
+        i === maxWorkersArgIndex + 1 ||
+        i === branchIndex ||
+        i === branchIndex + 1
+      )
+        continue;
+      targetPath = args[i] || targetPath;
+      break;
+    }
+
+    console.log(`\n[ESLint 配置]`);
+    console.log(`路径: ${targetPath}`);
+    console.log(`并发线程数: ${maxWorkers || 'ESLint 默认'}`);
     console.log('');
 
     // 路径解析
@@ -73,13 +75,11 @@ async function runEslint() {
       if (fs.existsSync(fullPath)) {
         rootDir = fullPath;
       } else {
-        console.error(`找不到目录: packages/${targetPath}`);
+        console.error(`❌ 找不到目录: packages/${targetPath}`);
         process.exit(1);
       }
     }
 
-    console.log('目标路径解析为:', rootDir);
-
     const gitRootResult = spawnSync('git', ['rev-parse', '--show-toplevel'], {
       cwd: rootDir,
       encoding: 'utf-8',
@@ -87,7 +87,7 @@ async function runEslint() {
     });
 
     if (gitRootResult.status !== 0 || !gitRootResult.stdout) {
-      console.error('无法获取 Git 根目录，请确保路径在 Git 仓库内');
+      console.error('❌ 无法获取 Git 根目录，请确保路径在 Git 仓库内');
       process.exit(1);
     }
 
@@ -107,43 +107,45 @@ async function runEslint() {
     });
 
     if (currentBranchResult.status !== 0 || !currentBranchResult.stdout) {
-      console.error('无法获取当前 Git 分支');
+      console.error('❌ 无法获取当前 Git 分支');
       process.exit(1);
     }
 
     const currentBranch = currentBranchResult.stdout.trim();
 
+    const branchToUse = branchArg || targetBranch;
+
     console.log(`[Git 信息]`);
-    console.log(`- 仓库根目录: ${gitRoot}`);
-    console.log(`- 当前分支: ${currentBranch}`);
-    console.log(`- 目标分支: ${branchArg || targetBranch}`);
+    console.log(`仓库根目录: ${gitRoot}`);
+    console.log(`当前分支: ${currentBranch}`);
+    console.log(`目标分支: ${branchArg || targetBranch}`);
     console.log('');
 
-    const statusResult = spawnSync('git', ['status', '--porcelain'], {
-      cwd: gitRoot,
-      encoding: 'utf-8',
-      shell: true,
-    });
-    if (statusResult.status === 0 && statusResult.stdout.trim()) {
-      console.warn(
-        '⚠️ 检测到当前分支有未提交的更改，切换分支可能失败或导致代码丢失，请先提交或暂存更改！\n',
-      );
-    }
+    if (currentBranch !== branchToUse) {
+      const statusResult = spawnSync('git', ['status', '--porcelain'], {
+        cwd: gitRoot,
+        encoding: 'utf-8',
+        shell: true,
+      });
+      if (statusResult.status === 0 && statusResult.stdout.trim()) {
+        console.error(
+          '⚠️ 当前分支有未提交的更改，切换分支可能导致代码丢失，请先提交或暂存更改！\n❌ 终止执行',
+        );
+        process.exit(1);
+      }
 
-    // 切换分支并拉取最新代码
-    if (!branchArg && currentBranch !== targetBranch) {
-      console.log(`➡️ 切换到分支 ${targetBranch} ...`);
-      const checkout = spawnSync('git', ['checkout', targetBranch], {
+      console.log(`➡️ 切换到分支 ${branchToUse} ...`);
+      const checkout = spawnSync('git', ['checkout', branchToUse], {
         cwd: gitRoot,
         stdio: 'inherit',
         shell: true,
       });
       if (checkout.status !== 0) {
-        console.error(`切换分支失败`);
+        console.error('❌ 切换分支失败');
         process.exit(1);
       }
-    } else if (branchArg) {
-      console.log(`➡️ 使用指定分支 ${branchArg} `);
+    } else {
+      console.log(`➡️ 当前已在分支 ${branchToUse}`);
     }
 
     console.log('⬇️ 正在拉取最新代码...');
@@ -153,64 +155,39 @@ async function runEslint() {
       shell: true,
     });
     if (pull.status !== 0) {
-      console.error('git pull 失败');
+      console.error('❌ git pull 失败');
       process.exit(1);
     }
 
     const srcPath = path.join(rootDir, 'src');
     const eslintTarget = fs.existsSync(srcPath) ? srcPath : '.';
     if (!fs.existsSync(srcPath)) {
-      console.warn(`src 文件夹不存在，改为检查当前目录: ${eslintTarget}`);
+      console.warn(`🔍 src 文件夹不存在，改为检查当前目录: ${eslintTarget}`);
     } else {
-      console.log(`检查目录: ${eslintTarget}`);
+      console.log(`🔍 检查目录: ${eslintTarget}`);
     }
 
-    const allFiles = glob.sync('**/*.{js,jsx,ts,tsx}', { cwd: eslintTarget, absolute: true });
-    if (allFiles.length === 0) {
-      console.log('没有需要检查的文件');
+    const eslint = new ESLint({ cwd: rootDir, threads: maxWorkers || undefined });
+    const files = glob.sync('**/*.{js,jsx,ts,tsx}', { cwd: eslintTarget, absolute: true });
+    if (files.length === 0) {
+      console.log('- 没有需要检查的文件');
       return;
     }
 
-    // 多进程拆分
-    const chunkSize = Math.max(1, Math.ceil(allFiles.length / maxWorkers)); // 最少一个文件
-    const chunks = [];
-    for (let i = 0; i < allFiles.length; i += chunkSize) {
-      chunks.push(allFiles.slice(i, i + chunkSize));
-    }
-
-    let finished = 0;
-    let hasError = false;
-
-    // 并行 ESLint
     console.log(`[ESLint 执行]`);
-    console.log(`- 共计文件: ${allFiles.length}`);
-    console.log(`- 拆分任务: ${chunks.length} 个`);
+    console.log(`文件总数: ${files.length}`);
     console.log('');
-    console.log('🚀 开始并行执行 ESLint ...\n');
-
-    chunks.forEach((chunk) => {
-      const eslint = spawn(
-        'npx',
-        ['eslint', ...chunk, '--ext', 'ts,tsx,js,jsx', '--report-unused-disable-directives'],
-        {
-          cwd: rootDir,
-          stdio: 'inherit',
-          shell: true,
-        },
-      );
-
-      eslint.on('close', (code) => {
-        if (code !== 0 && code !== null) {
-          hasError = true;
-        }
-        finished++;
-        if (finished === chunks.length) {
-          process.exit(hasError ? 1 : 0);
-        }
-      });
-    });
+    console.log('🚀 开始执行 ESLint ...\n');
+
+    const results = await eslint.lintFiles(files);
+    const formatter = await eslint.loadFormatter('stylish');
+    const resultText = formatter.format(results);
+    console.log(resultText);
+
+    const hasError = results.some((r) => r.errorCount > 0);
+    process.exit(hasError ? 1 : 0);
   } catch (err) {
-    console.error('脚本执行出错:', err);
+    console.error('❌ 脚本执行出错:', err);
     process.exit(1);
   }
 }