@code-pushup/eslint-plugin 0.54.0 → 0.56.0

package/bin.js

@@ -1,6 +1,6 @@
 // packages/plugin-eslint/src/lib/runner/index.ts
-import { writeFile as writeFile2 } from "node:fs/promises";
-import { dirname, join as join3 } from "node:path";
+import { writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
 
 // packages/models/src/lib/implementation/schemas.ts
 import { MATERIAL_ICONS } from "vscode-material-icons";
@@ -33,7 +33,7 @@ function exists(value) {
   return value != null;
 }
 function getMissingRefsForCategories(categories, plugins) {
-  if (categories.length === 0) {
+  if (!categories || categories.length === 0) {
     return false;
   }
   const auditRefsFromCategory = categories.flatMap(
@@ -532,12 +532,9 @@ var unrefinedCoreConfigSchema = z14.object({
 var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
 function refineCoreConfig(schema) {
   return schema.refine(
-    (coreCfg) => !getMissingRefsForCategories(coreCfg.categories ?? [], coreCfg.plugins),
-    (coreCfg) => ({
-      message: missingRefsForCategoriesErrorMsg(
-        coreCfg.categories ?? [],
-        coreCfg.plugins
-      )
+    ({ categories, plugins }) => !getMissingRefsForCategories(categories, plugins),
+    ({ categories, plugins }) => ({
+      message: missingRefsForCategoriesErrorMsg(categories, plugins)
     })
   );
 }
@@ -589,19 +586,16 @@ var reportSchema = packageVersionSchema({
 ).merge(
   z15.object(
     {
-      categories: z15.array(categoryConfigSchema),
       plugins: z15.array(pluginReportSchema).min(1),
+      categories: z15.array(categoryConfigSchema).optional(),
       commit: commitSchema.describe("Git commit for which report was collected").nullable()
     },
     { description: "Collect output data" }
   )
 ).refine(
-  (report) => !getMissingRefsForCategories(report.categories, report.plugins),
-  (report) => ({
-    message: missingRefsForCategoriesErrorMsg(
-      report.categories,
-      report.plugins
-    )
+  ({ categories, plugins }) => !getMissingRefsForCategories(categories, plugins),
+  ({ categories, plugins }) => ({
+    message: missingRefsForCategoriesErrorMsg(categories, plugins)
   })
 );
 
@@ -780,7 +774,7 @@ function executeProcess(cfg) {
 import { bold, gray } from "ansis";
 import { bundleRequire } from "bundle-require";
 import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 // packages/utils/src/lib/formatting.ts
 function slugify(text) {
@@ -934,22 +928,24 @@ import { MarkdownDocument as MarkdownDocument4, md as md5 } from "build-md";
 import { bold as bold4, cyan, cyanBright, green as green2, red } from "ansis";
 
 // packages/plugin-eslint/src/lib/runner/lint.ts
-import { rm as rm2, writeFile } from "node:fs/promises";
 import { platform } from "node:os";
-import { join as join2 } from "node:path";
 
 // packages/plugin-eslint/src/lib/setup.ts
 import { ESLint } from "eslint";
-function setupESLint(eslintrc) {
-  return new ESLint({
-    ...typeof eslintrc === "string" && { overrideConfigFile: eslintrc },
-    ...typeof eslintrc === "object" && {
-      baseConfig: eslintrc,
-      useEslintrc: false
-    },
+async function setupESLint(eslintrc) {
+  const eslintConstructor = await loadESLint();
+  return new eslintConstructor({
+    overrideConfigFile: eslintrc,
     errorOnUnmatchedPattern: false
   });
 }
+async function loadESLint() {
+  const eslint = await import("eslint");
+  if ("loadESLint" in eslint && typeof eslint.loadESLint === "function") {
+    return await eslint.loadESLint();
+  }
+  return ESLint;
+}
 
 // packages/plugin-eslint/src/lib/runner/lint.ts
 async function lint({
@@ -957,37 +953,35 @@ async function lint({
   patterns
 }) {
   const results = await executeLint({ eslintrc, patterns });
-  const ruleOptionsPerFile = await loadRuleOptionsPerFile(eslintrc, results);
+  const eslint = await setupESLint(eslintrc);
+  const ruleOptionsPerFile = await loadRuleOptionsPerFile(eslint, results);
   return { results, ruleOptionsPerFile };
 }
-function executeLint({
+async function executeLint({
   eslintrc,
   patterns
 }) {
-  return withConfig(eslintrc, async (configPath) => {
-    const { stdout } = await executeProcess({
-      command: "npx",
-      args: [
-        "eslint",
-        ...configPath ? [`--config=${filePathToCliArg(configPath)}`] : [],
-        ...typeof eslintrc === "object" ? ["--no-eslintrc"] : [],
-        "--no-error-on-unmatched-pattern",
-        "--format=json",
-        ...toArray(patterns).map(
-          (pattern) => (
-            // globs need to be escaped on Unix
-            platform() === "win32" ? pattern : `'${pattern}'`
-          )
+  const { stdout } = await executeProcess({
+    command: "npx",
+    args: [
+      "eslint",
+      ...eslintrc ? [`--config=${filePathToCliArg(eslintrc)}`] : [],
+      ...typeof eslintrc === "object" ? ["--no-eslintrc"] : [],
+      "--no-error-on-unmatched-pattern",
+      "--format=json",
+      ...toArray(patterns).map(
+        (pattern) => (
+          // globs need to be escaped on Unix
+          platform() === "win32" ? pattern : `'${pattern}'`
         )
-      ],
-      ignoreExitCode: true,
-      cwd: process.cwd()
-    });
-    return JSON.parse(stdout);
+      )
+    ],
+    ignoreExitCode: true,
+    cwd: process.cwd()
   });
+  return JSON.parse(stdout);
 }
-function loadRuleOptionsPerFile(eslintrc, results) {
-  const eslint = setupESLint(eslintrc);
+function loadRuleOptionsPerFile(eslint, results) {
   return results.reduce(async (acc, { filePath, messages }) => {
     const filesMap = await acc;
     const config = await eslint.calculateConfigForFile(
@@ -1011,24 +1005,6 @@ function loadRuleOptionsPerFile(eslintrc, results) {
     };
   }, Promise.resolve({}));
 }
-async function withConfig(eslintrc, fn) {
-  if (typeof eslintrc !== "object") {
-    return fn(eslintrc);
-  }
-  const configPath = generateTempConfigPath();
-  await writeFile(configPath, JSON.stringify(eslintrc));
-  try {
-    return await fn(configPath);
-  } finally {
-    await rm2(configPath);
-  }
-}
-function generateTempConfigPath() {
-  return join2(
-    process.cwd(),
-    `.eslintrc.${Math.random().toString().slice(2)}.json`
-  );
-}
 
 // packages/plugin-eslint/src/lib/meta/hash.ts
 import { createHash } from "node:crypto";
@@ -1122,8 +1098,8 @@ function convertSeverity(severity) {
 
 // packages/plugin-eslint/src/lib/runner/index.ts
 var WORKDIR = pluginWorkDir("eslint");
-var RUNNER_OUTPUT_PATH = join3(WORKDIR, "runner-output.json");
-var PLUGIN_CONFIG_PATH = join3(
+var RUNNER_OUTPUT_PATH = join2(WORKDIR, "runner-output.json");
+var PLUGIN_CONFIG_PATH = join2(
   process.cwd(),
   WORKDIR,
   "plugin-config.json"
@@ -1145,8 +1121,8 @@ async function executeRunner() {
       details: { issues: [] }
     }
   );
-  await ensureDirectoryExists(dirname(RUNNER_OUTPUT_PATH));
-  await writeFile2(RUNNER_OUTPUT_PATH, JSON.stringify(audits));
+  await ensureDirectoryExists(dirname2(RUNNER_OUTPUT_PATH));
+  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(audits));
 }
 
 // packages/plugin-eslint/src/bin.ts

package/index.js

@@ -1,10 +1,10 @@
 // packages/plugin-eslint/src/lib/eslint-plugin.ts
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname3, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/plugin-eslint/package.json
 var name = "@code-pushup/eslint-plugin";
-var version = "0.54.0";
+var version = "0.56.0";
 
 // packages/plugin-eslint/src/lib/config.ts
 import { z as z17 } from "zod";
@@ -40,7 +40,7 @@ function exists(value) {
   return value != null;
 }
 function getMissingRefsForCategories(categories, plugins) {
-  if (categories.length === 0) {
+  if (!categories || categories.length === 0) {
     return false;
   }
   const auditRefsFromCategory = categories.flatMap(
@@ -539,12 +539,9 @@ var unrefinedCoreConfigSchema = z14.object({
 var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
 function refineCoreConfig(schema) {
   return schema.refine(
-    (coreCfg) => !getMissingRefsForCategories(coreCfg.categories ?? [], coreCfg.plugins),
-    (coreCfg) => ({
-      message: missingRefsForCategoriesErrorMsg(
-        coreCfg.categories ?? [],
-        coreCfg.plugins
-      )
+    ({ categories, plugins }) => !getMissingRefsForCategories(categories, plugins),
+    ({ categories, plugins }) => ({
+      message: missingRefsForCategoriesErrorMsg(categories, plugins)
     })
   );
 }
@@ -596,19 +593,16 @@ var reportSchema = packageVersionSchema({
 ).merge(
   z15.object(
     {
-      categories: z15.array(categoryConfigSchema),
       plugins: z15.array(pluginReportSchema).min(1),
+      categories: z15.array(categoryConfigSchema).optional(),
       commit: commitSchema.describe("Git commit for which report was collected").nullable()
     },
     { description: "Collect output data" }
   )
 ).refine(
-  (report) => !getMissingRefsForCategories(report.categories, report.plugins),
-  (report) => ({
-    message: missingRefsForCategoriesErrorMsg(
-      report.categories,
-      report.plugins
-    )
+  ({ categories, plugins }) => !getMissingRefsForCategories(categories, plugins),
+  ({ categories, plugins }) => ({
+    message: missingRefsForCategoriesErrorMsg(categories, plugins)
   })
 );
 
@@ -719,7 +713,7 @@ var TERMINAL_WIDTH = 80;
 import { bold, gray } from "ansis";
 import { bundleRequire } from "bundle-require";
 import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 // packages/utils/src/lib/formatting.ts
 function slugify(text) {
@@ -802,6 +796,16 @@ async function ensureDirectoryExists(baseDir) {
 function pluginWorkDir(slug) {
   return join("node_modules", ".code-pushup", slug);
 }
+async function findNearestFile(fileNames, cwd = process.cwd()) {
+  for (let directory = cwd; directory !== dirname(directory); directory = dirname(directory)) {
+    for (const file of fileNames) {
+      if (await fileExists(join(directory, file))) {
+        return join(directory, file);
+      }
+    }
+  }
+  return void 0;
+}
 function filePathToCliArg(path) {
   return `"${path}"`;
 }
@@ -858,15 +862,7 @@ import { bold as bold4, cyan, cyanBright, green as green2, red } from "ansis";
 var patternsSchema = z17.union([z17.string(), z17.array(z17.string()).min(1)], {
   description: "Lint target files. May contain file paths, directory paths or glob patterns"
 });
-var eslintrcSchema = z17.union(
-  [
-    z17.string({ description: "Path to ESLint config file" }),
-    z17.record(z17.string(), z17.unknown(), {
-      description: "ESLint config object"
-    })
-  ],
-  { description: "ESLint config as file path or inline object" }
-);
+var eslintrcSchema = z17.string({ description: "Path to ESLint config file" });
 var eslintTargetObjectSchema = z17.object({
   eslintrc: eslintrcSchema.optional(),
   patterns: patternsSchema
@@ -889,80 +885,16 @@ function jsonHash(data, bytes = 8) {
   return createHash("shake256", { outputLength: bytes }).update(JSON.stringify(data) || "null").digest("hex");
 }
 
-// packages/plugin-eslint/src/lib/setup.ts
-import { ESLint } from "eslint";
-function setupESLint(eslintrc) {
-  return new ESLint({
-    ...typeof eslintrc === "string" && { overrideConfigFile: eslintrc },
-    ...typeof eslintrc === "object" && {
-      baseConfig: eslintrc,
-      useEslintrc: false
-    },
-    errorOnUnmatchedPattern: false
-  });
-}
-
-// packages/plugin-eslint/src/lib/meta/rules.ts
-async function listRules(targets) {
-  const rulesMap = await targets.reduce(async (acc, { eslintrc, patterns }) => {
-    const eslint = setupESLint(eslintrc);
-    const prev = await acc;
-    const curr = await loadRulesMap(eslint, patterns);
-    return mergeRulesMaps(prev, curr);
-  }, Promise.resolve({}));
-  return Object.values(rulesMap).flatMap(Object.values);
-}
-async function loadRulesMap(eslint, patterns) {
-  const configs = await toArray(patterns).reduce(
-    async (acc, pattern) => [
-      ...await acc,
-      await eslint.calculateConfigForFile(pattern)
-    ],
-    Promise.resolve([])
-  );
-  const rulesIds = distinct(
-    configs.flatMap((config) => Object.keys(config.rules ?? {}))
-  );
-  const rulesMeta = eslint.getRulesMetaForResults([
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    {
-      messages: rulesIds.map((ruleId) => ({ ruleId })),
-      suppressedMessages: []
-    }
-  ]);
-  return configs.flatMap((config) => Object.entries(config.rules ?? {})).filter(([, ruleEntry]) => ruleEntry != null && !isRuleOff(ruleEntry)).reduce((acc, [ruleId, ruleEntry]) => {
-    const meta = rulesMeta[ruleId];
-    if (!meta) {
-      ui().logger.warning(`Metadata not found for ESLint rule ${ruleId}`);
-      return acc;
-    }
-    const options = toArray(ruleEntry).slice(1);
-    const optionsHash = jsonHash(options);
-    const ruleData = {
-      ruleId,
-      meta,
-      options
-    };
-    return {
-      ...acc,
-      [ruleId]: {
-        ...acc[ruleId],
-        [optionsHash]: ruleData
-      }
-    };
-  }, {});
-}
-function mergeRulesMaps(prev, curr) {
-  return Object.entries(curr).reduce(
-    (acc, [ruleId, ruleVariants]) => ({
-      ...acc,
-      [ruleId]: {
-        ...acc[ruleId],
-        ...ruleVariants
-      }
-    }),
-    prev
-  );
+// packages/plugin-eslint/src/lib/meta/parse.ts
+function parseRuleId(ruleId) {
+  const i = ruleId.lastIndexOf("/");
+  if (i < 0) {
+    return { name: ruleId };
+  }
+  return {
+    plugin: ruleId.slice(0, i),
+    name: ruleId.slice(i + 1)
+  };
 }
 function isRuleOff(entry) {
   const level = Array.isArray(entry) ? entry[0] : entry;
@@ -977,15 +909,8 @@ function isRuleOff(entry) {
       return false;
   }
 }
-function parseRuleId(ruleId) {
-  const i = ruleId.lastIndexOf("/");
-  if (i < 0) {
-    return { name: ruleId };
-  }
-  return {
-    plugin: ruleId.slice(0, i),
-    name: ruleId.slice(i + 1)
-  };
+function optionsFromRuleEntry(entry) {
+  return toArray(entry).slice(1);
 }
 
 // packages/plugin-eslint/src/lib/meta/groups.ts
@@ -1053,6 +978,191 @@ function groupsFromRuleCategories(rules) {
   return groups.toSorted((a, b) => a.slug.localeCompare(b.slug));
 }
 
+// packages/plugin-eslint/src/lib/meta/versions/flat.ts
+import { builtinRules } from "eslint/use-at-your-own-risk";
+import { isAbsolute, join as join2 } from "node:path";
+import { pathToFileURL } from "node:url";
+async function loadRulesForFlatConfig({
+  eslintrc
+}) {
+  const config = eslintrc ? await loadConfigByPath(eslintrc) : await loadConfigByDefaultLocation();
+  const configs = toArray(config);
+  const rules = findEnabledRulesWithOptions(configs);
+  return rules.map((rule) => {
+    const meta = findRuleMeta(rule.ruleId, configs);
+    if (!meta) {
+      ui().logger.warning(`Cannot find metadata for rule ${rule.ruleId}`);
+      return null;
+    }
+    return { ...rule, meta };
+  }).filter(exists);
+}
+async function loadConfigByDefaultLocation() {
+  const flatConfigFileNames = [
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs"
+  ];
+  const configPath = await findNearestFile(flatConfigFileNames);
+  if (configPath) {
+    return loadConfigByPath(configPath);
+  }
+  throw new Error(
+    [
+      `ESLint config file not found - expected ${flatConfigFileNames.join("/")} in ${process.cwd()} or some parent directory`,
+      "If your ESLint config is in a non-standard location, use the `eslintrc` parameter to specify the path."
+    ].join("\n")
+  );
+}
+async function loadConfigByPath(path) {
+  const absolutePath = isAbsolute(path) ? path : join2(process.cwd(), path);
+  const url = pathToFileURL(absolutePath).toString();
+  const mod = await import(url);
+  return "default" in mod ? mod.default : mod;
+}
+function findEnabledRulesWithOptions(configs) {
+  const enabledRules = configs.flatMap(({ rules }) => Object.entries(rules ?? {})).filter(([, entry]) => entry != null && !isRuleOff(entry)).map(([ruleId, entry]) => ({
+    ruleId,
+    options: entry ? optionsFromRuleEntry(entry) : []
+  }));
+  const uniqueRulesMap = new Map(
+    enabledRules.map(({ ruleId, options }) => [
+      `${ruleId}::${jsonHash(options)}`,
+      { ruleId, options }
+    ])
+  );
+  return [...uniqueRulesMap.values()];
+}
+function findRuleMeta(ruleId, configs) {
+  const { plugin, name: name2 } = parseRuleId(ruleId);
+  if (!plugin) {
+    return findBuiltinRuleMeta(name2);
+  }
+  return findPluginRuleMeta(plugin, name2, configs);
+}
+function findBuiltinRuleMeta(name2) {
+  const rule = builtinRules.get(name2);
+  return rule?.meta;
+}
+function findPluginRuleMeta(plugin, name2, configs) {
+  const config = configs.find(({ plugins = {} }) => plugin in plugins);
+  const rule = config?.plugins?.[plugin]?.rules?.[name2];
+  if (typeof rule === "function") {
+    ui().logger.warning(
+      `Cannot parse metadata for rule ${plugin}/${name2}, plugin registers it as a function`
+    );
+    return void 0;
+  }
+  return rule?.meta;
+}
+
+// packages/plugin-eslint/src/lib/setup.ts
+import { ESLint } from "eslint";
+async function setupESLint(eslintrc) {
+  const eslintConstructor = await loadESLint();
+  return new eslintConstructor({
+    overrideConfigFile: eslintrc,
+    errorOnUnmatchedPattern: false
+  });
+}
+async function loadESLint() {
+  const eslint = await import("eslint");
+  if ("loadESLint" in eslint && typeof eslint.loadESLint === "function") {
+    return await eslint.loadESLint();
+  }
+  return ESLint;
+}
+
+// packages/plugin-eslint/src/lib/meta/versions/legacy.ts
+async function loadRulesForLegacyConfig({
+  eslintrc,
+  patterns
+}) {
+  const eslint = await setupESLint(eslintrc);
+  const configs = await toArray(patterns).reduce(
+    async (acc, pattern) => [
+      ...await acc,
+      await eslint.calculateConfigForFile(pattern)
+    ],
+    Promise.resolve([])
+  );
+  const rulesIds = distinct(
+    configs.flatMap((config) => Object.keys(config.rules ?? {}))
+  );
+  const rulesMeta = eslint.getRulesMetaForResults([
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    {
+      messages: rulesIds.map((ruleId) => ({ ruleId })),
+      suppressedMessages: []
+    }
+  ]);
+  return configs.flatMap((config) => Object.entries(config.rules ?? {})).map(([ruleId, ruleEntry]) => {
+    if (ruleEntry == null || isRuleOff(ruleEntry)) {
+      return null;
+    }
+    const meta = rulesMeta[ruleId];
+    if (!meta) {
+      ui().logger.warning(`Metadata not found for ESLint rule ${ruleId}`);
+      return null;
+    }
+    const options = optionsFromRuleEntry(ruleEntry);
+    return {
+      ruleId,
+      meta,
+      options
+    };
+  }).filter(exists);
+}
+
+// packages/plugin-eslint/src/lib/meta/versions/detect.ts
+import { ESLint as ESLint2 } from "eslint";
+async function detectConfigVersion() {
+  if (process.env["ESLINT_USE_FLAT_CONFIG"] === "true") {
+    return "flat";
+  }
+  if (process.env["ESLINT_USE_FLAT_CONFIG"] === "false") {
+    return "legacy";
+  }
+  if (ESLint2.version.startsWith("8.")) {
+    if (await fileExists("eslint.config.js")) {
+      return "flat";
+    }
+    return "legacy";
+  }
+  return "flat";
+}
+
+// packages/plugin-eslint/src/lib/meta/versions/index.ts
+function selectRulesLoader(version2) {
+  switch (version2) {
+    case "flat":
+      return loadRulesForFlatConfig;
+    case "legacy":
+      return loadRulesForLegacyConfig;
+  }
+}
+
+// packages/plugin-eslint/src/lib/meta/rules.ts
+async function listRules(targets) {
+  const version2 = await detectConfigVersion();
+  const loadRulesMap = selectRulesLoader(version2);
+  const rulesMap = await targets.reduce(async (acc, target) => {
+    const map = await acc;
+    const rules = await loadRulesMap(target);
+    return rules.reduce(mergeRuleIntoMap, map);
+  }, Promise.resolve({}));
+  return Object.values(rulesMap).flatMap(Object.values);
+}
+function mergeRuleIntoMap(map, rule) {
+  return {
+    ...map,
+    [rule.ruleId]: {
+      ...map[rule.ruleId],
+      [jsonHash(rule.options)]: rule
+    }
+  };
+}
+
 // packages/plugin-eslint/src/lib/meta/transform.ts
 function ruleToAudit({ ruleId, meta, options }) {
   const name2 = ruleId.split("/").at(-1) ?? ruleId;
@@ -1088,10 +1198,10 @@ async function listAuditsAndGroups(targets) {
 
 // packages/plugin-eslint/src/lib/runner/index.ts
 import { writeFile } from "node:fs/promises";
-import { dirname, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 var WORKDIR = pluginWorkDir("eslint");
-var RUNNER_OUTPUT_PATH = join2(WORKDIR, "runner-output.json");
-var PLUGIN_CONFIG_PATH = join2(
+var RUNNER_OUTPUT_PATH = join3(WORKDIR, "runner-output.json");
+var PLUGIN_CONFIG_PATH = join3(
   process.cwd(),
   WORKDIR,
   "plugin-config.json"
@@ -1101,7 +1211,7 @@ async function createRunnerConfig(scriptPath, audits, targets) {
     targets,
     slugs: audits.map((audit) => audit.slug)
   };
-  await ensureDirectoryExists(dirname(PLUGIN_CONFIG_PATH));
+  await ensureDirectoryExists(dirname2(PLUGIN_CONFIG_PATH));
   await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));
   return {
     command: "node",
@@ -1114,8 +1224,8 @@ async function createRunnerConfig(scriptPath, audits, targets) {
 async function eslintPlugin(config) {
   const targets = eslintPluginConfigSchema.parse(config);
   const { audits, groups } = await listAuditsAndGroups(targets);
-  const runnerScriptPath = join3(
-    fileURLToPath(dirname2(import.meta.url)),
+  const runnerScriptPath = join4(
+    fileURLToPath(dirname3(import.meta.url)),
     "bin.js"
   );
   return {
@@ -1152,25 +1262,74 @@ function filterProjectGraph(projectGraph, exclude = []) {
 }
 
 // packages/plugin-eslint/src/lib/nx/utils.ts
-import { join as join4 } from "node:path";
-async function findCodePushupEslintrc(project) {
-  const name2 = "code-pushup.eslintrc";
-  const extensions = ["json", "js", "cjs", "yml", "yaml"];
-  for (const ext of extensions) {
-    const filename = `./${project.root}/${name2}.${ext}`;
-    if (await fileExists(join4(process.cwd(), filename))) {
-      return filename;
-    }
-  }
-  return null;
+import { join as join5 } from "node:path";
+var ESLINT_CONFIG_EXTENSIONS = {
+  // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-formats
+  flat: ["js", "mjs", "cjs"],
+  // https://eslint.org/docs/latest/use/configure/configuration-files-deprecated
+  legacy: ["json", "js", "cjs", "yml", "yaml"]
+};
+var ESLINT_CONFIG_NAMES = {
+  // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-formats
+  flat: ["eslint.config"],
+  // https://eslint.org/docs/latest/use/configure/configuration-files-deprecated
+  legacy: [".eslintrc"]
+};
+var CP_ESLINT_CONFIG_NAMES = {
+  flat: [
+    "code-pushup.eslint.config",
+    "eslint.code-pushup.config",
+    "eslint.config.code-pushup",
+    "eslint.strict.config",
+    "eslint.config.strict"
+  ],
+  legacy: ["code-pushup.eslintrc", ".eslintrc.code-pushup", ".eslintrc.strict"]
+};
+async function findCodePushupEslintConfig(project, format) {
+  return findProjectFile(project, {
+    names: CP_ESLINT_CONFIG_NAMES[format],
+    extensions: ESLINT_CONFIG_EXTENSIONS[format]
+  });
 }
-function getLintFilePatterns(project) {
+async function findEslintConfig(project, format) {
   const options = project.targets?.["lint"]?.options;
-  return options?.lintFilePatterns == null ? [`${project.root}/**/*`] : toArray(options.lintFilePatterns);
+  return options?.eslintConfig ?? await findProjectFile(project, {
+    names: ESLINT_CONFIG_NAMES[format],
+    extensions: ESLINT_CONFIG_EXTENSIONS[format]
+  });
 }
-function getEslintConfig(project) {
+function getLintFilePatterns(project, format) {
   const options = project.targets?.["lint"]?.options;
-  return options?.eslintConfig ?? `./${project.root}/.eslintrc.json`;
+  const defaultPatterns = format === "legacy" ? `${project.root}/**/*` : project.root;
+  const patterns = options?.lintFilePatterns == null ? [defaultPatterns] : toArray(options.lintFilePatterns);
+  if (format === "legacy") {
+    return [
+      ...patterns,
+      // HACK: ESLint.calculateConfigForFile won't find rules included only for subsets of *.ts when globs used
+      // so we explicitly provide additional patterns used by @code-pushup/eslint-config to ensure those rules are included
+      // this workaround is only necessary for legacy configs (rules are detected more reliably in flat configs)
+      `${project.root}/*.spec.ts`,
+      // jest/* and vitest/* rules
+      `${project.root}/*.cy.ts`,
+      // cypress/* rules
+      `${project.root}/*.stories.ts`,
+      // storybook/* rules
+      `${project.root}/.storybook/main.ts`
+      // storybook/no-uninstalled-addons rule
+    ];
+  }
+  return patterns;
+}
+async function findProjectFile(project, file) {
+  for (const name2 of file.names) {
+    for (const ext of file.extensions) {
+      const filename = `./${project.root}/${name2}.${ext}`;
+      if (await fileExists(join5(process.cwd(), filename))) {
+        return filename;
+      }
+    }
+  }
+  return void 0;
 }
 
 // packages/plugin-eslint/src/lib/nx/projects-to-config.ts
@@ -1178,24 +1337,12 @@ async function nxProjectsToConfig(projectGraph, predicate = () => true) {
   const { readProjectsConfigurationFromProjectGraph } = await import("@nx/devkit");
   const projectsConfiguration = readProjectsConfigurationFromProjectGraph(projectGraph);
   const projects = Object.values(projectsConfiguration.projects).filter((project) => "lint" in (project.targets ?? {})).filter(predicate).sort((a, b) => a.root.localeCompare(b.root));
+  const format = await detectConfigVersion();
   return Promise.all(
     projects.map(
       async (project) => ({
-        eslintrc: await findCodePushupEslintrc(project) ?? getEslintConfig(project),
-        patterns: [
-          ...getLintFilePatterns(project),
-          // HACK: ESLint.calculateConfigForFile won't find rules included only for subsets of *.ts when globs used
-          // so we explicitly provide additional patterns used by @code-pushup/eslint-config to ensure those rules are included
-          // this workaround won't be necessary once flat configs are stable (much easier to find all rules)
-          `${project.sourceRoot}/*.spec.ts`,
-          // jest/* and vitest/* rules
-          `${project.sourceRoot}/*.cy.ts`,
-          // cypress/* rules
-          `${project.sourceRoot}/*.stories.ts`,
-          // storybook/* rules
-          `${project.sourceRoot}/.storybook/main.ts`
-          // storybook/no-uninstalled-addons rule
-        ]
+        eslintrc: await findCodePushupEslintConfig(project, format) ?? await findEslintConfig(project, format),
+        patterns: getLintFilePatterns(project, format)
       })
     )
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-pushup/eslint-plugin",
-  "version": "0.54.0",
+  "version": "0.56.0",
   "license": "MIT",
   "description": "Code PushUp plugin for detecting problems in source code using ESLint.📋",
   "homepage": "https://github.com/code-pushup/cli/tree/main/packages/plugin-eslint#readme",
@@ -40,13 +40,13 @@
   "main": "./index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
-    "@code-pushup/utils": "0.54.0",
-    "@code-pushup/models": "0.54.0",
-    "eslint": "^8.46.0",
+    "@code-pushup/utils": "0.56.0",
+    "@code-pushup/models": "0.56.0",
     "zod": "^3.22.4"
   },
   "peerDependencies": {
-    "@nx/devkit": ">=17.0.0"
+    "@nx/devkit": ">=17.0.0",
+    "eslint": "^8.46.0 || ^9.0.0"
   },
   "peerDependenciesMeta": {
     "@nx/devkit": {

package/src/lib/config.d.ts

@@ -1,61 +1,60 @@
-import type { ESLint } from 'eslint';
-import { type ZodType, z } from 'zod';
+import { z } from 'zod';
 export declare const eslintTargetSchema: z.ZodEffects<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
-    eslintrc: z.ZodOptional<z.ZodUnion<[z.ZodString, ZodType<ESLint.ConfigData<import("eslint").Linter.RulesRecord>, z.ZodTypeDef, ESLint.ConfigData<import("eslint").Linter.RulesRecord>>]>>;
+    eslintrc: z.ZodOptional<z.ZodString>;
     patterns: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
 }, "strip", z.ZodTypeAny, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }>]>, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }, string | string[] | {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }>;
 export type ESLintTarget = z.infer<typeof eslintTargetSchema>;
 export declare const eslintPluginConfigSchema: z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
-    eslintrc: z.ZodOptional<z.ZodUnion<[z.ZodString, ZodType<ESLint.ConfigData<import("eslint").Linter.RulesRecord>, z.ZodTypeDef, ESLint.ConfigData<import("eslint").Linter.RulesRecord>>]>>;
+    eslintrc: z.ZodOptional<z.ZodString>;
     patterns: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
 }, "strip", z.ZodTypeAny, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }>]>, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }, string | string[] | {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }>, z.ZodArray<z.ZodEffects<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodObject<{
-    eslintrc: z.ZodOptional<z.ZodUnion<[z.ZodString, ZodType<ESLint.ConfigData<import("eslint").Linter.RulesRecord>, z.ZodTypeDef, ESLint.ConfigData<import("eslint").Linter.RulesRecord>>]>>;
+    eslintrc: z.ZodOptional<z.ZodString>;
     patterns: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
 }, "strip", z.ZodTypeAny, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }>]>, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }, string | string[] | {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }>, "many">]>, {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 }[], string | string[] | {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 } | (string | string[] | {
     patterns: string | string[];
-    eslintrc?: string | ESLint.ConfigData<import("eslint").Linter.RulesRecord> | undefined;
+    eslintrc?: string | undefined;
 })[]>;
 export type ESLintPluginConfig = z.input<typeof eslintPluginConfigSchema>;
 export type ESLintPluginRunnerConfig = {

package/src/lib/meta/groups.d.ts

@@ -1,4 +1,4 @@
 import type { Group } from '@code-pushup/models';
-import { type RuleData } from './rules';
+import { type RuleData } from './parse';
 export declare function groupsFromRuleTypes(rules: RuleData[]): Group[];
 export declare function groupsFromRuleCategories(rules: RuleData[]): Group[];

package/src/lib/meta/index.d.ts

@@ -1,5 +1,6 @@
 import type { Audit, Group } from '@code-pushup/models';
 import type { ESLintTarget } from '../config';
+export { detectConfigVersion, type ConfigFormat } from './versions';
 export declare function listAuditsAndGroups(targets: ESLintTarget[]): Promise<{
     audits: Audit[];
     groups: Group[];

package/src/lib/meta/parse.d.ts

@@ -0,0 +1,12 @@
+import type { Linter, Rule } from 'eslint';
+export type RuleData = {
+    ruleId: string;
+    meta: Rule.RuleMetaData;
+    options: unknown[] | undefined;
+};
+export declare function parseRuleId(ruleId: string): {
+    plugin?: string;
+    name: string;
+};
+export declare function isRuleOff(entry: Linter.RuleEntry<unknown[]>): boolean;
+export declare function optionsFromRuleEntry(entry: Linter.RuleEntry<unknown[]>): unknown[];

package/src/lib/meta/rules.d.ts

@@ -1,12 +1,3 @@
-import type { Rule } from 'eslint';
 import type { ESLintTarget } from '../config';
-export type RuleData = {
-    ruleId: string;
-    meta: Rule.RuleMetaData;
-    options: unknown[] | undefined;
-};
+import type { RuleData } from './parse';
 export declare function listRules(targets: ESLintTarget[]): Promise<RuleData[]>;
-export declare function parseRuleId(ruleId: string): {
-    plugin?: string;
-    name: string;
-};

package/src/lib/meta/transform.d.ts

@@ -1,3 +1,3 @@
 import type { Audit } from '@code-pushup/models';
-import type { RuleData } from './rules';
+import type { RuleData } from './parse';
 export declare function ruleToAudit({ ruleId, meta, options }: RuleData): Audit;

package/src/lib/meta/versions/detect.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigFormat } from './formats';
+export declare function detectConfigVersion(): Promise<ConfigFormat>;

package/src/lib/meta/versions/flat.d.ts

@@ -0,0 +1,3 @@
+import type { ESLintTarget } from '../../config';
+import { type RuleData } from '../parse';
+export declare function loadRulesForFlatConfig({ eslintrc, }: Pick<ESLintTarget, 'eslintrc'>): Promise<RuleData[]>;

package/src/lib/meta/versions/formats.d.ts

@@ -0,0 +1 @@
+export type ConfigFormat = 'flat' | 'legacy';

package/src/lib/meta/versions/index.d.ts

@@ -0,0 +1,6 @@
+import type { ESLintTarget } from '../../config';
+import type { RuleData } from '../parse';
+import type { ConfigFormat } from './formats';
+export { detectConfigVersion } from './detect';
+export type { ConfigFormat } from './formats';
+export declare function selectRulesLoader(version: ConfigFormat): (target: ESLintTarget) => Promise<RuleData[]>;

package/src/lib/meta/versions/legacy.d.ts

@@ -0,0 +1,3 @@
+import type { ESLintTarget } from '../../config';
+import { type RuleData } from '../parse';
+export declare function loadRulesForLegacyConfig({ eslintrc, patterns, }: ESLintTarget): Promise<RuleData[]>;

package/src/lib/nx/utils.d.ts

@@ -1,4 +1,5 @@
 import type { ProjectConfiguration } from '@nx/devkit';
-export declare function findCodePushupEslintrc(project: ProjectConfiguration): Promise<string | null>;
-export declare function getLintFilePatterns(project: ProjectConfiguration): string[];
-export declare function getEslintConfig(project: ProjectConfiguration): string | undefined;
+import type { ConfigFormat } from '../meta';
+export declare function findCodePushupEslintConfig(project: ProjectConfiguration, format: ConfigFormat): Promise<string | undefined>;
+export declare function findEslintConfig(project: ProjectConfiguration, format: ConfigFormat): Promise<string | undefined>;
+export declare function getLintFilePatterns(project: ProjectConfiguration, format: ConfigFormat): string[];

package/src/lib/setup.d.ts

@@ -1,3 +1,3 @@
 import { ESLint } from 'eslint';
 import type { ESLintTarget } from './config';
-export declare function setupESLint(eslintrc: ESLintTarget['eslintrc']): ESLint;
+export declare function setupESLint(eslintrc: ESLintTarget['eslintrc']): Promise<ESLint>;