monocart-coverage-reports 3.0.0 → 3.2.0

package/lib/converter/converter.js

@@ -11,16 +11,18 @@ import { Util } from '../utils/util.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';
 
 import { getUntestedList } from './untested.js';
-
 import {
     sortRanges, dedupeCountRanges, mergeRangesWith
 } from '../utils/dedupe.js';
-import { getSourceType, initSourceMapSourcesPath } from '../utils/source-path.js';
+import {
+    getSourceType, initSourceMapSourcesPath, cssTypes
+} from '../utils/source-path.js';
 
 import { decode } from '@jridgewell/sourcemap-codec';
 
@@ -759,31 +761,25 @@ const handleOriginalEmptyBytesCoverage = (state, originalStateMap) => {
         }
 
         const { decodedMappings } = originalState;
-        const len = decodedMappings.length;
-        if (len < 2) {
-            return;
-        }
-        // sort by original line/column
-        const startMapping = decodedMappings[0];
-        const endMapping = decodedMappings[len - 1];
-        // console.log(startMapping, endMapping);
-        const startOffset = startMapping.generatedOffset;
-
-        if (!endMapping.generatedEndOffset) {
-            // line last one
-            const line = state.locator.getLine(endMapping.generatedLine + 1);
-            // could be no line found
-            if (line) {
-                // last column
-                endMapping.generatedEndOffset = line.end;
-            } else {
-                endMapping.generatedEndOffset = endMapping.generatedOffset;
+        // The generated range the file's own mappings start in. Leave out the
+        // added line-end mappings: the last one is at the end of its line, which
+        // in a minified bundle is the end of the whole script, not of the wrapper
+        // the file is in.
+        let startOffset = Infinity;
+        let endOffset = -Infinity;
+        decodedMappings.forEach((mapping) => {
+            if (mapping.end) {
+                return;
             }
-        }
-        const endOffset = endMapping.generatedEndOffset;
+            startOffset = Math.min(startOffset, mapping.generatedOffset);
+            endOffset = Math.max(endOffset, mapping.generatedOffset);
+        });
 
-        // console.log('===========================================================', originalState.sourcePath);
-        // console.log(originalState.source.length, endMapping);
+        // A single real mapping is enough; auxiliary line-end mappings are not
+        // guaranteed for every source. Do not infer coverage without mappings.
+        if (startOffset === Infinity) {
+            return;
+        }
 
         checkList.push({
             originalState,
@@ -817,7 +813,9 @@ const handleOriginalEmptyBytesCoverage = (state, originalStateMap) => {
             if (range.count > 0) {
                 continue;
             }
-            if (startOffset >= range.start && endOffset <= range.end) {
+            // endOffset is the last mapping's start, not an exclusive end.
+            // V8 ranges exclude range.end, so a mapping there is outside.
+            if (startOffset >= range.start && endOffset < range.end) {
                 // console.log('------------', 'added');
                 originalState.bytes.push({
                     start: 0,
@@ -831,16 +829,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) => {
@@ -1046,7 +1099,6 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
 };
 
 // ========================================================================================================
-
 const initOriginalList = (state, originalDecodedMap, options) => {
 
     // source filter
@@ -1054,6 +1106,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;
 
@@ -1065,7 +1120,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);
@@ -1082,14 +1137,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,
@@ -1149,6 +1202,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);
@@ -1695,8 +1754,14 @@ const generateV8DataList = (stateList, options, needsIstanbul) => {
         // 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 {
@@ -1715,7 +1780,7 @@ const generateV8DataList = (stateList, options, needsIstanbul) => {
         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));
         }
     }
 

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/find-original-range.js

@@ -813,6 +813,44 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
 
 };
 
+const findMappingStartIndex = (mappings, offset) => {
+    let low = 0;
+    let high = mappings.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (mappings[mid].generatedOffset < offset) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
+    }
+    return low;
+};
+
+const isFilteredRange = (start, end, mappingInfo, state) => {
+    const filtered = state.filteredSourceIndexes;
+    if (state.js || !filtered?.size) {
+        return false;
+    }
+    // A mapping after the exclusive end can belong to the next rule. Only
+    // inspect the active start segment and mappings inside this range.
+    const [startMapping] = [].concat(mappingInfo.startMappings);
+    if (!filtered.has(startMapping.sourceIndex)) {
+        return false;
+    }
+
+    const mappings = state.decodedMappings;
+    const low = findMappingStartIndex(mappings, start);
+    // Excluded endpoints alone are not enough: a retained source may have
+    // mappings in the middle of a rule that combines multiple source files.
+    for (let i = low; i < mappings.length && mappings[i].generatedOffset < end; i++) {
+        if (!filtered.has(mappings[i].sourceIndex)) {
+            return false;
+        }
+    }
+    return true;
+};
+
 const getOriginalState = (start, end, state, originalMap) => {
 
     const mappingInfo = getMappingInfo(start, end, state);
@@ -829,6 +867,7 @@ const getOriginalState = (start, end, state, originalMap) => {
     if (!results) {
         return {
             error: true,
+            filtered: isFilteredRange(start, end, mappingInfo, state),
             errors: [`invalid source indexes: ${EC.yellow(`${startIndexes} ~ ${endIndexes}`)}`]
         };
     }
@@ -845,6 +884,7 @@ const getOriginalState = (start, end, state, originalMap) => {
     if (!originalState) {
         return {
             error: true,
+            filtered: state.filteredSourceIndexes?.has(sourceIndex) && isFilteredRange(start, end, mappingInfo, state),
             errors: [`not found original file: ${EC.yellow(sourceIndex)}`]
         };
     }
@@ -904,7 +944,167 @@ const getMappingInfo = (start, end, state) => {
 };
 
 
-const findOriginalRange = (start, end, state, originalMap, options = {}) => {
+// CSS uses the shared mapping lookup, but owns its endpoint repair and validation.
+const getCssOriginalEndPosition = (cache, state) => {
+    const { end, endMappings } = cache;
+    if (!Array.isArray(endMappings)) {
+        // Synthetic line ends are already exclusive, unlike real token mappings.
+        if (endMappings.end) {
+            return {
+                originalEnd: endMappings.originalOffset
+            };
+        }
+        return getOriginalEndPosition(cache, state);
+    }
+
+    const exclusiveMappings = findMapping(state.decodedMappings, end);
+    if (Array.isArray(exclusiveMappings) && !cache.crossEnd) {
+        const [mapping] = exclusiveMappings;
+        if (mapping.end && mapping.generatedOffset === end - 1) {
+            return {
+                originalEnd: mapping.originalOffset
+            };
+        }
+    }
+    return getOriginalEndPosition(cache, state);
+};
+
+const isValidCssOriginalRange = (start, end, length) => Number.isInteger(start) && Number.isInteger(end)
+    && start >= 0 && start < end && end <= length;
+
+const getCssRangeMappingError = (start, end, state, cache) => {
+    // Matching endpoints do not guarantee a contiguous rule: a Sass mixin
+    // body can map to another file or an earlier location in the same file.
+    const mappings = state.decodedMappings;
+    const low = findMappingStartIndex(mappings, start);
+    for (let i = low; i < mappings.length && mappings[i].generatedOffset < end; i++) {
+        const mapping = mappings[i];
+        if (mapping.sourceIndex !== cache.sourceIndex) {
+            return {
+                error: true,
+                errors: ['cross-source CSS range']
+            };
+        }
+        // Synthetic line ends describe whole lines, not actual mapped tokens.
+        // Do not validate against the inferred end: indentation-based sources
+        // can map a generated closing brace back to the selector's line end.
+        if (!mapping.end && mapping.originalOffset < cache.originalStart) {
+            return {
+                error: true,
+                errors: ['mapped token before original CSS range']
+            };
+        }
+    }
+};
+
+const mapCssOriginalRange = (start, end, state, originalMap, options) => {
+    const cache = getOriginalState(start, end, state, originalMap);
+    if (cache.error) {
+        return cache;
+    }
+    const { originalStart, originalName } = getOriginalStartPosition(cache, state, options);
+    cache.originalStart = originalStart;
+    const mappingError = getCssRangeMappingError(start, end, state, cache);
+    if (mappingError) {
+        return mappingError;
+    }
+    const endResult = getCssOriginalEndPosition(cache, state);
+    if (endResult.error) {
+        return endResult;
+    }
+    const { originalEnd } = endResult;
+    const { originalState } = cache;
+    if (!isValidCssOriginalRange(originalStart, originalEnd, originalState.source.length)) {
+        return {
+            error: true,
+            errors: [`invalid original range: ${EC.yellow(`${originalStart} ~ ${originalEnd}`)}`]
+        };
+    }
+    if (originalState.locator.lineParser.commentParser.isComment(originalStart, originalEnd)) {
+        return {
+            error: true,
+            errors: ['the range in a original comment']
+        };
+    }
+    return {
+        start: originalStart,
+        end: originalEnd,
+        name: originalName,
+        originalState
+    };
+};
+
+const skipCssTrivia = (originalState, offset, direction) => {
+    const { source, locator } = originalState;
+    const { commentParser } = locator.lineParser;
+    while (offset >= 0 && offset < source.length) {
+        if ((/\s/).test(source[offset])) {
+            offset += direction;
+            continue;
+        }
+        if (commentParser.isComment(offset, offset + 1)) {
+            const comment = commentParser.findComment(offset);
+            offset = direction > 0 ? comment.end : comment.start - 1;
+            continue;
+        }
+        break;
+    }
+    return offset;
+};
+
+const fixCssOriginalRange = (result, state, end) => {
+    if (result.error || result.filtered || state.source[end - 1] !== '}') {
+        return result;
+    }
+    const { originalState } = result;
+    const { source } = originalState;
+    // A synthetic endpoint can include whitespace or comments after a brace
+    // already mapped. Do not mistake the next enclosing brace for this rule's.
+    const previousToken = skipCssTrivia(originalState, result.end - 1, -1);
+    if (source[previousToken] === '}') {
+        return result;
+    }
+    // Sass can omit both closing-brace mappings and intervening line comments.
+    // Extend only when the next non-comment, non-whitespace token is a brace.
+    const nextToken = skipCssTrivia(originalState, result.end, 1);
+    if (source[nextToken] === '}') {
+        return {
+            ... result, end: nextToken + 1
+        };
+    }
+    return result;
+};
+
+const findCssOriginalRange = (start, end, state, originalMap, options) => {
+    const { sourcePath, rangeCache } = state;
+    const key = `${start}_${end}_${Boolean(options.fixOriginalRange)}`;
+    if (rangeCache.has(key)) {
+        return rangeCache.get(key);
+    }
+
+    let result = mapCssOriginalRange(start, end, state, originalMap, options);
+    if (options.fixOriginalRange) {
+        // A closing brace may map to a mixin caller in another source. Retry the
+        // body when necessary, then repair using the full generated rule end.
+        if (result.error && !result.filtered && state.source[end - 1] === '}') {
+            result = mapCssOriginalRange(start, end - 1, state, originalMap, options);
+        }
+        result = fixCssOriginalRange(result, state, end);
+    }
+    if (result.error) {
+        result = {
+            ... result, start, end, sourcePath
+        };
+    }
+
+    // Cache the final CSS range, error or deliberate exclusion.
+    rangeCache.set(key, result);
+    return result;
+};
+
+// ========================================================================================================
+
+const findJsOriginalRange = (start, end, state, originalMap, options = {}) => {
 
     const { sourcePath, rangeCache } = state;
 
@@ -913,9 +1113,10 @@ const findOriginalRange = (start, end, state, originalMap, options = {}) => {
         return rangeCache.get(key);
     }
 
-    const createMappingError = (errors) => {
+    const createMappingError = (errors, filtered) => {
         const res = {
             error: true,
+            filtered,
             start,
             end,
             sourcePath,
@@ -930,7 +1131,7 @@ const findOriginalRange = (start, end, state, originalMap, options = {}) => {
 
     const cache = getOriginalState(start, end, state, originalMap);
     if (cache.error) {
-        return createMappingError(cache.errors);
+        return createMappingError(cache.errors, cache.filtered);
     }
 
     const originalStartResult = getOriginalStartPosition(cache, state, options);
@@ -977,4 +1178,11 @@ const findOriginalRange = (start, end, state, originalMap, options = {}) => {
 
 };
 
+const findOriginalRange = (start, end, state, originalMap, options = {}) => {
+    if (state.js) {
+        return findJsOriginalRange(start, end, state, originalMap, options);
+    }
+    return findCssOriginalRange(start, end, state, originalMap, options);
+};
+
 export { findOriginalRange };

package/lib/converter/untested.js

@@ -4,7 +4,9 @@ import { Util } from '../utils/util.js';
 
 import { pathToFileURL, fileURLToPath } from 'node:url';
 
-import { normalizeSourcePath, getSourcePathReplacer } from '../utils/source-path.js';
+import {
+    normalizeSourcePath, getSourcePathReplacer, getSourceType, cssTypes
+} from '../utils/source-path.js';
 
 // ========================================================================================================
 
@@ -67,11 +69,7 @@ const resolveFileType = (fileType, filePath) => {
     if (fileType === 'js' || fileType === 'css') {
         return fileType;
     }
-    const extname = path.extname(filePath);
-    if (['.css', '.scss', '.sass', '.less'].includes(extname)) {
-        return 'css';
-    }
-    return 'js';
+    return cssTypes.has(getSourceType(filePath)) ? 'css' : 'js';
 };
 
 const saveUntestedFileSource = async (entryFile, options) => {

package/lib/default/options.js

@@ -111,6 +111,11 @@ const defaultOptions = {
     // onEntry: async (entry) => {}
     onEntry: null,
 
+    // (mcr test only) {function} Optional hook before test result publication, onReady and coverage generation.
+    // Results are always collected. Redact sensitive messages/names here before raw/debug export.
+    // onTestEnd: async (testResults) => {}
+    onTestEnd: null,
+
     // {function} onEnd hook
     // onEnd: async (reportData) => {}
     onEnd: null

package/lib/generate.js

@@ -303,8 +303,9 @@ const addZipData = async (mcr, dataList, sourceCache, dir) => {
         }
         const entryName = entry.name;
         const filename = path.basename(entryName);
-        // console.log('============================', filename);
-        if (filename.endsWith('.json')) {
+        // Do not decompress or parse test results (or other unrelated JSON)
+        // when merging coverage. Match the cache reader's accepted prefixes.
+        if (filename.endsWith('.json') && (filename.startsWith('coverage-') || filename.startsWith('source-'))) {
             const buf = await zip.entryData(entryName);
             const json = JSON.parse(buf.toString('utf-8'));
             await addJsonData(mcr, dataList, sourceCache, json, filename);