monocart-coverage-reports 2.10.3 → 2.10.5

package/README.md

@@ -45,6 +45,7 @@
     - [VSCode](#vscode)
     - [Jest](#jest)
     - [Vitest](#vitest)
+    - [Node Test Runner](#node-test-runner)
     - [Puppeteer](#puppeteer)
     - [Cypress](#cypress)
     - [WebdriverIO](#webdriverio)
@@ -294,6 +295,7 @@ const [jsCoverage, cssCoverage] = await Promise.all([
 const coverageData = [... jsCoverage, ... cssCoverage];
 
 ```
+Collect coverage with `@playwright/test` [`Automatic fixtures`](https://playwright.dev/docs/test-fixtures#automatic-fixtures), see example: [fixtures.ts](https://github.com/cenfun/playwright-coverage/blob/main/fixtures.ts)
 For more examples, see [./test/test-v8.js](./test/test-v8.js), and [anonymous](./test/test-anonymous.js), [css](./test/test-css.js)
 
 
@@ -987,6 +989,9 @@ c8 --experimental-monocart --reporter=v8 --reporter=console-details node foo.js
 - [vitest-monocart-coverage](https://github.com/cenfun/vitest-monocart-coverage) - Vitest custom provider module for coverage reports
 - [merge-code-coverage-vitest](https://github.com/cenfun/merge-code-coverage-vitest) - Example for merging code coverage (Vitest unit + Playwright e2e sharding)
 
+### [Node Test Runner](https://nodejs.org/docs/latest/api/test.html)
+- [node-monocart-coverage](https://github.com/cenfun/node-monocart-coverage) - Custom reporter for Node test runner for coverage
+
 ### [Puppeteer](https://github.com/puppeteer/puppeteer/)
 - [jest-puppeteer-coverage](https://github.com/cenfun/jest-puppeteer-coverage) - Example for Jest puppeteer coverage
 - [maplibre-gl-js](https://github.com/maplibre/maplibre-gl-js) - Example for Jest (unit) + Puppeteer (e2e) + Codecov

package/README.zh-Hans.md

@@ -45,6 +45,7 @@
     - [VSCode](#vscode)
     - [Jest](#jest)
     - [Vitest](#vitest)
+    - [Node Test Runner](#node-test-runner)
     - [Puppeteer](#puppeteer)
     - [Cypress](#cypress)
     - [WebdriverIO](#webdriverio)
@@ -117,10 +118,11 @@ mcr node my-app.js -r v8,console-details
 ![](./assets/v8.gif)
 
 - `v8-json`
-    - 保存 `CoverageResults` 到一个json文件
     - 保存 `CoverageResults` 到一个json文件 (默认是 [`coverage-report.json`](https://cenfun.github.io/monocart-coverage-reports/v8-and-istanbul/coverage-report.json))
     - 用于VSCode扩展来显示原生V8代码覆盖率: [Monocart Coverage for VSCode](https://github.com/cenfun/monocart-coverage-vscode)
 
+![](./assets/mcv.gif)
+
 > 内置Istanbul报告 (V8和Istanbul格式数据都支持):
 
 - `clover`
@@ -295,6 +297,7 @@ const [jsCoverage, cssCoverage] = await Promise.all([
 const coverageData = [... jsCoverage, ... cssCoverage];
 
 ```
+使用 `@playwright/test` 的 [`Automatic fixtures`](https://playwright.dev/docs/test-fixtures#automatic-fixtures)收集覆盖率数据, 见例子: [fixtures.ts](https://github.com/cenfun/playwright-coverage/blob/main/fixtures.ts)
 参见例子 [./test/test-v8.js](./test/test-v8.js), and [anonymous](./test/test-anonymous.js), [css](./test/test-css.js)
 
 
@@ -990,6 +993,9 @@ c8 --experimental-monocart --reporter=v8 --reporter=console-details node foo.js
 - [vitest-monocart-coverage](https://github.com/cenfun/vitest-monocart-coverage) - Vitest custom provider module for coverage reports
 - [merge-code-coverage-vitest](https://github.com/cenfun/merge-code-coverage-vitest) - Example for merging code coverage (Vitest unit + Playwright e2e sharding)
 
+### [Node Test Runner](https://nodejs.org/docs/latest/api/test.html)
+- [node-monocart-coverage](https://github.com/cenfun/node-monocart-coverage) - Custom reporter for Node test runner for coverage
+
 ### [Puppeteer](https://github.com/puppeteer/puppeteer/)
 - [jest-puppeteer-coverage](https://github.com/cenfun/jest-puppeteer-coverage) - Example for Jest puppeteer coverage
 - [maplibre-gl-js](https://github.com/maplibre/maplibre-gl-js) - Example for Jest (unit) + Puppeteer (e2e) + Codecov
@@ -1044,7 +1050,7 @@ const coverageOptions = {
     ]
 };
 ```
-- Github actions example:
+- Github actions:
 ```yml
 - name: Codecov
     uses: codecov/codecov-action@v4
@@ -1080,7 +1086,7 @@ const coverageOptions = {
     lcov: true
 };
 ```
-- Github actions example:
+- Github actions:
 ```yml
 - name: Coveralls
     uses: coverallsapp/github-action@v2

package/lib/converter/converter.js

@@ -13,6 +13,8 @@ const findOriginalRange = require('./find-original-range.js');
 const { getJsAstInfo, getCssAstInfo } = require('./ast.js');
 const { getIgnoredRanges } = require('./ignore.js');
 
+const { getUntestedList } = require('./untested.js');
+
 const {
     sortRanges, dedupeCountRanges, mergeRangesWith
 } = require('../utils/dedupe.js');
@@ -868,8 +870,8 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
 
     const allDecodedMappings = [];
     decodedList.forEach((segments, generatedLine) => {
-        let info = null;
-        segments.forEach((segment) => {
+        const lastIndex = segments.length - 1;
+        segments.forEach((segment, i) => {
 
             // const COLUMN = 0;
             // const SOURCES_INDEX = 1;
@@ -889,7 +891,7 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
                 column: generatedColumn
             });
 
-            info = {
+            const info = {
                 generatedOffset,
                 generatedLine,
                 generatedColumn,
@@ -900,12 +902,21 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
                 nameIndex
             };
 
+            // first and last column
+            if (i === 0) {
+                info.first = true;
+            }
+            if (i === lastIndex) {
+                info.last = true;
+            }
+
             allDecodedMappings.push(info);
 
             originalDecodedMap.get(sourceIndex).push(info);
 
         });
 
+
     });
 
     // defaults to sort by generated offset, not need sort
@@ -1324,66 +1335,215 @@ const initJsCoverageList = (item) => {
     return coverageList;
 };
 
-// ========================================================================================================
-
-const isCoveredInRanges = (range, uncoveredBytes) => {
-    if (!uncoveredBytes.length) {
-        return true;
+const logConvertTime = (msg, time_start, untested) => {
+    if (untested) {
+        return;
     }
-    for (const item of uncoveredBytes) {
-        if (range.start >= item.start && range.end <= item.end) {
-            return false;
+    Util.logTime(msg, time_start);
+};
+
+const convertCoverages = (list, options, untested) => {
+    const stateList = [];
+
+    for (const item of list) {
+        // console.log([item.id]);
+
+        const time_start_ast = Date.now();
+
+        const {
+            type, source, fake, sourcePath
+        } = item;
+
+        // for source file, type could be ts or vue as extname, but js = true
+        const js = type === 'js';
+        item.js = js;
+
+        // source mapping
+        const locator = new Locator(source);
+        const maxContentLength = source.length;
+
+        // ============================
+        // move sourceMap
+        const sourceMap = item.sourceMap;
+        if (sourceMap) {
+            delete item.sourceMap;
+        }
+
+        // ============================
+        // move functions and ranges to coverageList
+        let coverageList = [];
+        let astInfo;
+        if (js) {
+            coverageList = initJsCoverageList(item);
+            // remove original functions
+            if (!Util.isDebug()) {
+                delete item.functions;
+            }
+            astInfo = getJsAstInfo(item, coverageList);
+        } else {
+            // convent css covered ranges to rules ranges and include uncovered ranges
+            astInfo = getCssAstInfo(item, coverageList);
+            // remove original ranges
+            if (!Util.isDebug()) {
+                delete item.ranges;
+            }
         }
+
+        logConvertTime(`  ┌ [convert] parsed ast: ${sourcePath} (${EC.cyan(Util.BSF(maxContentLength))})`, time_start_ast, untested);
+
+        // console.log(sourcePath, astInfo.statements.length);
+        // ============================
+
+        const time_start_unpack = Date.now();
+
+        // current file and it's sources from sourceMap
+        // see const originalState
+        const state = {
+            js,
+            type,
+            source,
+            fake,
+            sourcePath,
+            sourceMap,
+            locator,
+            maxContentLength,
+            decodedMappings: [],
+            rangeCache: new Map(),
+            diffCache: new Map(),
+
+            // alignTextList: [],
+
+            // coverage info
+            bytes: [],
+            functions: [],
+            branches: [],
+            statements: [],
+            astInfo,
+            // for sub source files
+            coverageList,
+            originalList: [],
+            // coverage data
+            v8Data: item
+        };
+
+        unpackDistFile(item, state, options);
+        const unpackedFiles = EC.cyan(`${state.originalList.length} files`);
+
+        stateList.push(state);
+
+        logConvertTime(`  ┌ [convert] unpacked sourcemap: ${sourcePath} (${unpackedFiles})`, time_start_unpack, untested);
+
     }
-    return true;
+
+    return stateList;
+};
+
+// ========================================================================================================
+
+const isUncoveredRange = (range, key, uncoveredGroups) => {
+
+    let uncovered = true;
+    uncoveredGroups.forEach((group) => {
+        const { groupMap, state } = group;
+
+        // ========================================================
+        // self key
+        if (groupMap.has(key)) {
+            return;
+        }
+
+        // ========================================================
+        // in all group
+        for (const item of groupMap.values()) {
+            if (range.start >= item.start && range.end <= item.end) {
+                return;
+            }
+        }
+
+        // ========================================================
+        // no sourcemap mappings in range
+        // check original range in decodedMappings
+        const { decodedMappings } = state;
+        const item = decodedMappings.find((it) => it.originalOffset >= range.start && it.originalOffset <= range.end);
+        if (!item) {
+            return;
+        }
+
+        // ========================================================
+        uncovered = false;
+
+    });
+
+    return uncovered;
+
 };
 
 const mergeV8Data = (state, stateList) => {
     // console.log(stateList);
 
-    // const sourcePath = state.sourcePath;
-    // console.log(sourcePath);
-    // if (sourcePath.endsWith('scroll_zoom.ts')) {
-    // console.log('merge v8 data ===================================', sourcePath);
-    // console.log(stateList.map((it) => it.bytes));
-    // console.log(stateList.map((it) => it.functions));
-    // console.log(stateList.map((it) => it.branches.map((b) => [`${b.start}-${b.end}`, JSON.stringify(b.locations.map((l) => l.count))])));
+    // let debug = false;
+    // if (state.sourcePath.endsWith('counter.tsx')) {
+    //     debug = true;
+    //     console.log('merge v8 data ===================================', state.sourcePath);
+    //     console.log('bytes before ============', stateList.map((it) => it.bytes));
+    //     // console.log('statements ==============', stateList.map((it) => it.statements));
+    //     // console.log('functions ==============', stateList.map((it) => it.functions));
+    //     // console.log('branches ======================', stateList.map((it) => it.branches.map((b) => [`${b.start}-${b.end}`, JSON.stringify(b.locations.map((l) => l.count))])));
     // }
 
     // ===========================================================
     // bytes
     const mergedBytes = [];
-    const uncoveredList = [];
+
+    const coveredMap = new Map();
+    const uncoveredMap = new Map();
+    const uncoveredGroups = [];
     stateList.forEach((st) => {
+        const groupMap = new Map();
         const bytes = dedupeCountRanges(st.bytes);
-        const uncoveredBytes = [];
         bytes.forEach((range) => {
+            const key = `${range.start}_${range.end}`;
             if (range.count) {
                 mergedBytes.push(range);
+                coveredMap.set(key, true);
             } else {
-                uncoveredBytes.push(range);
+                uncoveredMap.set(key, range);
+                groupMap.set(key, range);
             }
         });
-        uncoveredList.push(uncoveredBytes);
+
+        uncoveredGroups.push({
+            groupMap,
+            state: st
+        });
     });
-    // just remove uncovered range
-    uncoveredList.forEach((currentBytes) => {
-        currentBytes.forEach((range) => {
-            for (const targetBytes of uncoveredList) {
-                if (targetBytes === currentBytes) {
-                    continue;
-                }
-                if (isCoveredInRanges(range, targetBytes)) {
-                    return;
-                }
-            }
+
+    // if (debug) {
+    //     console.log('coveredMap ============', coveredMap);
+    //     console.log('uncoveredMap ============', uncoveredMap);
+    //     console.log('uncoveredGroups ============', uncoveredGroups);
+    // }
+
+    uncoveredMap.forEach((range, key) => {
+
+        // in covered range
+        if (coveredMap.has(key)) {
+            return;
+        }
+
+        if (isUncoveredRange(range, key, uncoveredGroups)) {
             mergedBytes.push(range);
-        });
+        }
+
     });
 
     // will be dedupeCountRanges in collectFileCoverage
     state.bytes = mergedBytes;
 
+    // if (debug) {
+    //     console.log('bytes after ============', mergedBytes);
+    // }
+
     // ===========================================================
     // functions
     const allFunctions = stateList.map((it) => it.functions).flat();
@@ -1423,6 +1583,20 @@ const mergeV8Data = (state, stateList) => {
     const mergedFunctions = mergeRangesWith(allFunctions, functionComparer, functionHandler);
     state.functions = mergedFunctions;
 
+    // ===========================================================
+    // statements
+    const allStatements = stateList.map((it) => it.statements).flat();
+    const statementComparer = (lastRange, range) => {
+        // exact matched because the statement range is generated from ast
+        return lastRange.start === range.start && lastRange.end === range.end;
+    };
+    const statementHandler = (lastRange, range) => {
+        // merge statements count
+        lastRange.count += range.count;
+    };
+    const mergedStatements = mergeRangesWith(allStatements, statementComparer, statementHandler);
+    state.statements = mergedStatements;
+
     // ===========================================================
     // branches
     const allBranches = stateList.map((it) => it.branches).flat();
@@ -1449,6 +1623,43 @@ const mergeV8Data = (state, stateList) => {
     // }
 
 
+};
+
+const addUntestedFiles = async (stateList, options) => {
+
+    const time_start_untested = Date.now();
+
+    const testedMap = new Map();
+    stateList.forEach((state) => {
+        const { v8Data, originalList } = state;
+        // dedupe dist file if not debug
+        if (!v8Data.dedupe) {
+            testedMap.set(state.sourcePath, true);
+        }
+        originalList.forEach((originalState) => {
+            testedMap.set(originalState.sourcePath, true);
+        });
+    });
+
+    // console.log('testedMap', testedMap);
+
+    const untestedList = await getUntestedList(testedMap, options, 'v8');
+    if (!untestedList) {
+        return;
+    }
+
+    const untestedStateList = convertCoverages(untestedList, options, true);
+
+    // console.log(untestedStateList);
+    untestedStateList.forEach((state) => {
+        stateList.push(state);
+    });
+
+    // console.log('untestedList', untestedList);
+
+    Util.logTime(`  ┌ [convert] added untested files: ${EC.yellow(untestedList.length)}`, time_start_untested);
+
+
 };
 
 const generateV8DataList = (stateList, options) => {
@@ -1527,109 +1738,17 @@ const generateV8DataList = (stateList, options) => {
     };
 };
 
-const convertV8List = (v8list, options) => {
-
-    const stateList = [];
-
-    for (const item of v8list) {
-        // console.log([item.id]);
-
-        const time_start_ast = Date.now();
-
-        const {
-            type, source, fake, sourcePath
-        } = item;
-
-        // for source file, type could be ts or vue as extname, but js = true
-        const js = type === 'js';
-        item.js = js;
-
-        // source mapping
-        const locator = new Locator(source);
-        const maxContentLength = source.length;
-
-        // ============================
-        // move sourceMap
-        const sourceMap = item.sourceMap;
-        if (sourceMap) {
-            delete item.sourceMap;
-        }
-
-        // ============================
-        // move functions and ranges to coverageList
-        let coverageList = [];
-        let astInfo;
-        if (js) {
-            coverageList = initJsCoverageList(item);
-            // remove original functions
-            if (!Util.isDebug()) {
-                delete item.functions;
-            }
-            astInfo = getJsAstInfo(item, coverageList);
-        } else {
-            // convent css covered ranges to rules ranges and include uncovered ranges
-            astInfo = getCssAstInfo(item, coverageList);
-            // remove original ranges
-            if (!Util.isDebug()) {
-                delete item.ranges;
-            }
-        }
+const convertV8List = async (v8list, options) => {
 
-        Util.logTime(`  ┌ [convert] parsed ast: ${sourcePath} (${EC.cyan(Util.BSF(maxContentLength))})`, time_start_ast);
-
-        // console.log(sourcePath, astInfo.statements.length);
-        // ============================
+    // for tested files
+    const stateList = convertCoverages(v8list, options);
 
-        const time_start_unpack = Date.now();
-
-        // current file and it's sources from sourceMap
-        // see const originalState
-        const state = {
-            js,
-            type,
-            source,
-            fake,
-            sourcePath,
-            sourceMap,
-            locator,
-            maxContentLength,
-            decodedMappings: [],
-            rangeCache: new Map(),
-            diffCache: new Map(),
-
-            // alignTextList: [],
-
-            // coverage info
-            bytes: [],
-            functions: [],
-            branches: [],
-            statements: [],
-            astInfo,
-            // for sub source files
-            coverageList,
-            originalList: [],
-            // coverage data
-            v8Data: item
-        };
-
-        unpackDistFile(item, state, options);
-        const unpackedFiles = EC.cyan(`${state.originalList.length} files`);
-
-        stateList.push(state);
-
-        Util.logTime(`  ┌ [convert] unpacked sourcemap: ${sourcePath} (${unpackedFiles})`, time_start_unpack);
-
-    }
+    // empty coverage handler
+    await addUntestedFiles(stateList, options);
 
     const time_start_convert = Date.now();
-
     const dataList = generateV8DataList(stateList, options);
     const dataFiles = EC.cyan(`${dataList.v8DataList.length} files`);
-
-    // stateList.forEach((st, i) => {
-    // Util.writeFileSync(`align-text-${i}.js`, `window.gridData = ${JSON.stringify(st.alignTextList, null, 4)}`);
-    // });
-
     Util.logTime(`  ┌ [convert] converted data list (${dataFiles})`, time_start_convert);
 
     return dataList;

package/lib/converter/find-original-range.js

@@ -407,16 +407,16 @@ const getFixedPosition = (info, direction) => {
 
 // ========================================================================================================
 
-const getOriginalEndOffset = (m, cache) => {
+const getOriginalEndOffset = (m, originalState) => {
     if (!m.originalEndOffset) {
-        const line = cache.originalState.locator.getLine(m.originalLine + 1);
+        const line = originalState.locator.getLine(m.originalLine + 1);
         m.originalEndOffset = line ? line.end : m.originalOffset;
     }
     return m.originalEndOffset;
 };
 
-const getOriginalText = (m1, m2, cache) => {
-    const originalLocator = cache.originalState.locator;
+const getOriginalText = (m1, m2, originalState, startNextLine) => {
+    const originalLocator = originalState.locator;
 
     const o1 = m1.originalOffset;
     const o2 = m2.originalOffset;
@@ -442,10 +442,22 @@ const getOriginalText = (m1, m2, cache) => {
             };
         }
 
+        // start from next line
+        if (startNextLine) {
+            const nextLine = originalState.locator.getLine(m1.originalLine + 2);
+            if (nextLine) {
+                // console.log(nextLine);
+                return {
+                    originalOffset: nextLine.start + nextLine.indent,
+                    originalText: nextLine.text.slice(nextLine.indent)
+                };
+            }
+        }
+
         // could be multiple lines for original text
         return {
             originalOffset: o1,
-            originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, cache))
+            originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, originalState))
         };
     }
 
@@ -454,7 +466,7 @@ const getOriginalText = (m1, m2, cache) => {
     if (o1 === o2) {
         return {
             originalOffset: o1,
-            originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, cache))
+            originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, originalState))
         };
     }
 
@@ -477,7 +489,7 @@ const getOriginalText = (m1, m2, cache) => {
     // should be wrong, ignore m2
     return {
         originalOffset: o1,
-        originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, cache))
+        originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, originalState))
     };
 
 };
@@ -553,8 +565,19 @@ const getFixedOriginalStart = (start, mappings, state, cache, options) => {
         };
     }
 
+    // skip last mapping
+    let startNextLine = false;
+    if (m1.last) {
+        const locStart = state.locator.offsetToLocation(start);
+        // 1-base
+        const lineIndex = locStart.line - 1;
+        if (lineIndex > m1.generatedLine) {
+            startNextLine = true;
+            // console.log(originalState.sourcePath, start, m1, m2);
+        }
+    }
 
-    const { originalText, originalOffset } = getOriginalText(m1, m2, cache);
+    const { originalText, originalOffset } = getOriginalText(m1, m2, originalState, startNextLine);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, start);
     const direction = 'start';
 
@@ -592,7 +615,7 @@ const getFixedOriginalEnd = (end, mappings, state, cache) => {
 
     // cross file until e1 line end (not file end)
     if (crossEnd) {
-        const originalEndOffset = getOriginalEndOffset(m1, cache);
+        const originalEndOffset = getOriginalEndOffset(m1, originalState);
         return {
             originalEnd: originalEndOffset
         };
@@ -608,7 +631,7 @@ const getFixedOriginalEnd = (end, mappings, state, cache) => {
     }
 
 
-    const { originalText, originalOffset } = getOriginalText(m1, m2, cache);
+    const { originalText, originalOffset } = getOriginalText(m1, m2, originalState);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, end);
     const direction = 'end';