@code-pushup/eslint-plugin 0.34.0 → 0.39.0

package/bin.js

@@ -1,6 +1,6 @@
 // packages/plugin-eslint/src/lib/runner/index.ts
-import { writeFile } from "node:fs/promises";
-import { dirname, join as join2 } from "node:path";
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { dirname, join as join3 } from "node:path";
 
 // packages/models/src/lib/audit.ts
 import { z as z2 } from "zod";
@@ -578,10 +578,14 @@ function makeArraysComparisonSchema(diffSchema, resultSchema, description) {
     { description }
   );
 }
-var scorableMetaSchema = z14.object({ slug: slugSchema, title: titleSchema });
+var scorableMetaSchema = z14.object({
+  slug: slugSchema,
+  title: titleSchema,
+  docsUrl: docsUrlSchema
+});
 var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
   z14.object({
-    plugin: pluginMetaSchema.pick({ slug: true, title: true }).describe("Plugin which defines it")
+    plugin: pluginMetaSchema.pick({ slug: true, title: true, docsUrl: true }).describe("Plugin which defines it")
   })
 );
 var scorableDiffSchema = scorableMetaSchema.merge(
@@ -648,6 +652,9 @@ var reportsDiffSchema = z14.object({
   })
 );
 
+// packages/utils/src/lib/execute-process.ts
+import { spawn } from "node:child_process";
+
 // packages/utils/src/lib/file-system.ts
 import { bundleRequire } from "bundle-require";
 import chalk2 from "chalk";
@@ -730,7 +737,7 @@ async function ensureDirectoryExists(baseDir) {
     await mkdir(baseDir, { recursive: true });
     return;
   } catch (error) {
-    ui().logger.error(error.message);
+    ui().logger.info(error.message);
     if (error.code !== "EEXIST") {
       throw error;
     }
@@ -741,6 +748,9 @@ function pluginWorkDir(slug) {
 }
 
 // packages/utils/src/lib/reports/utils.ts
+function calcDuration(start, stop) {
+  return Math.round((stop ?? performance.now()) - start);
+}
 function compareIssueSeverity(severity1, severity2) {
   const levels = {
     info: 0,
@@ -750,6 +760,51 @@ function compareIssueSeverity(severity1, severity2) {
   return levels[severity1] - levels[severity2];
 }
 
+// packages/utils/src/lib/execute-process.ts
+var ProcessError = class extends Error {
+  code;
+  stderr;
+  stdout;
+  constructor(result) {
+    super(result.stderr);
+    this.code = result.code;
+    this.stderr = result.stderr;
+    this.stdout = result.stdout;
+  }
+};
+function executeProcess(cfg) {
+  const { observer, cwd, command, args, ignoreExitCode = false } = cfg;
+  const { onStdout, onError, onComplete } = observer ?? {};
+  const date = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  return new Promise((resolve, reject) => {
+    const process2 = spawn(command, args, { cwd, shell: true });
+    let stdout = "";
+    let stderr = "";
+    process2.stdout.on("data", (data) => {
+      stdout += String(data);
+      onStdout?.(String(data));
+    });
+    process2.stderr.on("data", (data) => {
+      stderr += String(data);
+    });
+    process2.on("error", (err) => {
+      stderr += err.toString();
+    });
+    process2.on("close", (code) => {
+      const timings = { date, duration: calcDuration(start) };
+      if (code === 0 || ignoreExitCode) {
+        onComplete?.();
+        resolve({ code, stdout, stderr, ...timings });
+      } else {
+        const errorMsg = new ProcessError({ code, stdout, stderr, ...timings });
+        onError?.(errorMsg);
+        reject(errorMsg);
+      }
+    });
+  });
+}
+
 // packages/utils/src/lib/git.ts
 import { simpleGit } from "simple-git";
 
@@ -777,6 +832,11 @@ import { MultiProgressBars } from "multi-progress-bars";
 // packages/utils/src/lib/reports/log-stdout-summary.ts
 import chalk4 from "chalk";
 
+// 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) {
@@ -792,34 +852,78 @@ async function lint({
   eslintrc,
   patterns
 }) {
+  const results = await executeLint({ eslintrc, patterns });
+  const ruleOptionsPerFile = await loadRuleOptionsPerFile(eslintrc, results);
+  return { results, ruleOptionsPerFile };
+}
+function executeLint({
+  eslintrc,
+  patterns
+}) {
+  return withConfig(eslintrc, async (configPath) => {
+    const { stdout } = await executeProcess({
+      command: "npx",
+      args: [
+        "eslint",
+        `--config=${configPath}`,
+        "--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);
+  });
+}
+function loadRuleOptionsPerFile(eslintrc, results) {
   const eslint = setupESLint(eslintrc);
-  const results = await eslint.lintFiles(patterns);
-  const ruleOptionsPerFile = await results.reduce(
-    async (acc, { filePath, messages }) => {
-      const filesMap = await acc;
-      const config = await eslint.calculateConfigForFile(
-        filePath
-      );
-      const ruleIds = distinct(
-        messages.map(({ ruleId }) => ruleId).filter((ruleId) => ruleId != null)
-      );
-      const rulesMap = Object.fromEntries(
-        ruleIds.map((ruleId) => [
-          ruleId,
-          toArray(config.rules?.[ruleId] ?? []).slice(1)
-        ])
-      );
-      return {
-        ...filesMap,
-        [filePath]: {
-          ...filesMap[filePath],
-          ...rulesMap
-        }
-      };
-    },
-    Promise.resolve({})
+  return results.reduce(async (acc, { filePath, messages }) => {
+    const filesMap = await acc;
+    const config = await eslint.calculateConfigForFile(
+      filePath
+    );
+    const ruleIds = distinct(
+      messages.map(({ ruleId }) => ruleId).filter((ruleId) => ruleId != null)
+    );
+    const rulesMap = Object.fromEntries(
+      ruleIds.map((ruleId) => [
+        ruleId,
+        toArray(config.rules?.[ruleId] ?? []).slice(1)
+      ])
+    );
+    return {
+      ...filesMap,
+      [filePath]: {
+        ...filesMap[filePath],
+        ...rulesMap
+      }
+    };
+  }, Promise.resolve({}));
+}
+async function withConfig(eslintrc, fn) {
+  if (typeof eslintrc === "string") {
+    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`
   );
-  return { results, ruleOptionsPerFile };
 }
 
 // packages/plugin-eslint/src/lib/meta/hash.ts
@@ -836,6 +940,15 @@ function jsonHash(data, bytes = 8) {
 }
 
 // packages/plugin-eslint/src/lib/runner/transform.ts
+function mergeLinterOutputs(outputs) {
+  return outputs.reduce(
+    (acc, { results, ruleOptionsPerFile }) => ({
+      results: [...acc.results, ...results],
+      ruleOptionsPerFile: { ...acc.ruleOptionsPerFile, ...ruleOptionsPerFile }
+    }),
+    { results: [], ruleOptionsPerFile: {} }
+  );
+}
 function lintResultsToAudits({
   results,
   ruleOptionsPerFile
@@ -845,7 +958,9 @@ function lintResultsToAudits({
   ).reduce((acc, issue) => {
     const { ruleId, message, filePath } = issue;
     if (!ruleId) {
-      ui().logger.warning(`ESLint core error - ${message}`);
+      ui().logger.warning(
+        `ESLint core error - ${message} (file: ${filePath})`
+      );
       return acc;
     }
     const options = ruleOptionsPerFile[filePath]?.[ruleId] ?? [];
@@ -903,20 +1018,21 @@ function convertSeverity(severity) {
 
 // packages/plugin-eslint/src/lib/runner/index.ts
 var WORKDIR = pluginWorkDir("eslint");
-var RUNNER_OUTPUT_PATH = join2(WORKDIR, "runner-output.json");
-var ESLINTRC_PATH = join2(process.cwd(), WORKDIR, ".eslintrc.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"
 );
 async function executeRunner() {
-  const { slugs, eslintrc, patterns } = await readJsonFile(PLUGIN_CONFIG_PATH);
-  const lintResults = await lint({
-    // if file created from inline object, provide inline to preserve relative links
-    eslintrc: eslintrc === ESLINTRC_PATH ? await readJsonFile(eslintrc) : eslintrc,
-    patterns
-  });
+  const { slugs, targets } = await readJsonFile(
+    PLUGIN_CONFIG_PATH
+  );
+  const linterOutputs = await targets.reduce(
+    async (acc, target) => [...await acc, await lint(target)],
+    Promise.resolve([])
+  );
+  const lintResults = mergeLinterOutputs(linterOutputs);
   const failedAudits = lintResultsToAudits(lintResults);
   const audits = slugs.map(
     (slug) => failedAudits.find((audit) => audit.slug === slug) ?? {
@@ -928,7 +1044,7 @@ async function executeRunner() {
     }
   );
   await ensureDirectoryExists(dirname(RUNNER_OUTPUT_PATH));
-  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(audits));
+  await writeFile2(RUNNER_OUTPUT_PATH, JSON.stringify(audits));
 }
 
 // packages/plugin-eslint/src/bin.ts

package/index.js

@@ -1,35 +1,20 @@
 // packages/plugin-eslint/src/lib/eslint-plugin.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/plugin-eslint/package.json
 var name = "@code-pushup/eslint-plugin";
-var version = "0.34.0";
+var version = "0.39.0";
 
 // packages/plugin-eslint/src/lib/config.ts
-import { z } from "zod";
-var eslintPluginConfigSchema = z.object({
-  eslintrc: z.union(
-    [
-      z.string({ description: "Path to ESLint config file" }),
-      z.record(z.string(), z.unknown(), {
-        description: "ESLint config object"
-      })
-    ],
-    { description: "ESLint config as file path or inline object" }
-  ),
-  patterns: z.union([z.string(), z.array(z.string()).min(1)], {
-    description: "Lint target files. May contain file paths, directory paths or glob patterns"
-  })
-});
+import { z as z15 } from "zod";
 
 // packages/models/src/lib/audit.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 
 // packages/models/src/lib/implementation/schemas.ts
 import { MATERIAL_ICONS } from "vscode-material-icons";
-import { z as z2 } from "zod";
+import { z } from "zod";
 
 // packages/models/src/lib/implementation/limits.ts
 var MAX_SLUG_LENGTH = 128;
@@ -96,21 +81,21 @@ function executionMetaSchema(options = {
   descriptionDate: "Execution start date and time",
   descriptionDuration: "Execution duration in ms"
 }) {
-  return z2.object({
-    date: z2.string({ description: options.descriptionDate }),
-    duration: z2.number({ description: options.descriptionDuration })
+  return z.object({
+    date: z.string({ description: options.descriptionDate }),
+    duration: z.number({ description: options.descriptionDuration })
   });
 }
-var slugSchema = z2.string({ description: "Unique ID (human-readable, URL-safe)" }).regex(slugRegex, {
+var slugSchema = z.string({ description: "Unique ID (human-readable, URL-safe)" }).regex(slugRegex, {
   message: "The slug has to follow the pattern [0-9a-z] followed by multiple optional groups of -[0-9a-z]. e.g. my-slug"
 }).max(MAX_SLUG_LENGTH, {
   message: `slug can be max ${MAX_SLUG_LENGTH} characters long`
 });
-var descriptionSchema = z2.string({ description: "Description (markdown)" }).max(MAX_DESCRIPTION_LENGTH).optional();
-var urlSchema = z2.string().url();
-var docsUrlSchema = urlSchema.optional().or(z2.literal("")).describe("Documentation site");
-var titleSchema = z2.string({ description: "Descriptive name" }).max(MAX_TITLE_LENGTH);
-var scoreSchema = z2.number({
+var descriptionSchema = z.string({ description: "Description (markdown)" }).max(MAX_DESCRIPTION_LENGTH).optional();
+var urlSchema = z.string().url();
+var docsUrlSchema = urlSchema.optional().or(z.literal("")).describe("Documentation site");
+var titleSchema = z.string({ description: "Descriptive name" }).max(MAX_TITLE_LENGTH);
+var scoreSchema = z.number({
   description: "Value between 0 and 1"
 }).min(0).max(1);
 function metaSchema(options) {
@@ -120,7 +105,7 @@ function metaSchema(options) {
     docsUrlDescription,
     description
   } = options ?? {};
-  return z2.object(
+  return z.object(
     {
       title: titleDescription ? titleSchema.describe(titleDescription) : titleSchema,
       description: descriptionDescription ? descriptionSchema.describe(descriptionDescription) : descriptionSchema,
@@ -129,17 +114,17 @@ function metaSchema(options) {
     { description }
   );
 }
-var filePathSchema = z2.string().trim().min(1, { message: "path is invalid" });
-var fileNameSchema = z2.string().trim().regex(filenameRegex, {
+var filePathSchema = z.string().trim().min(1, { message: "path is invalid" });
+var fileNameSchema = z.string().trim().regex(filenameRegex, {
   message: `The filename has to be valid`
 }).min(1, { message: "file name is invalid" });
-var positiveIntSchema = z2.number().int().positive();
-var nonnegativeIntSchema = z2.number().int().nonnegative();
+var positiveIntSchema = z.number().int().positive();
+var nonnegativeIntSchema = z.number().int().nonnegative();
 function packageVersionSchema(options) {
   const { versionDescription = "NPM version of the package", required } = options ?? {};
-  const packageSchema = z2.string({ description: "NPM package name" });
-  const versionSchema = z2.string({ description: versionDescription });
-  return z2.object(
+  const packageSchema = z.string({ description: "NPM package name" });
+  const versionSchema = z.string({ description: versionDescription });
+  return z.object(
     {
       packageName: required ? packageSchema : packageSchema.optional(),
       version: required ? versionSchema : versionSchema.optional()
@@ -151,7 +136,7 @@ var weightSchema = nonnegativeIntSchema.describe(
   "Coefficient for the given score (use weight 0 if only for display)"
 );
 function weightedRefSchema(description, slugDescription) {
-  return z2.object(
+  return z.object(
     {
       slug: slugSchema.describe(slugDescription),
       weight: weightSchema.describe("Weight used to calculate score")
@@ -160,10 +145,10 @@ function weightedRefSchema(description, slugDescription) {
   );
 }
 function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessageFn) {
-  return z2.object(
+  return z.object(
     {
       slug: slugSchema.describe('Human-readable unique ID, e.g. "performance"'),
-      refs: z2.array(refSchema).min(1).refine(
+      refs: z.array(refSchema).min(1).refine(
         (refs) => !duplicateCheckFn(refs),
         (refs) => ({
           message: duplicateMessageFn(refs)
@@ -175,7 +160,7 @@ function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessa
     { description }
   );
 }
-var materialIconSchema = z2.enum(MATERIAL_ICONS, {
+var materialIconSchema = z.enum(MATERIAL_ICONS, {
   description: "Icon from VSCode Material Icons extension"
 });
 function hasNonZeroWeightedRef(refs) {
@@ -183,7 +168,7 @@ function hasNonZeroWeightedRef(refs) {
 }
 
 // packages/models/src/lib/audit.ts
-var auditSchema = z3.object({
+var auditSchema = z2.object({
   slug: slugSchema.describe("ID (unique within plugin)")
 }).merge(
   metaSchema({
@@ -193,7 +178,7 @@ var auditSchema = z3.object({
     description: "List of scorable metrics for the given plugin"
   })
 );
-var pluginAuditsSchema = z3.array(auditSchema, {
+var pluginAuditsSchema = z2.array(auditSchema, {
   description: "List of audits maintained in a plugin"
 }).min(1).refine(
   (auditMetadata) => !getDuplicateSlugsInAudits(auditMetadata),
@@ -212,14 +197,14 @@ function getDuplicateSlugsInAudits(audits) {
 }
 
 // packages/models/src/lib/audit-output.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // packages/models/src/lib/issue.ts
-import { z as z4 } from "zod";
-var sourceFileLocationSchema = z4.object(
+import { z as z3 } from "zod";
+var sourceFileLocationSchema = z3.object(
   {
     file: filePathSchema.describe("Relative path to source file in Git repo"),
-    position: z4.object(
+    position: z3.object(
       {
         startLine: positiveIntSchema.describe("Start line"),
         startColumn: positiveIntSchema.describe("Start column").optional(),
@@ -231,12 +216,12 @@ var sourceFileLocationSchema = z4.object(
   },
   { description: "Source file location" }
 );
-var issueSeveritySchema = z4.enum(["info", "warning", "error"], {
+var issueSeveritySchema = z3.enum(["info", "warning", "error"], {
   description: "Severity level"
 });
-var issueSchema = z4.object(
+var issueSchema = z3.object(
   {
-    message: z4.string({ description: "Descriptive error message" }).max(MAX_ISSUE_MESSAGE_LENGTH),
+    message: z3.string({ description: "Descriptive error message" }).max(MAX_ISSUE_MESSAGE_LENGTH),
     severity: issueSeveritySchema,
     source: sourceFileLocationSchema.optional()
   },
@@ -245,14 +230,14 @@ var issueSchema = z4.object(
 
 // packages/models/src/lib/audit-output.ts
 var auditValueSchema = nonnegativeIntSchema.describe("Raw numeric value");
-var auditDisplayValueSchema = z5.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
-var auditDetailsSchema = z5.object(
+var auditDisplayValueSchema = z4.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
+var auditDetailsSchema = z4.object(
   {
-    issues: z5.array(issueSchema, { description: "List of findings" })
+    issues: z4.array(issueSchema, { description: "List of findings" })
   },
   { description: "Detailed information" }
 );
-var auditOutputSchema = z5.object(
+var auditOutputSchema = z4.object(
   {
     slug: slugSchema.describe("Reference to audit"),
     displayValue: auditDisplayValueSchema,
@@ -262,7 +247,7 @@ var auditOutputSchema = z5.object(
   },
   { description: "Audit information" }
 );
-var auditOutputsSchema = z5.array(auditOutputSchema, {
+var auditOutputsSchema = z4.array(auditOutputSchema, {
   description: "List of JSON formatted audit output emitted by the runner process of a plugin"
 }).refine(
   (audits) => !getDuplicateSlugsInAudits2(audits),
@@ -279,13 +264,13 @@ function getDuplicateSlugsInAudits2(audits) {
 }
 
 // packages/models/src/lib/category-config.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var categoryRefSchema = weightedRefSchema(
   "Weighted references to audits and/or groups for the category",
   "Slug of an audit or group (depending on `type`)"
 ).merge(
-  z6.object({
-    type: z6.enum(["audit", "group"], {
+  z5.object({
+    type: z5.enum(["audit", "group"], {
       description: "Discriminant for reference kind, affects where `slug` is looked up"
     }),
     plugin: slugSchema.describe(
@@ -306,8 +291,8 @@ var categoryConfigSchema = scorableSchema(
     description: "Meta info for category"
   })
 ).merge(
-  z6.object({
-    isBinary: z6.boolean({
+  z5.object({
+    isBinary: z5.boolean({
       description: 'Is this a binary category (i.e. only a perfect score considered a "pass")?'
     }).optional()
   })
@@ -323,7 +308,7 @@ function getDuplicateRefsInCategoryMetrics(metrics) {
     metrics.map(({ slug, type, plugin }) => `${type} :: ${plugin} / ${slug}`)
   );
 }
-var categoriesSchema = z6.array(categoryConfigSchema, {
+var categoriesSchema = z5.array(categoryConfigSchema, {
   description: "Categorization of individual audits"
 }).refine(
   (categoryCfg) => !getDuplicateSlugCategories(categoryCfg),
@@ -342,18 +327,18 @@ function getDuplicateSlugCategories(categories) {
 }
 
 // packages/models/src/lib/commit.ts
-import { z as z7 } from "zod";
-var commitSchema = z7.object(
+import { z as z6 } from "zod";
+var commitSchema = z6.object(
   {
-    hash: z7.string({ description: "Commit SHA (full)" }).regex(
+    hash: z6.string({ description: "Commit SHA (full)" }).regex(
       /^[\da-f]{40}$/,
       "Commit SHA should be a 40-character hexadecimal string"
     ),
-    message: z7.string({ description: "Commit message" }),
-    date: z7.coerce.date({
+    message: z6.string({ description: "Commit message" }),
+    date: z6.coerce.date({
       description: "Date and time when commit was authored"
     }),
-    author: z7.string({
+    author: z6.string({
       description: "Commit author name"
     }).trim()
   },
@@ -361,22 +346,22 @@ var commitSchema = z7.object(
 );
 
 // packages/models/src/lib/core-config.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 
 // packages/models/src/lib/persist-config.ts
-import { z as z8 } from "zod";
-var formatSchema = z8.enum(["json", "md"]);
-var persistConfigSchema = z8.object({
+import { z as z7 } from "zod";
+var formatSchema = z7.enum(["json", "md"]);
+var persistConfigSchema = z7.object({
   outputDir: filePathSchema.describe("Artifacts folder").optional(),
   filename: fileNameSchema.describe("Artifacts file name (without extension)").optional(),
-  format: z8.array(formatSchema).optional()
+  format: z7.array(formatSchema).optional()
 });
 
 // packages/models/src/lib/plugin-config.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 
 // packages/models/src/lib/group.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var groupRefSchema = weightedRefSchema(
   "Weighted reference to a group",
   "Reference slug to a group within this plugin (e.g. 'max-lines')"
@@ -393,7 +378,7 @@ var groupSchema = scorableSchema(
   getDuplicateRefsInGroups,
   duplicateRefsInGroupsErrorMsg
 ).merge(groupMetaSchema);
-var groupsSchema = z9.array(groupSchema, {
+var groupsSchema = z8.array(groupSchema, {
   description: "List of groups"
 }).optional().refine(
   (groups) => !getDuplicateSlugsInGroups(groups),
@@ -421,14 +406,14 @@ function getDuplicateSlugsInGroups(groups) {
 }
 
 // packages/models/src/lib/runner-config.ts
-import { z as z10 } from "zod";
-var outputTransformSchema = z10.function().args(z10.unknown()).returns(z10.union([auditOutputsSchema, z10.promise(auditOutputsSchema)]));
-var runnerConfigSchema = z10.object(
+import { z as z9 } from "zod";
+var outputTransformSchema = z9.function().args(z9.unknown()).returns(z9.union([auditOutputsSchema, z9.promise(auditOutputsSchema)]));
+var runnerConfigSchema = z9.object(
   {
-    command: z10.string({
+    command: z9.string({
       description: "Shell command to execute"
     }),
-    args: z10.array(z10.string({ description: "Command arguments" })).optional(),
+    args: z9.array(z9.string({ description: "Command arguments" })).optional(),
     outputFile: filePathSchema.describe("Output path"),
     outputTransform: outputTransformSchema.optional()
   },
@@ -436,8 +421,8 @@ var runnerConfigSchema = z10.object(
     description: "How to execute runner"
   }
 );
-var onProgressSchema = z10.function().args(z10.unknown()).returns(z10.void());
-var runnerFunctionSchema = z10.function().args(onProgressSchema.optional()).returns(z10.union([auditOutputsSchema, z10.promise(auditOutputsSchema)]));
+var onProgressSchema = z9.function().args(z9.unknown()).returns(z9.void());
+var runnerFunctionSchema = z9.function().args(onProgressSchema.optional()).returns(z9.union([auditOutputsSchema, z9.promise(auditOutputsSchema)]));
 
 // packages/models/src/lib/plugin-config.ts
 var pluginMetaSchema = packageVersionSchema().merge(
@@ -448,13 +433,13 @@ var pluginMetaSchema = packageVersionSchema().merge(
     description: "Plugin metadata"
   })
 ).merge(
-  z11.object({
+  z10.object({
     slug: slugSchema.describe("Unique plugin slug within core config"),
     icon: materialIconSchema
   })
 );
-var pluginDataSchema = z11.object({
-  runner: z11.union([runnerConfigSchema, runnerFunctionSchema]),
+var pluginDataSchema = z10.object({
+  runner: z10.union([runnerConfigSchema, runnerFunctionSchema]),
   audits: pluginAuditsSchema,
   groups: groupsSchema
 });
@@ -480,22 +465,22 @@ function getMissingRefsFromGroups(pluginCfg) {
 }
 
 // packages/models/src/lib/upload-config.ts
-import { z as z12 } from "zod";
-var uploadConfigSchema = z12.object({
+import { z as z11 } from "zod";
+var uploadConfigSchema = z11.object({
   server: urlSchema.describe("URL of deployed portal API"),
-  apiKey: z12.string({
+  apiKey: z11.string({
     description: "API key with write access to portal (use `process.env` for security)"
   }),
   organization: slugSchema.describe(
     "Organization slug from Code PushUp portal"
   ),
   project: slugSchema.describe("Project slug from Code PushUp portal"),
-  timeout: z12.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
+  timeout: z11.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
 });
 
 // packages/models/src/lib/core-config.ts
-var unrefinedCoreConfigSchema = z13.object({
-  plugins: z13.array(pluginConfigSchema, {
+var unrefinedCoreConfigSchema = z12.object({
+  plugins: z12.array(pluginConfigSchema, {
     description: "List of plugins to be used (official, community-provided, or custom)"
   }).min(1),
   /** portal configuration for persisting results */
@@ -518,7 +503,7 @@ function refineCoreConfig(schema) {
 }
 
 // packages/models/src/lib/report.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 var auditReportSchema = auditSchema.merge(auditOutputSchema);
 var pluginReportSchema = pluginMetaSchema.merge(
   executionMetaSchema({
@@ -526,9 +511,9 @@ var pluginReportSchema = pluginMetaSchema.merge(
     descriptionDuration: "Duration of the plugin run in ms"
   })
 ).merge(
-  z14.object({
-    audits: z14.array(auditReportSchema).min(1),
-    groups: z14.array(groupSchema).optional()
+  z13.object({
+    audits: z13.array(auditReportSchema).min(1),
+    groups: z13.array(groupSchema).optional()
   })
 ).refine(
   (pluginReport) => !getMissingRefsFromGroups2(pluginReport.audits, pluginReport.groups ?? []),
@@ -562,10 +547,10 @@ var reportSchema = packageVersionSchema({
     descriptionDuration: "Duration of the collect run in ms"
   })
 ).merge(
-  z14.object(
+  z13.object(
     {
-      categories: z14.array(categoryConfigSchema),
-      plugins: z14.array(pluginReportSchema).min(1),
+      categories: z13.array(categoryConfigSchema),
+      plugins: z13.array(pluginReportSchema).min(1),
       commit: commitSchema.describe("Git commit for which report was collected").nullable()
     },
     { description: "Collect output data" }
@@ -581,36 +566,40 @@ var reportSchema = packageVersionSchema({
 );
 
 // packages/models/src/lib/reports-diff.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 function makeComparisonSchema(schema) {
   const sharedDescription = schema.description || "Result";
-  return z15.object({
+  return z14.object({
     before: schema.describe(`${sharedDescription} (source commit)`),
     after: schema.describe(`${sharedDescription} (target commit)`)
   });
 }
 function makeArraysComparisonSchema(diffSchema, resultSchema, description) {
-  return z15.object(
+  return z14.object(
     {
-      changed: z15.array(diffSchema),
-      unchanged: z15.array(resultSchema),
-      added: z15.array(resultSchema),
-      removed: z15.array(resultSchema)
+      changed: z14.array(diffSchema),
+      unchanged: z14.array(resultSchema),
+      added: z14.array(resultSchema),
+      removed: z14.array(resultSchema)
     },
     { description }
   );
 }
-var scorableMetaSchema = z15.object({ slug: slugSchema, title: titleSchema });
+var scorableMetaSchema = z14.object({
+  slug: slugSchema,
+  title: titleSchema,
+  docsUrl: docsUrlSchema
+});
 var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
-  z15.object({
-    plugin: pluginMetaSchema.pick({ slug: true, title: true }).describe("Plugin which defines it")
+  z14.object({
+    plugin: pluginMetaSchema.pick({ slug: true, title: true, docsUrl: true }).describe("Plugin which defines it")
   })
 );
 var scorableDiffSchema = scorableMetaSchema.merge(
-  z15.object({
+  z14.object({
     scores: makeComparisonSchema(scoreSchema).merge(
-      z15.object({
-        diff: z15.number().min(-1).max(1).describe("Score change (`scores.after - scores.before`)")
+      z14.object({
+        diff: z14.number().min(-1).max(1).describe("Score change (`scores.after - scores.before`)")
       })
     ).describe("Score comparison")
   })
@@ -621,10 +610,10 @@ var scorableWithPluginDiffSchema = scorableDiffSchema.merge(
 var categoryDiffSchema = scorableDiffSchema;
 var groupDiffSchema = scorableWithPluginDiffSchema;
 var auditDiffSchema = scorableWithPluginDiffSchema.merge(
-  z15.object({
+  z14.object({
     values: makeComparisonSchema(auditValueSchema).merge(
-      z15.object({
-        diff: z15.number().int().describe("Value change (`values.after - values.before`)")
+      z14.object({
+        diff: z14.number().int().describe("Value change (`values.after - values.before`)")
       })
     ).describe("Audit `value` comparison"),
     displayValues: makeComparisonSchema(auditDisplayValueSchema).describe(
@@ -633,15 +622,15 @@ var auditDiffSchema = scorableWithPluginDiffSchema.merge(
   })
 );
 var categoryResultSchema = scorableMetaSchema.merge(
-  z15.object({ score: scoreSchema })
+  z14.object({ score: scoreSchema })
 );
 var groupResultSchema = scorableWithPluginMetaSchema.merge(
-  z15.object({ score: scoreSchema })
+  z14.object({ score: scoreSchema })
 );
 var auditResultSchema = scorableWithPluginMetaSchema.merge(
   auditOutputSchema.pick({ score: true, value: true, displayValue: true })
 );
-var reportsDiffSchema = z15.object({
+var reportsDiffSchema = z14.object({
   commits: makeComparisonSchema(commitSchema).nullable().describe("Commits identifying compared reports"),
   categories: makeArraysComparisonSchema(
     categoryDiffSchema,
@@ -740,7 +729,7 @@ async function ensureDirectoryExists(baseDir) {
     await mkdir(baseDir, { recursive: true });
     return;
   } catch (error) {
-    ui().logger.error(error.message);
+    ui().logger.info(error.message);
     if (error.code !== "EEXIST") {
       throw error;
     }
@@ -771,6 +760,23 @@ import { MultiProgressBars } from "multi-progress-bars";
 // packages/utils/src/lib/reports/log-stdout-summary.ts
 import chalk4 from "chalk";
 
+// packages/plugin-eslint/src/lib/config.ts
+var eslintTargetSchema = z15.object({
+  eslintrc: z15.union(
+    [
+      z15.string({ description: "Path to ESLint config file" }),
+      z15.record(z15.string(), z15.unknown(), {
+        description: "ESLint config object"
+      })
+    ],
+    { description: "ESLint config as file path or inline object" }
+  ),
+  patterns: z15.union([z15.string(), z15.array(z15.string()).min(1)], {
+    description: "Lint target files. May contain file paths, directory paths or glob patterns"
+  })
+});
+var eslintPluginConfigSchema = z15.union([eslintTargetSchema, z15.array(eslintTargetSchema).min(1)]).transform(toArray);
+
 // packages/plugin-eslint/src/lib/meta/hash.ts
 import { createHash } from "node:crypto";
 function ruleIdToSlug(ruleId, options) {
@@ -784,8 +790,27 @@ 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 } : { baseConfig: eslintrc },
+    useEslintrc: false,
+    errorOnUnmatchedPattern: false
+  });
+}
+
 // packages/plugin-eslint/src/lib/meta/rules.ts
-async function listRules(eslint, patterns) {
+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,
@@ -803,31 +828,39 @@ async function listRules(eslint, patterns) {
       suppressedMessages: []
     }
   ]);
-  const rulesMap = 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;
+  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
       }
-      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
   );
-  return Object.values(rulesMap).flatMap(Object.values);
 }
 function isRuleOff(entry) {
   const level = Array.isArray(entry) ? entry[0] : entry;
@@ -941,8 +974,8 @@ function ruleToAudit({ ruleId, meta, options }) {
 }
 
 // packages/plugin-eslint/src/lib/meta/index.ts
-async function listAuditsAndGroups(eslint, patterns) {
-  const rules = await listRules(eslint, patterns);
+async function listAuditsAndGroups(targets) {
+  const rules = await listRules(targets);
   const audits = rules.map(ruleToAudit);
   const groups = [
     ...groupsFromRuleTypes(rules),
@@ -954,31 +987,17 @@ async function listAuditsAndGroups(eslint, patterns) {
 // packages/plugin-eslint/src/lib/runner/index.ts
 import { writeFile } from "node:fs/promises";
 import { dirname, 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 } : { baseConfig: eslintrc },
-    useEslintrc: false,
-    errorOnUnmatchedPattern: false
-  });
-}
-
-// packages/plugin-eslint/src/lib/runner/index.ts
 var WORKDIR = pluginWorkDir("eslint");
 var RUNNER_OUTPUT_PATH = join2(WORKDIR, "runner-output.json");
-var ESLINTRC_PATH = join2(process.cwd(), WORKDIR, ".eslintrc.json");
 var PLUGIN_CONFIG_PATH = join2(
   process.cwd(),
   WORKDIR,
   "plugin-config.json"
 );
-async function createRunnerConfig(scriptPath, audits, eslintrc, patterns) {
+async function createRunnerConfig(scriptPath, audits, targets) {
   const config = {
-    eslintrc,
-    slugs: audits.map((audit) => audit.slug),
-    patterns: toArray(patterns)
+    targets,
+    slugs: audits.map((audit) => audit.slug)
   };
   await ensureDirectoryExists(dirname(PLUGIN_CONFIG_PATH));
   await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));
@@ -991,14 +1010,8 @@ async function createRunnerConfig(scriptPath, audits, eslintrc, patterns) {
 
 // packages/plugin-eslint/src/lib/eslint-plugin.ts
 async function eslintPlugin(config) {
-  const { eslintrc, patterns } = eslintPluginConfigSchema.parse(config);
-  const eslint = setupESLint(eslintrc);
-  const { audits, groups } = await listAuditsAndGroups(eslint, patterns);
-  if (typeof eslintrc !== "string") {
-    await mkdir2(dirname2(ESLINTRC_PATH), { recursive: true });
-    await writeFile2(ESLINTRC_PATH, JSON.stringify(eslintrc));
-  }
-  const eslintrcPath = typeof eslintrc === "string" ? eslintrc : ESLINTRC_PATH;
+  const targets = eslintPluginConfigSchema.parse(config);
+  const { audits, groups } = await listAuditsAndGroups(targets);
   const runnerScriptPath = join3(
     fileURLToPath(dirname2(import.meta.url)),
     "bin.js"
@@ -1013,12 +1026,7 @@ async function eslintPlugin(config) {
     version,
     audits,
     groups,
-    runner: await createRunnerConfig(
-      runnerScriptPath,
-      audits,
-      eslintrcPath,
-      patterns
-    )
+    runner: await createRunnerConfig(runnerScriptPath, audits, targets)
   };
 }
 
@@ -1049,33 +1057,27 @@ 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 eslintConfig = {
-    root: true,
-    overrides: await Promise.all(
-      projects.map(async (project) => ({
-        files: getLintFilePatterns(project),
-        extends: await findCodePushupEslintrc(project) ?? getEslintConfig(project)
-      }))
+  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
+        ]
+      })
     )
-  };
-  const patterns = projects.flatMap((project) => [
-    ...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
-  ]);
-  return {
-    eslintrc: eslintConfig,
-    patterns
-  };
+  );
 }
 
 // packages/plugin-eslint/src/lib/nx/find-all-projects.ts

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@code-pushup/eslint-plugin",
-  "version": "0.34.0",
+  "version": "0.39.0",
   "license": "MIT",
   "dependencies": {
-    "@code-pushup/utils": "0.34.0",
-    "@code-pushup/models": "0.34.0",
+    "@code-pushup/utils": "0.39.0",
+    "@code-pushup/models": "0.39.0",
     "eslint": "^8.46.0",
     "zod": "^3.22.4"
   },

package/src/lib/config.d.ts

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

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

@@ -1,6 +1,6 @@
-import type { ESLint } from 'eslint';
 import type { Audit, Group } from '@code-pushup/models';
-export declare function listAuditsAndGroups(eslint: ESLint, patterns: string | string[]): Promise<{
+import type { ESLintTarget } from '../config';
+export declare function listAuditsAndGroups(targets: ESLintTarget[]): Promise<{
     audits: Audit[];
     groups: Group[];
 }>;

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

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

package/src/lib/nx/find-all-projects.d.ts

@@ -1,4 +1,4 @@
-import type { ESLintPluginConfig } from '../config';
+import type { ESLintTarget } from '../config';
 /**
  * Finds all Nx projects in workspace and converts their lint configurations to Code PushUp ESLint plugin parameters.
  *
@@ -20,4 +20,4 @@ import type { ESLintPluginConfig } from '../config';
  *
  * @returns ESLint config and patterns, intended to be passed to {@link eslintPlugin}
  */
-export declare function eslintConfigFromNxProjects(): Promise<ESLintPluginConfig>;
+export declare function eslintConfigFromNxProjects(): Promise<ESLintTarget[]>;

package/src/lib/nx/find-project-with-deps.d.ts

@@ -1,4 +1,4 @@
-import type { ESLintPluginConfig } from '../config';
+import type { ESLintTarget } from '../config';
 /**
  * Accepts a target Nx projects, finds projects it depends on, and converts lint configurations to Code PushUp ESLint plugin parameters.
  *
@@ -23,4 +23,4 @@ import type { ESLintPluginConfig } from '../config';
  * @param projectName Nx project serving as main entry point
  * @returns ESLint config and patterns, intended to be passed to {@link eslintPlugin}
  */
-export declare function eslintConfigFromNxProject(projectName: string): Promise<ESLintPluginConfig>;
+export declare function eslintConfigFromNxProject(projectName: string): Promise<ESLintTarget[]>;

package/src/lib/nx/projects-to-config.d.ts

@@ -1,3 +1,3 @@
 import type { ProjectConfiguration, ProjectGraph } from '@nx/devkit';
-import type { ESLintPluginConfig } from '../config';
-export declare function nxProjectsToConfig(projectGraph: ProjectGraph, predicate?: (project: ProjectConfiguration) => boolean): Promise<ESLintPluginConfig>;
+import type { ESLintTarget } from '../config';
+export declare function nxProjectsToConfig(projectGraph: ProjectGraph, predicate?: (project: ProjectConfiguration) => boolean): Promise<ESLintTarget[]>;

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

@@ -1,7 +1,7 @@
 import type { Audit, RunnerConfig } from '@code-pushup/models';
+import { type ESLintTarget } from '../config';
 export declare const WORKDIR: string;
 export declare const RUNNER_OUTPUT_PATH: string;
-export declare const ESLINTRC_PATH: string;
 export declare const PLUGIN_CONFIG_PATH: string;
 export declare function executeRunner(): Promise<void>;
-export declare function createRunnerConfig(scriptPath: string, audits: Audit[], eslintrc: string, patterns: string | string[]): Promise<RunnerConfig>;
+export declare function createRunnerConfig(scriptPath: string, audits: Audit[], targets: ESLintTarget[]): Promise<RunnerConfig>;

package/src/lib/runner/lint.d.ts

@@ -1,3 +1,3 @@
-import { ESLintPluginConfig } from '../config';
+import type { ESLintTarget } from '../config';
 import type { LinterOutput } from './types';
-export declare function lint({ eslintrc, patterns, }: ESLintPluginConfig): Promise<LinterOutput>;
+export declare function lint({ eslintrc, patterns, }: ESLintTarget): Promise<LinterOutput>;

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

@@ -1,3 +1,4 @@
 import type { AuditOutput } from '@code-pushup/models';
 import type { LinterOutput } from './types';
+export declare function mergeLinterOutputs(outputs: LinterOutput[]): LinterOutput;
 export declare function lintResultsToAudits({ results, ruleOptionsPerFile, }: LinterOutput): AuditOutput[];

package/src/lib/setup.d.ts

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