monocart-coverage-reports 2.13.2 → 3.1.0

package/lib/converter/converter.js

@@ -4,27 +4,31 @@
  * @author cenfun@gmail.com
  */
 
-const EC = require('eight-colors');
+import EC from 'eight-colors';
 
-const { Locator } = require('monocart-locator');
-const Util = require('../utils/util.js');
+import { Locator } from 'monocart-locator';
+import { Util } from '../utils/util.js';
 
-const findOriginalRange = require('./find-original-range.js');
-const { getJsAstInfo, getCssAstInfo } = require('./ast.js');
-const { getIgnoredRanges } = require('./ignore.js');
+import { findOriginalRange } from './find-original-range.js';
+import { isUncoveredRange } from './source-range-merge.js';
+import { mergeCssBytes } from './css-coverage.js';
+import { handleUncoveredInCovered } from './fake-source-coverage.js';
+import { getJsAstInfo, getCssAstInfo } from './ast.js';
+import { getIgnoredRanges } from './ignore.js';
 
-const { getUntestedList } = require('./untested.js');
-
-const {
+import { getUntestedList } from './untested.js';
+import {
     sortRanges, dedupeCountRanges, mergeRangesWith
-} = require('../utils/dedupe.js');
-const { getSourceType, initSourceMapSourcesPath } = require('../utils/source-path.js');
+} from '../utils/dedupe.js';
+import {
+    getSourceType, initSourceMapSourcesPath, cssTypes
+} from '../utils/source-path.js';
 
-const { decode } = require('../packages/monocart-coverage-vendor.js');
+import { decode } from '@jridgewell/sourcemap-codec';
 
-const InfoBranch = require('./info-branch.js');
-const InfoFunction = require('./info-function.js');
-const InfoStatement = require('./info-statement.js');
+import { InfoBranch } from './info-branch.js';
+import { InfoFunction } from './info-function.js';
+import { InfoStatement } from './info-statement.js';
 
 // ========================================================================================================
 
@@ -212,7 +216,7 @@ const calculateV8Summary = (list) => {
  * * `f` - hit count for functions
  * * `b` - hit count for branches
  */
-const collectFileCoverage = (v8Data, state, options) => {
+const collectFileCoverage = (v8Data, state, options, needsIstanbul) => {
 
     const {
         bytes,
@@ -220,7 +224,6 @@ const collectFileCoverage = (v8Data, state, options) => {
         branches,
         statements,
 
-        sourcePath,
         locator
     } = state;
 
@@ -313,7 +316,19 @@ const collectFileCoverage = (v8Data, state, options) => {
     v8Data.summary = summary;
 
     // ==========================================
-    // istanbul
+    // Istanbul location maps are not needed by V8-only reports. Keep the
+    // V8 ranges, counts and summaries above identical in either mode.
+    if (!needsIstanbul) {
+        return;
+    }
+
+    return collectIstanbulCoverage(state);
+};
+
+const collectIstanbulCoverage = (state) => {
+    const {
+        sourcePath, locator, statements, functions, branches
+    } = state;
     const istanbulData = {
         path: sourcePath,
 
@@ -818,16 +833,71 @@ const handleOriginalEmptyBytesCoverage = (state, originalStateMap) => {
     });
 };
 
-
 const handleAllOriginalBytesCoverage = (state, originalStateMap) => {
 
-    const { js, coverageList } = state;
+    const {
+        js, coverageList, type
+    } = state;
+
+    if (cssTypes.has(type)) {
+        // An intentional exclusion is not a broken source map, even when all
+        // sources were excluded and there is nothing left to map.
+        if (state.filteredSourceIndexes.size > 0 && state.filteredSourceIndexes.size === state.sourceMap.sources.length) {
+            return;
+        }
+        const positionMap = new Map();
+        const couldMapAllRanges = coverageList.every((range) => {
+            const {
+                start, end, originalState, error, filtered
+            } = findOriginalRange(range.start, range.end, state, originalStateMap, {
+                fixOriginalRange: true
+            });
+
+            if (filtered) {
+                return true;
+            }
+            if (error) {
+                return false;
+            }
+
+            // Offsets are local to each source, not unique across the bundle.
+            let positions = positionMap.get(originalState);
+            if (!positions) {
+                positions = new Set();
+                positionMap.set(originalState, positions);
+            }
+            const positionKey = `${start}-${end}`;
+            if (positions.has(positionKey)) {
+                return false;
+            }
+            positions.add(positionKey);
+            originalState.bytes.push({
+                start, end, count: range.count
+            });
+            return true;
+        });
+
+        // make sure every range mapped correctly,
+        // otherwise discard changes and fall back to dist file to show at least some meaningful coverage.
+        // Sass `@include` is a common case: one generated rule maps to both the
+        // call site and the mixin body, which cannot be one contiguous original
+        // range. See "Sass mixins and @include" in README.
+        if (!couldMapAllRanges) {
+            Util.logDebug(`Could not map all ranges, fallback to dist file for ${EC.yellow(state.sourcePath)}`);
+            state.v8Data.dedupe = false;
+            // The fallback is now a real report file, not a debug-only copy.
+            delete state.v8Data.debug;
+            state.originalList = [];
+            originalStateMap.clear();
+            generateCoverageForDist(state);
+        }
 
-    // only for js, no sourcemap for css for now
-    if (!js) {
         return;
     }
 
+    if (!js) {
+        return;
+    }
     // v8 coverage
     coverageList.forEach((block) => {
         block.ranges.forEach((range) => {
@@ -1033,7 +1103,6 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
 };
 
 // ========================================================================================================
-
 const initOriginalList = (state, originalDecodedMap, options) => {
 
     // source filter
@@ -1041,6 +1110,9 @@ const initOriginalList = (state, originalDecodedMap, options) => {
 
     // create original content mappings
     const originalStateMap = new Map();
+    if (!state.js) {
+        state.filteredSourceIndexes = new Set();
+    }
 
     const { sources, sourcesContent } = state.sourceMap;
 
@@ -1052,7 +1124,7 @@ const initOriginalList = (state, originalDecodedMap, options) => {
         // filter
         // do not change for sourceIndex
         if (!sourceFilter(sourcePath)) {
-            // console.log('-', sourcePath);
+            state.filteredSourceIndexes?.add(sourceIndex);
             return;
         }
         // console.log(sourcePath);
@@ -1069,14 +1141,12 @@ const initOriginalList = (state, originalDecodedMap, options) => {
 
         const decodedMappings = getOriginalDecodedMappings(originalDecodedMap, sourceIndex, locator);
 
-        // unpacked file always is js
-
         const type = getSourceType(sourcePath);
 
         const originalState = {
             original: true,
-            // original file is js
-            js: true,
+            // Only known style types are CSS; preserve JS coverage for all other sources.
+            js: !cssTypes.has(type),
             type,
             source: sourceContent,
             sourcePath,
@@ -1136,6 +1206,12 @@ const collectOriginalList = (state, originalStateMap) => {
             source
         };
 
+        // Sourcemap gaps must not count as covered bytes for untested files.
+        // Keep the marker so real coverage can replace this entry during merge.
+        if (state.v8Data.empty) {
+            sourceItem.empty = true;
+        }
+
         // save v8 data and add to originalList
         originalState.v8Data = sourceItem;
         state.originalList.push(originalState);
@@ -1157,56 +1233,6 @@ const generateCoverageForDist = (state) => {
 
 };
 
-const handleUncoveredInCovered = (state, originalStateMap) => {
-    if (!state.fake) {
-        return;
-    }
-
-    // fake statements/branches/functions
-    originalStateMap.forEach((originalState) => {
-        const { bytes } = originalState;
-        const list = [];
-        originalState.bytes = bytes.filter((item) => {
-            if (item.count === 0) {
-                const range = bytes.find((it) => {
-                    if (it.count === 0) {
-                        return false;
-                    }
-                    if (it.start > item.end) {
-                        return false;
-                    }
-                    if (it.end < item.start) {
-                        return false;
-                    }
-                    return true;
-                });
-                if (range) {
-                    list.push(item);
-                    return false;
-                }
-            }
-            return true;
-        });
-
-        if (!list.length) {
-            return;
-        }
-
-        list.forEach((item) => {
-            ['statements', 'branches', 'functions'].forEach((key) => {
-                originalState[key] = originalState[key].filter((it) => {
-                    if (it.start === item.start && it.end === item.end) {
-                        return false;
-                    }
-                    return true;
-                });
-            });
-        });
-
-    });
-
-};
-
 const unpackSourceMap = (state, options) => {
 
     const { sourceMap, sourcePath } = state;
@@ -1525,44 +1551,6 @@ const convertCoverages = (list, options, untested) => {
 
 // ========================================================================================================
 
-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);
 
@@ -1747,7 +1735,7 @@ const addUntestedFiles = async (stateList, options) => {
 
 };
 
-const generateV8DataList = (stateList, options) => {
+const generateV8DataList = (stateList, options, needsIstanbul) => {
 
     const stateMap = new Map();
 
@@ -1770,8 +1758,14 @@ const generateV8DataList = (stateList, options) => {
         // exists item
         const prevState = stateMap.get(id);
         if (prevState) {
-            // ignore empty item, just override it
-            if (!prevState.v8Data.empty) {
+            // Empty entries and debug copies must not replace real original
+            // coverage, nor contribute a duplicate execution to its merge.
+            if (!prevState.v8Data.empty && !prevState.v8Data.debug) {
+                // An untested build may contain different mapped AST nodes
+                // (for example ES5 helpers). It must not alter real metrics.
+                if (v8Data.empty) {
+                    return;
+                }
                 if (mergeMap.has(id)) {
                     mergeMap.get(id).push(originalState);
                 } else {
@@ -1790,7 +1784,7 @@ const generateV8DataList = (stateList, options) => {
         if (state.js) {
             mergeV8Data(state, mergeMap.get(id));
         } else {
-            // should no css here, css can not be in sources
+            state.bytes = mergeCssBytes(mergeMap.get(id).map((it) => it.bytes));
         }
     }
 
@@ -1801,11 +1795,13 @@ const generateV8DataList = (stateList, options) => {
     const coverageData = {};
     stateMap.forEach((state) => {
         const { v8Data } = state;
-        const istanbulData = collectFileCoverage(v8Data, state, options);
-        const { sourcePath, source } = v8Data;
+        const istanbulData = collectFileCoverage(v8Data, state, options, needsIstanbul);
         v8DataList.push(v8Data);
-        fileSources[sourcePath] = source;
-        coverageData[sourcePath] = istanbulData;
+        if (needsIstanbul) {
+            const { sourcePath, source } = v8Data;
+            fileSources[sourcePath] = source;
+            coverageData[sourcePath] = istanbulData;
+        }
     });
 
     // sort v8DataList (files)
@@ -1823,7 +1819,8 @@ const generateV8DataList = (stateList, options) => {
     };
 };
 
-const convertV8List = async (v8list, options) => {
+// Direct users of the converter retain the full result by default.
+const convertV8List = async (v8list, options, needsIstanbul = true) => {
 
     // for tested files
     const stateList = convertCoverages(v8list, options);
@@ -1832,13 +1829,11 @@ const convertV8List = async (v8list, options) => {
     await addUntestedFiles(stateList, options);
 
     const time_start_convert = Date.now();
-    const dataList = generateV8DataList(stateList, options);
+    const dataList = generateV8DataList(stateList, options, needsIstanbul);
     const dataFiles = EC.cyan(`${dataList.v8DataList.length} files`);
     Util.logTime(`${EC.magenta('│ ')}${EC.cyan('├')} [convert] converted data list (${dataFiles})`, time_start_convert);
 
     return dataList;
 };
 
-module.exports = {
-    convertV8List
-};
+export { convertV8List };

package/lib/converter/css-coverage.js

@@ -0,0 +1,76 @@
+const getCssRangePoints = (groups) => {
+    const points = [];
+    groups.forEach((ranges) => {
+        ranges.forEach(({
+            start, end, count
+        }) => {
+            if (start >= end) {
+                return;
+            }
+            const covered = count > 0 ? 1 : 0;
+            const uncovered = count > 0 ? 0 : 1;
+            points.push({
+                offset: start, covered, uncovered
+            }, {
+                offset: end, covered: -covered, uncovered: -uncovered
+            });
+        });
+    });
+    return points.sort((a, b) => a.offset - b.offset);
+};
+
+const appendCssRange = (merged, start, end, count) => {
+    const last = merged[merged.length - 1];
+    if (last && last.end === start && last.count === count) {
+        last.end = end;
+    } else {
+        merged.push({
+            start, end, count
+        });
+    }
+};
+
+const sweepCssBytes = (groups, uncoveredWins) => {
+    const points = getCssRangePoints(groups);
+    const merged = [];
+    let start = 0;
+    let covered = 0;
+    let uncovered = 0;
+    for (const point of points) {
+        const end = point.offset;
+        if (start < end && (covered > 0 || uncovered > 0)) {
+            const count = uncoveredWins ? Number(uncovered === 0) : Number(covered > 0);
+            appendCssRange(merged, start, end, count);
+        }
+        covered += point.covered;
+        uncovered += point.uncovered;
+        start = end;
+    }
+    return merged;
+};
+
+const isSortedDisjoint = (ranges) => {
+    let end = -Infinity;
+    for (const range of ranges) {
+        if (!(range.start >= end && range.start < range.end)) {
+            return false;
+        }
+        end = range.end;
+    }
+    return true;
+};
+
+// Within one bundle an uncovered child overrides its covered wrapper. Only
+// after that interpretation may coverage from separate bundles be unioned.
+// Unmapped gaps stay absent from this union; this function does not turn them
+// into covered ranges. Byte summaries still derive covered bytes from total
+// length minus explicit uncovered ranges, so gaps without an uncovered range
+// are reported as covered. Use the line/code views when gaps matter.
+const mergeCssBytes = (groups) => {
+    // Ordered, disjoint ranges already have unambiguous per-bundle coverage.
+    // Reuse them without allocating intermediate events and normalized ranges.
+    const normalized = groups.map((ranges) => (isSortedDisjoint(ranges) ? ranges : sweepCssBytes([ranges], true)));
+    return sweepCssBytes(normalized, false);
+};
+
+export { mergeCssBytes };

package/lib/converter/fake-source-coverage.js

@@ -0,0 +1,64 @@
+const rangeKey = (range) => `${range.start}_${range.end}`;
+
+const handleUncoveredInCovered = (state, originalStateMap) => {
+    if (!state.fake) {
+        return;
+    }
+
+    originalStateMap.forEach((originalState) => {
+        const { bytes } = originalState;
+        // The old check treats every non-zero count as covered, not just > 0.
+        const covered = bytes.filter((range) => range.count !== 0);
+        if (!covered.length || covered.length === bytes.length) {
+            originalState.bytes = bytes.slice();
+            return;
+        }
+
+        // Sort a separate array so byte order and original range objects stay
+        // unchanged. Prefix maxima also handle nested/overlapping coverage.
+        covered.sort((a, b) => a.start - b.start);
+        const starts = new Float64Array(covered.length);
+        const maxEnds = new Float64Array(covered.length);
+        let maxEnd = -Infinity;
+        for (let i = 0; i < covered.length; i++) {
+            starts[i] = covered[i].start;
+            maxEnd = Math.max(maxEnd, covered[i].end);
+            maxEnds[i] = maxEnd;
+        }
+
+        const removed = new Set();
+        originalState.bytes = bytes.filter((range) => {
+            if (range.count !== 0) {
+                return true;
+            }
+            let low = 0;
+            let high = starts.length;
+            while (low < high) {
+                const mid = Math.floor((low + high) / 2);
+                // Preserve the original inclusive overlap test: touching
+                // endpoints count as overlap even though ranges are half-open.
+                if (starts[mid] <= range.end) {
+                    low = mid + 1;
+                } else {
+                    high = mid;
+                }
+            }
+            if (low > 0 && maxEnds[low - 1] >= range.start) {
+                removed.add(rangeKey(range));
+                return false;
+            }
+            return true;
+        });
+
+        if (!removed.size) {
+            return;
+        }
+        // Remove exact start/end matches, not every overlapping AST range.
+        // Each metadata array is filtered once, regardless of removal count.
+        for (const key of ['statements', 'branches', 'functions']) {
+            originalState[key] = originalState[key].filter((range) => !removed.has(rangeKey(range)));
+        }
+    });
+};
+
+export { handleUncoveredInCovered };