fix(merge-coverage): eliminate Windows path-separator duplication (#203)

Copilot · nev21 · Copilot · web-flow · commit 61a0cb565d18 · 2026-05-09T20:30:40.000-07:00
* Initial plan * fix: normalize coverage path separators on Windows in merge-coverage - Add normalizeCoverageKeys() to convert backslash path keys and `path` properties to forward slashes in coverage JSON blobs before merging. This prevents nyc (backslash) vs karma-typescript (forward-slash) key duplication on Windows. - Normalize globby paths to forward slashes before the exclusion filter so that `coverage/coverage-final.json` is correctly excluded even when globby returns backslash-separated paths on Windows. - Add tests for normalizeCoverageKeys in merge-coverage.test.ts Agent-Logs-Url: https://github.com/nevware21/ts-build-tools/sessions/fe9562c3-39c4-4338-9207-223a423590cb Co-authored-by: nev21 <82737406+nev21@users.noreply.github.com> * chore: revert accidental package.json changes from test setup Co-authored-by: nev21 <82737406+nev21@users.noreply.github.com> * fix: use string types and const instead of any/var in merge-coverage Address code review feedback: use string type annotations instead of any in lambda parameters, and use const instead of var for jsonBlobs. Agent-Logs-Url: https://github.com/nevware21/ts-build-tools/sessions/fe9562c3-39c4-4338-9207-223a423590cb Co-authored-by: nev21 <82737406+nev21@users.noreply.github.com> * Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * fix: use simple overwrite instead of istanbul merge for key collision in normalizeCoverageKeys The istanbul FileCoverage.merge() call requires complete statementMap location data (start/end), which may not be present. Use simple last-write-wins overwrite instead — cross-blob merging is handled by istanbul in the main mergeCoverage loop. All 23 tests pass. Agent-Logs-Url: https://github.com/nevware21/ts-build-tools/sessions/148514cb-94a7-4094-a057-e3cb05720107 Co-authored-by: nev21 <82737406+nev21@users.noreply.github.com> * chore: revert accidental package.json changes from local test setup Co-authored-by: nev21 <82737406+nev21@users.noreply.github.com> * fix: move normalizeCoverageKeys to utils.ts to fix Node 18 ESM loader issue merge-coverage.ts imports globby v13 (ESM-only). On Node 18, loading any test that imports from merge-coverage.ts triggers the ESM loader, which can't handle .ts file extensions (ERR_UNKNOWN_FILE_EXTENSION). Moving normalizeCoverageKeys to utils.ts (only CJS deps: fs, path, @nevware21/ts-utils) and updating the test to import from utils.ts avoids this ESM cascade. merge-coverage.ts re-exports the function for API compatibility. utils.ts also gets stronger types (Record<string, any> instead of any). Agent-Logs-Url: https://github.com/nevware21/ts-build-tools/sessions/4303ce38-8fd4-4261-a66a-f982cd20395a Co-authored-by: nev21 <82737406+nev21@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: nev21 <82737406+nev21@users.noreply.github.com> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> Co-authored-by: nevware21-bot <252503968+nevware21-bot@users.noreply.github.com>
diff --git a/lib/coverage-tools/src/merge-coverage.ts b/lib/coverage-tools/src/merge-coverage.ts
@@ -17,9 +17,9 @@ import * as fs from "fs";
 import * as path from "path";
 import { globbySync } from "globby";
 import { IMergeCoverageArgs } from "./interfaces/IMergeCoverageArgs";
-import { findPath, getJson } from "./utils";
+import { findPath, getJson, normalizeCoverageKeys } from "./utils";
 
-export { IMergeCoverageArgs };
+export { IMergeCoverageArgs, normalizeCoverageKeys };
 
 export function findCoverage(thePath: string): string {
     let foundPath = findPath((thePath) => {
@@ -54,14 +54,18 @@ export function mergeCoverage(cfg: IMergeCoverageArgs) {
 
     console.log(`Merging coverage files in ${rootPath} - [${fs.realpathSync(rootPath)}]`);
     // Find any files named "coverage-final.json" (excluding any existing merged one)
+    // Normalize to forward slashes so the filter works correctly on Windows too
     let jsonFiles = globbySync(`${rootPath}/**/coverage-final.json`)
-        .filter((possibleFile: any) => (possibleFile.indexOf("report") === -1 && possibleFile.indexOf("coverage/coverage-final.json") === -1));
+        .map((possibleFile: string) => possibleFile.replace(/\\/g, "/"))
+        .filter((possibleFile: string) => (possibleFile.indexOf("report") === -1 && possibleFile.indexOf("coverage/coverage-final.json") === -1));
 
     console.log(`Found ${jsonFiles.length} coverage files to merge:`);
-    jsonFiles.forEach((file: any) => console.log(`  merging: ${file}`));
+    jsonFiles.forEach((file: string) => console.log(`  merging: ${file}`));
 
-    // Load the json blobs from the discovered .json files
-    var jsonBlobs = jsonFiles.map((file: any) => getJson(file));
+    // Load the json blobs from the discovered .json files, normalizing path keys
+    // to forward slashes so that nyc (backslash) and karma-typescript (forward slash)
+    // entries are treated as the same file on Windows.
+    const jsonBlobs = jsonFiles.map((file: string) => normalizeCoverageKeys(getJson(file)));
 
     // Create an empty map and merge in all the loaded maps
     let mergedMap = istanbulCoverage.createCoverageMap();
diff --git a/lib/coverage-tools/src/utils.ts b/lib/coverage-tools/src/utils.ts
@@ -67,6 +67,34 @@ export function findPath(cb: (thePath: string) => string, thePath: string, cnt =
     return findPath(cb, thePath + "../", cnt + 1);
 }
 
+/**
+ * Normalize all path keys and `path` properties in a coverage JSON blob to use
+ * forward slashes. This ensures that entries produced by tools that emit
+ * Windows-style backslash paths (e.g. nyc) are treated as the same file as
+ * entries produced by tools that emit POSIX-style forward-slash paths
+ * (e.g. karma-typescript) when istanbul merges the coverage maps.
+ *
+ * Returns a new object; does not mutate the input.
+ */
+export function normalizeCoverageKeys(jsonBlob: Record<string, any>): Record<string, any> {
+    const normalized: Record<string, any> = {};
+    Object.keys(jsonBlob).forEach((key: string) => {
+        const normalizedKey = key.replace(/\\/g, "/");
+        const entry = jsonBlob[key];
+        const normalizedEntry = entry && typeof entry === "object" ? { ...entry } : entry;
+
+        if (normalizedEntry && normalizedEntry.path) {
+            normalizedEntry.path = normalizedEntry.path.replace(/\\/g, "/");
+        }
+
+        // The later entry wins if both a backslash-keyed and a forward-slash-keyed entry
+        // normalize to the same key. Cross-blob merging is handled by istanbul in the
+        // main mergeCoverage loop.
+        normalized[normalizedKey] = normalizedEntry;
+    });
+    return normalized;
+}
+
 export function findRepoRoot(thePath: string): string {
     let foundPath = findPath((thePath) => {
         console.log("Checking [" + thePath + ".git]");
diff --git a/lib/coverage-tools/test/src/merge-coverage.test.ts b/lib/coverage-tools/test/src/merge-coverage.test.ts
@@ -0,0 +1,56 @@
+/*
+ * @nevware21/ts-build-tools
+ * https://github.com/nevware21/ts-build-tools
+ *
+ * Copyright (c) 2022 NevWare21 Solutions LLC
+ * Licensed under the MIT license.
+ */
+
+import { expect } from "@nevware21/tripwire";
+import { normalizeCoverageKeys } from "../../src/utils";
+
+describe("normalizeCoverageKeys", () => {
+    it("should return an empty object for an empty input", () => {
+        expect(normalizeCoverageKeys({})).deep.equals({});
+    });
+
+    it("should leave forward-slash keys unchanged", () => {
+        const input = {
+            "D:/project/src/foo.ts": { path: "D:/project/src/foo.ts", s: {}, b: {}, f: {}, fnMap: {}, statementMap: {}, branchMap: {} }
+        };
+        const result = normalizeCoverageKeys(input);
+        expect(Object.keys(result)).deep.equals(["D:/project/src/foo.ts"]);
+        expect(result["D:/project/src/foo.ts"].path).equals("D:/project/src/foo.ts");
+    });
+
+    it("should convert backslash keys to forward slashes", () => {
+        const input = {
+            "D:\\project\\src\\foo.ts": { path: "D:\\project\\src\\foo.ts", s: {}, b: {}, f: {}, fnMap: {}, statementMap: {}, branchMap: {} }
+        };
+        const result = normalizeCoverageKeys(input);
+        expect(Object.keys(result)).deep.equals(["D:/project/src/foo.ts"]);
+        expect(result["D:/project/src/foo.ts"].path).equals("D:/project/src/foo.ts");
+    });
+
+    it("should normalize both backslash and forward-slash entries to the same key", () => {
+        // Simulate nyc (backslash) + karma-typescript (forward-slash) for the same file
+        const input = {
+            "D:\\project\\src\\foo.ts": { path: "D:\\project\\src\\foo.ts", s: { "0": 1 }, b: {}, f: {}, fnMap: {}, statementMap: {}, branchMap: {} },
+            "D:/project/src/foo.ts": { path: "D:/project/src/foo.ts", s: { "0": 2 }, b: {}, f: {}, fnMap: {}, statementMap: {}, branchMap: {} }
+        };
+        const result = normalizeCoverageKeys(input);
+        const keys = Object.keys(result);
+        expect(keys).deep.equals(["D:/project/src/foo.ts"]);
+        expect(result["D:/project/src/foo.ts"].path).equals("D:/project/src/foo.ts");
+        expect(result["D:/project/src/foo.ts"].s).deep.equals({ "0": 2 });
+    });
+
+    it("should not modify entries without a path property", () => {
+        const input = {
+            "D:\\project\\src\\foo.ts": { s: {}, b: {}, f: {}, fnMap: {}, statementMap: {}, branchMap: {} }
+        };
+        const result = normalizeCoverageKeys(input);
+        expect(Object.keys(result)).deep.equals(["D:/project/src/foo.ts"]);
+        expect(result["D:/project/src/foo.ts"].path).equals(undefined);
+    });
+});
