headlamp 0.1.29 → 0.1.31

package/dist/cli.cjs

@@ -60898,6 +60898,8 @@ var program = async () => {
   let jestExitCode = 0;
   const allBridgeJson = [];
   const executedTestFilesSet = /* @__PURE__ */ new Set();
+  const coverageFailureLines = [];
+  let anyTestFailed = false;
   if (shouldRunJest) {
     console.info("Starting Jest (no Vitest targets)\u2026");
     await runJestBootstrap(bootstrapCommand);
@@ -61486,6 +61488,17 @@ ${stripFooter(rawAlso)}`.trimEnd();
       } catch {
       }
       pretty = stripFooter(pretty);
+      try {
+        const simpleOut = stripAnsiSimple(output);
+        const lines = simpleOut.split(/\r?\n/).map((ln2) => ln2.trim()).filter(Boolean);
+        const matches = lines.filter(
+          (ln2) => /Coverage for (Statements|Branches|Functions|Lines)/i.test(ln2) && /does not meet/i.test(ln2)
+        );
+        for (const m3 of matches) {
+          if (!coverageFailureLines.includes(m3)) coverageFailureLines.push(m3);
+        }
+      } catch {
+      }
       if (pretty.trim().length > 0) {
         if (useTty) {
           process.stdout.write("\n");
@@ -61550,6 +61563,7 @@ ${stripFooter(rawAlso)}`.trimEnd();
     } catch {
     }
     const showStacks = Boolean(unified.aggregated?.numFailedTests > 0);
+    anyTestFailed = Number(unified.aggregated?.numFailedTests ?? 0) > 0;
     let text = renderVitestFromJestJSON(
       unified,
       makeCtx(
@@ -61568,7 +61582,7 @@ ${stripFooter(rawAlso)}`.trimEnd();
     }
   }
   const finalExitCode = jestExitCode;
-  if (collectCoverage && shouldRunJest && coverageAbortOnFailure && finalExitCode !== 0) {
+  if (coverageAbortOnFailure && finalExitCode !== 0 && anyTestFailed) {
     process.exit(finalExitCode);
     return;
   }
@@ -61591,6 +61605,105 @@ ${stripFooter(rawAlso)}`.trimEnd();
       executedTests: Array.from(executedTestFilesSet)
     };
     await emitMergedCoverage(coverageUi, mergedOptsBase);
+    if (finalExitCode !== 0 && !anyTestFailed) {
+      try {
+        const header = `${ansi.red("Coverage thresholds not met")}`;
+        process.stdout.write(`
+${header}
+`);
+        const summaryTxt = (() => {
+          try {
+            const summaryPath = path16.resolve("coverage", "merged", "coverage-summary.txt");
+            if (fsSync4.existsSync(summaryPath)) return fsSync4.readFileSync(summaryPath, "utf8");
+          } catch {
+          }
+          try {
+            const textPath = path16.resolve("coverage", "merged", "coverage.txt");
+            if (fsSync4.existsSync(textPath)) return fsSync4.readFileSync(textPath, "utf8");
+          } catch {
+          }
+          return "";
+        })();
+        const mergedBody = stripAnsiSimple(summaryTxt);
+        const pctRe = /(Statements|Branches|Functions|Lines)\s*:\s*(\d+(?:\.\d+)?)%/g;
+        const percents = /* @__PURE__ */ new Map();
+        {
+          let m3;
+          while (m3 = pctRe.exec(mergedBody)) {
+            const label = String(m3[1]);
+            const pct = Number(m3[2]);
+            if (!Number.isNaN(pct)) percents.set(label, pct);
+          }
+        }
+        const thresholds = /* @__PURE__ */ new Map();
+        try {
+          const firstCfg = Array.isArray(projectConfigs) && projectConfigs.length ? projectConfigs[0] : void 0;
+          if (firstCfg && fsSync4.existsSync(firstCfg)) {
+            const cfgText = fsSync4.readFileSync(firstCfg, "utf8");
+            const blockRe = /coverageThreshold\s*:\s*\{[\s\S]*?global\s*:\s*\{([\s\S]*?)\}/m;
+            const m3 = blockRe.exec(cfgText);
+            if (m3) {
+              const blk = m3[1] || "";
+              const pick = (key) => {
+                const r4 = new RegExp(`${key}\\s*:\\s*(\\d+)`, "i");
+                const mm = r4.exec(blk);
+                return mm ? Number(mm[1]) : void 0;
+              };
+              const st = pick("statements");
+              const br = pick("branches");
+              const fn2 = pick("functions");
+              const ln2 = pick("lines");
+              if (typeof st === "number") thresholds.set("Statements", st);
+              if (typeof br === "number") thresholds.set("Branches", br);
+              if (typeof fn2 === "number") thresholds.set("Functions", fn2);
+              if (typeof ln2 === "number") thresholds.set("Lines", ln2);
+            }
+          }
+        } catch {
+        }
+        const labels = [
+          "Statements",
+          "Branches",
+          "Functions",
+          "Lines"
+        ];
+        let printedAny = false;
+        for (const label of labels) {
+          const pct = percents.get(label);
+          const need = thresholds.get(label);
+          if (typeof pct === "number" && typeof need === "number") {
+            printedAny = true;
+            if (pct >= need) {
+              process.stdout.write(`${ansi.green(` ${label}: ${pct.toFixed(2)}% \u2265 ${need}%`)}
+`);
+            } else {
+              const delta = (need - pct).toFixed(2);
+              process.stdout.write(
+                `${ansi.red(` ${label}: ${pct.toFixed(2)}% < ${need}% (short ${delta}%)`)}
+`
+              );
+            }
+          }
+        }
+        if (!printedAny) {
+          if (coverageFailureLines.length > 0) {
+            for (const line of coverageFailureLines)
+              process.stdout.write(`${ansi.red(" - ")}${line}
+`);
+          } else {
+            process.stdout.write(
+              `${ansi.red(" - Coverage failed. See tables above and jest coverageThreshold.")}`
+            );
+            process.stdout.write("\n");
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (coverageAbortOnFailure && finalExitCode !== 0) {
+    process.exit(finalExitCode);
+    return;
   }
   process.exit(finalExitCode);
 };