@code-pushup/coverage-plugin 0.30.0-alpha → 0.35.0

package/index.js

@@ -698,6 +698,21 @@ async function ensureDirectoryExists(baseDir) {
     }
   }
 }
+var NoExportError = class extends Error {
+  constructor(filepath) {
+    super(`No default export found in ${filepath}`);
+  }
+};
+async function importEsmModule(options) {
+  const { mod } = await bundleRequire({
+    format: "esm",
+    ...options
+  });
+  if (!("default" in mod)) {
+    throw new NoExportError(options.filepath);
+  }
+  return mod.default;
+}
 function pluginWorkDir(slug) {
   return join("node_modules", ".code-pushup", slug);
 }
@@ -721,7 +736,7 @@ import chalk4 from "chalk";
 
 // packages/plugin-coverage/package.json
 var name = "@code-pushup/coverage-plugin";
-var version = "0.29.0";
+var version = "0.35.0";
 
 // packages/plugin-coverage/src/lib/config.ts
 import { z as z15 } from "zod";
@@ -857,23 +872,31 @@ async function getNxCoveragePaths(targets = ["test"], verbose) {
   }
   const { createProjectGraphAsync } = await import("@nx/devkit");
   const { nodes } = await createProjectGraphAsync({ exitOnError: false });
-  const coverageResults = targets.map((target) => {
-    const relevantNodes = Object.values(nodes).filter(
-      (graph) => hasNxTarget(graph, target)
-    );
-    return relevantNodes.map(({ name: name2, data }) => {
-      const targetConfig = data.targets?.[target];
-      const coveragePath = getCoveragePathForTarget(target, targetConfig, name2);
-      const rootToReportsDir = join4(data.root, coveragePath);
-      if (verbose) {
-        ui().logger.info(`- ${name2}: ${target}`);
-      }
-      return {
-        pathToProject: data.root,
-        resultsPath: join4(rootToReportsDir, "lcov.info")
-      };
-    });
-  });
+  const coverageResults = await Promise.all(
+    targets.map(async (target) => {
+      const relevantNodes = Object.values(nodes).filter(
+        (graph) => hasNxTarget(graph, target)
+      );
+      return await Promise.all(
+        relevantNodes.map(async ({ name: name2, data }) => {
+          const targetConfig = data.targets?.[target];
+          const coveragePath = await getCoveragePathForTarget(
+            target,
+            targetConfig,
+            name2
+          );
+          const rootToReportsDir = join4(data.root, coveragePath);
+          if (verbose) {
+            ui().logger.info(`- ${name2}: ${target}`);
+          }
+          return {
+            pathToProject: data.root,
+            resultsPath: join4(rootToReportsDir, "lcov.info")
+          };
+        })
+      );
+    })
+  );
   if (verbose) {
     ui().logger.info("\n");
   }
@@ -882,21 +905,39 @@ async function getNxCoveragePaths(targets = ["test"], verbose) {
 function hasNxTarget(project, target) {
   return project.data.targets != null && target in project.data.targets;
 }
-function getCoveragePathForTarget(target, targetConfig, projectName) {
+async function getCoveragePathForTarget(target, targetConfig, projectName) {
+  const { config } = targetConfig.options;
   if (targetConfig.executor?.includes("@nx/vite")) {
-    const { reportsDirectory } = targetConfig.options;
+    const testConfig = await importEsmModule({
+      filepath: config
+    });
+    const reportsDirectory = testConfig.test.coverage?.reportsDirectory;
+    const reporter = testConfig.test.coverage?.reporter;
     if (reportsDirectory == null) {
       throw new Error(
-        `Coverage configuration not found for target ${target} in ${projectName}. Define your Vitest coverage directory in the reportsDirectory option.`
+        `Vitest coverage configuration at ${config} does not include coverage path for target ${target} in ${projectName}. Add the path under coverage > reportsDirectory.`
+      );
+    }
+    if (!reporter?.includes("lcov")) {
+      throw new Error(
+        `Vitest coverage configuration at ${config} does not include LCOV report format for target ${target} in ${projectName}. Add 'lcov' format under coverage > reporter.`
       );
     }
     return reportsDirectory;
   }
   if (targetConfig.executor?.includes("@nx/jest")) {
-    const { coverageDirectory } = targetConfig.options;
+    const testConfig = await importEsmModule({
+      filepath: config
+    });
+    const coverageDirectory = testConfig.coverageDirectory;
     if (coverageDirectory == null) {
       throw new Error(
-        `Coverage configuration not found for target ${target} in ${projectName}. Define your Jest coverage directory in the coverageDirectory option.`
+        `Jest coverage configuration at ${config} does not include coverage path for target ${target} in ${projectName}. Add the path under coverageDirectory.`
+      );
+    }
+    if (!testConfig.coverageReporters?.includes("lcov")) {
+      throw new Error(
+        `Jest coverage configuration at ${config} does not include LCOV report format for target ${target} in ${projectName}. Add 'lcov' format under coverageReporters.`
       );
     }
     return coverageDirectory;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@code-pushup/coverage-plugin",
-  "version": "0.30.0-alpha",
+  "version": "0.35.0",
   "dependencies": {
-    "@code-pushup/models": "*",
-    "@code-pushup/utils": "*",
+    "@code-pushup/models": "0.35.0",
+    "@code-pushup/utils": "0.35.0",
     "parse-lcov": "^1.0.4",
     "chalk": "^5.3.0",
     "zod": "^3.22.4"

package/src/lib/nx/coverage-paths.d.ts

@@ -1,6 +1,20 @@
+import type { TargetConfiguration } from '@nx/devkit';
 import { CoverageResult } from '../config';
 /**
  * @param targets nx targets to be used for measuring coverage, test by default
  * @returns An array of coverage result information for the coverage plugin.
  */
 export declare function getNxCoveragePaths(targets?: string[], verbose?: boolean): Promise<CoverageResult[]>;
+export type VitestCoverageConfig = {
+    test: {
+        coverage?: {
+            reporter?: string[];
+            reportsDirectory?: string;
+        };
+    };
+};
+export type JestCoverageConfig = {
+    coverageDirectory?: string;
+    coverageReporters?: string[];
+};
+export declare function getCoveragePathForTarget(target: string, targetConfig: TargetConfiguration, projectName: string): Promise<string>;