feat: improve config handling

Author: pnodet

Diff for: biome.json

@@ -4,14 +4,7 @@
     "enabled": true
   },
   "linter": {
-    "enabled": true,
-    "ignore": ["dist/**/*"],
-    "rules": {
-      "recommended": true,
-      "style":{
-        "useSingleVarDeclarator": "off"
-      }
-    }
+    "enabled": false
   },
   "formatter": {
     "enabled": true,

Diff for: bun.lockb

@@ -60,7 +60,6 @@
     "@biomejs/js-api": "^0.6.2",
     "eslint": "^9.11.0",
     "fast-glob": "^3.3.2",
-    "p-limit": "^6.1.0",
     "yargs": "^17.7.2"
   }
 }

Diff for: package.json

@@ -1,14 +1,19 @@
 import { Biome, Distribution } from "@biomejs/js-api";
-import pLimit from "p-limit";
+import type { LintResult as BiomeLintResult } from "@biomejs/js-api";
 import { readFileSync, existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import os from "node:os";
 import { performance } from "node:perf_hooks";
-import type { Configuration, LintResult } from "@biomejs/js-api";
+import type {
+  Configuration,
+  LintResult as ESLintLintResult,
+} from "@biomejs/js-api";
 import type { ESLint } from "eslint";
+import { getFilesToLint } from "./files";
 
-const getSeverity = (severity: LintResult["diagnostics"][0]["severity"]) => {
+const getSeverity = (
+  severity: ESLintLintResult["diagnostics"][0]["severity"],
+) => {
   switch (severity) {
     case "fatal": {
       return 2;
@@ -61,8 +66,21 @@ const getLineAncColFromByteOffset = (
   return { line, column };
 };
 
+const getEmptyLintResult = (filePath: string): ESLint.LintResult =>
+  ({
+    filePath,
+    fatalErrorCount: 0,
+    errorCount: 0,
+    warningCount: 0,
+    fixableErrorCount: 0,
+    fixableWarningCount: 0,
+    usedDeprecatedRules: [],
+    suppressedMessages: [],
+    messages: [],
+  }) satisfies ESLint.LintResult;
+
 const convertBiomeResult = (
-  result: LintResult,
+  result: ESLintLintResult,
   filePath: string,
   fileContent: string,
 ): ESLint.LintResult => {
@@ -110,20 +128,34 @@ const convertBiomeResult = (
 
 const biomeLintFile = async (
   biome: Biome,
+  config: Configuration,
   filePath: string,
-  fix = true,
-  unsafe = false,
+  fix: boolean,
+  unsafe: boolean,
 ) => {
+  const shouldLint = config.linter?.enabled ?? true;
+
+  if (!shouldLint && !fix) {
+    return getEmptyLintResult(filePath);
+  }
+
   const initialContent = await readFile(filePath, "utf8");
 
-  const result = biome.lintContent(initialContent, {
-    filePath,
-    fixFileMode: fix
-      ? unsafe
-        ? "SafeAndUnsafeFixes"
-        : "SafeFixes"
-      : undefined,
-  });
+  let result: BiomeLintResult = {
+    content: initialContent,
+    diagnostics: [],
+  };
+
+  if (shouldLint) {
+    result = biome.lintContent(initialContent, {
+      filePath,
+      fixFileMode: fix
+        ? unsafe
+          ? "SafeAndUnsafeFixes"
+          : "SafeFixes"
+        : undefined,
+    });
+  }
 
   if (fix) {
     const formatted = biome.formatContent(result.content, {
@@ -138,23 +170,6 @@ const biomeLintFile = async (
   return convertBiomeResult(result, filePath, result.content);
 };
 
-const biomeLintFiles = async (
-  biome: Biome,
-  files: string[],
-  concurrency: number = os.cpus().length,
-  fix = true,
-  unsafe = false,
-) => {
-  const limit = pLimit(concurrency);
-  const results = await Promise.all(
-    files.map((file) =>
-      limit(async () => await biomeLintFile(biome, file, fix, unsafe)),
-    ),
-  );
-
-  return results;
-};
-
 const findNearestBiomeConfig = () => {
   const cwd = process.cwd();
 
@@ -217,16 +232,18 @@ const defaultConfig: Configuration = {
   },
 };
 
-const getBiomeConfig = (): Configuration => {
+export const getBiomeConfig = (): Configuration => {
   try {
     let config = defaultConfig;
     const biomeConfigPath = findNearestBiomeConfig();
 
     if (biomeConfigPath) {
       const biomeConfig = readFileSync(biomeConfigPath, "utf8");
-      config = Object.assign(config, JSON.parse(biomeConfig));
+      config = JSON.parse(biomeConfig);
     }
 
+    console.log(config);
+
     return config;
   } catch (error) {
     console.warn(error);
@@ -235,28 +252,28 @@ const getBiomeConfig = (): Configuration => {
 };
 
 export const lintWithBiome = async (
-  files: string[],
-  concurrency: number = os.cpus().length,
-  fix = true,
-  debug = false,
-  unsafe = false,
+  patterns: string[],
+  fix: boolean,
+  debug: boolean,
+  unsafe: boolean,
 ) => {
+  const [biome, files, config] = await Promise.all([
+    Biome.create({
+      distribution: Distribution.NODE,
+    }),
+    getFilesToLint(patterns),
+    getBiomeConfig(),
+  ]);
+  biome.applyConfiguration(config);
+
   if (debug) {
     performance.mark("biome-start");
   }
 
-  const biome = await Biome.create({
-    distribution: Distribution.NODE,
-  });
-
-  biome.applyConfiguration(getBiomeConfig());
-
-  const biomeResults = await biomeLintFiles(
-    biome,
-    files,
-    concurrency,
-    fix,
-    unsafe,
+  const biomeResults = await Promise.all(
+    files.map(
+      async (file) => await biomeLintFile(biome, config, file, fix, unsafe),
+    ),
   );
 
   if (debug) {

Diff for: src/biome.ts

@@ -1,35 +1,22 @@
 import { ESLint } from "eslint";
-import os from "node:os";
 import { performance } from "node:perf_hooks";
-import pLimit from "p-limit";
 import type { Linter } from "eslint";
 
 export const lintWithEslint = async (
   eslint: ESLint,
   files: string[],
-  concurrency: number = os.cpus().length,
-  fix = true,
-  debug = false,
+  fix: boolean,
+  debug: boolean,
 ) => {
   if (debug) {
     performance.mark("eslint-start");
   }
 
-  const limit = pLimit(concurrency);
-
-  const eslintResults = (
-    await Promise.all(
-      files.map((file) =>
-        limit(async () => {
-          const results = await eslint.lintFiles([file]);
-          if (fix && results.length > 0) {
-            await ESLint.outputFixes(results);
-          }
-          return results;
-        }),
-      ),
-    )
-  ).flat();
+  const eslintResults = await eslint.lintFiles(files);
+  if (fix && eslintResults.length > 0) {
+    console.log("Fixing...");
+    await ESLint.outputFixes(eslintResults);
+  }
 
   if (debug) {
     performance.mark("eslint-end");

Diff for: src/eslint.ts

@@ -1,16 +1,8 @@
 import path from "node:path";
 import fs from "node:fs";
-import os from "node:os";
 import fg from "fast-glob";
-import type { ESLint } from "eslint";
-import pLimit from "p-limit";
 
-export const getFilesToLint = async (
-  eslint: ESLint,
-  patterns: string[],
-
-  concurrency: number = os.cpus().length,
-) => {
+export const getFilesToLint = async (patterns: string[]) => {
   const globPatterns = patterns.flatMap((pattern) => {
     if (!fs.existsSync(pattern)) {
       return pattern;
@@ -30,21 +22,5 @@ export const getFilesToLint = async (
   });
 
   const files = await fg(globPatterns, { dot: true, absolute: true });
-
-  await eslint.isPathIgnored(files[0]);
-
-  const limit = pLimit(concurrency);
-
-  const results = (
-    await Promise.all(
-      files.map(async (file) =>
-        limit(async () => {
-          const isIgnored = await eslint.isPathIgnored(file);
-          return !isIgnored ? file : null;
-        }),
-      ),
-    )
-  ).filter(Boolean) as string[];
-
-  return results;
+  return files;
 };

Diff for: src/files.ts

@@ -1,14 +1,12 @@
 #!/usr/bin/env node
 
 import { ESLint } from "eslint";
-import { getFilesToLint } from "./files";
 import { lintWithBiome } from "./biome";
-import { lintWithEslint, mergeResults, overrideConfig } from "./eslint";
+import { lintWithEslint, mergeResults } from "./eslint";
 import pkgJson from "../package.json" assert { type: "json" };
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { performance } from "node:perf_hooks";
-import os from "node:os";
 
 const instance = yargs(hideBin(process.argv))
   .scriptName("@nivalis/linter")
@@ -29,56 +27,41 @@ const instance = yargs(hideBin(process.argv))
         })
         .option("fix", {
           type: "boolean",
-          default: true,
+          default: false,
           description: "Automatically fix linting errors",
         })
         .option("debug", {
           type: "boolean",
           default: false,
           description: "Run in debug mode",
         })
-        .option("concurrency", {
-          type: "number",
-          default: os.cpus().length,
-          description:
-            "Number of concurrent linting processes (default: number of CPU cores)",
-        })
         .option("unsafe", {
           type: "boolean",
           default: false,
           description: "Allow unsafe fixes",
         })
         .help(),
     async (args) => {
-      const { files: files_, fix, debug, concurrency, unsafe } = args;
+      const { files: files_, fix, debug, unsafe } = args;
       try {
         const patterns = Array.isArray(files_) ? files_ : [files_];
 
         const eslint = new ESLint({
           fix,
           cache: true,
-          overrideConfig: overrideConfig,
+          // overrideConfig: overrideConfig,
         });
 
-        const formatter = await eslint.loadFormatter("stylish");
-        const files = await getFilesToLint(eslint, patterns, concurrency);
+        const biomeResults = await lintWithBiome(patterns, fix, debug, unsafe);
 
         const eslintResults = await lintWithEslint(
           eslint,
-          files,
-          concurrency,
-          fix,
-          debug,
-        );
-
-        const biomeResults = await lintWithBiome(
-          files,
-          concurrency,
+          patterns,
           fix,
           debug,
-          unsafe,
         );
 
+        const formatter = await eslint.loadFormatter("stylish");
         const resultText = await formatter.format(
           mergeResults([...biomeResults, ...eslintResults]),
         );