monocart-coverage-reports 2.13.2 → 3.1.0

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

@@ -1,5 +1,5 @@
-const { diffSequence } = require('../packages/monocart-coverage-vendor.js');
-const Util = require('../utils/util.js');
+import { diffSequence } from '../packages/monocart-coverage-converter.js';
+import { Util } from '../utils/util.js';
 const EC = Util.EC;
 
 const findMapping = (list, offset) => {
@@ -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 = {}) => {
 
 };
 
-module.exports = findOriginalRange;
+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/flatten-source-maps.js

@@ -1,4 +1,4 @@
-const { decode } = require('../packages/monocart-coverage-vendor.js');
+import { decode } from '@jridgewell/sourcemap-codec';
 
 const COLUMN = 0;
 const SOURCES_INDEX = 1;
@@ -181,6 +181,4 @@ const flattenSourceMaps = function(indexedMap, mapUrl) {
     return indexedMap;
 };
 
-module.exports = {
-    flattenSourceMaps
-};
+export { flattenSourceMaps };

package/lib/converter/ignore.js

@@ -1,4 +1,4 @@
-const Util = require('../utils/util.js');
+import { Util } from '../utils/util.js';
 
 const getNextN = (content, currentLine, item, locator) => {
 
@@ -220,6 +220,4 @@ const getIgnoredRanges = (locator, options) => {
 };
 
 
-module.exports = {
-    getIgnoredRanges
-};
+export { getIgnoredRanges };

package/lib/converter/info-branch.js

@@ -1,5 +1,5 @@
-const Util = require('../utils/util.js');
-module.exports = class InfoBranch {
+import { Util } from '../utils/util.js';
+class InfoBranch {
     constructor(data, original) {
         const {
             start, end, locations, type
@@ -90,4 +90,6 @@ module.exports = class InfoBranch {
         };
     }
 
-};
+}
+
+export { InfoBranch };

package/lib/converter/info-function.js

@@ -1,5 +1,5 @@
-const Util = require('../utils/util.js');
-module.exports = class InfoFunction {
+import { Util } from '../utils/util.js';
+class InfoFunction {
     constructor(data, original) {
 
         const {
@@ -63,4 +63,6 @@ module.exports = class InfoFunction {
             line: line
         };
     }
-};
+}
+
+export { InfoFunction };

package/lib/converter/info-statement.js

@@ -1,5 +1,5 @@
-const Util = require('../utils/util.js');
-module.exports = class InfoStatement {
+import { Util } from '../utils/util.js';
+class InfoStatement {
     constructor(data, original) {
         const {
             start, end, count
@@ -40,4 +40,6 @@ module.exports = class InfoStatement {
 
         return loc;
     }
-};
+}
+
+export { InfoStatement };

package/lib/converter/range-index.js

@@ -0,0 +1,78 @@
+// AST block arrays are immutable during a visit. Weak keys release the index
+// with the array, and rebuilding coverage info creates fresh arrays/indices.
+const indices = new WeakMap();
+const linearSearchLimit = 16;
+
+const createIndex = (ranges) => {
+    // V8 ranges are in start-offset order. Preserve last-in-input semantics for
+    // custom, unsorted coverage rather than sorting it and changing the result.
+    for (let i = 1; i < ranges.length; i++) {
+        if (ranges[i].startOffset < ranges[i - 1].startOffset) {
+            return null;
+        }
+    }
+
+    let size = 1;
+    while (size < ranges.length) {
+        size *= 2;
+    }
+    const maxEnds = new Float64Array(size * 2);
+    maxEnds.fill(-Infinity);
+    for (let i = 0; i < ranges.length; i++) {
+        maxEnds[size + i] = ranges[i].endOffset;
+    }
+    for (let i = size - 1; i > 0; i--) {
+        maxEnds[i] = Math.max(maxEnds[i * 2], maxEnds[i * 2 + 1]);
+    }
+    return {
+        size, maxEnds
+    };
+};
+
+const findRightmost = (maxEnds, node, left, right, limit, end) => {
+    if (left >= limit || maxEnds[node] < end) {
+        return -1;
+    }
+    if (right - left === 1) {
+        return left;
+    }
+    const mid = (left + right) / 2;
+    const found = findRightmost(maxEnds, node * 2 + 1, mid, right, limit, end);
+    if (found !== -1) {
+        return found;
+    }
+    return findRightmost(maxEnds, node * 2, left, mid, limit, end);
+};
+
+// Return the last enclosing range, including equal-start ranges. For sorted
+// arrays the O(n) index is built once; subsequent queries take O(log n).
+const findContainingRange = (ranges, start, end) => {
+    if (ranges.length <= linearSearchLimit) {
+        return ranges.findLast((range) => range.startOffset <= start && range.endOffset >= end);
+    }
+    if (!indices.has(ranges)) {
+        indices.set(ranges, createIndex(ranges));
+    }
+    const index = indices.get(ranges);
+    if (!index) {
+        return ranges.findLast((range) => range.startOffset <= start && range.endOffset >= end);
+    }
+
+    // Only the prefix with startOffset <= start can contain the query.
+    let low = 0;
+    let high = ranges.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (ranges[mid].startOffset <= start) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
+    }
+    const found = findRightmost(index.maxEnds, 1, 0, index.size, low, end);
+    if (found !== -1) {
+        return ranges[found];
+    }
+};
+
+export { findContainingRange };

package/lib/converter/source-range-merge.js

@@ -0,0 +1,103 @@
+// Each group belongs to one source-file merge and is immutable while queried.
+// Weak keys keep indices from retaining coverage after that merge finishes.
+const rangeIndices = new WeakMap();
+const mappingIndices = new WeakMap();
+const mappingScanLimit = 32;
+
+const createRangeIndex = (groupMap) => {
+    // Copy before sorting: custom group order must not be changed.
+    const ranges = Array.from(groupMap.values()).sort((a, b) => a.start - b.start);
+    const starts = new Float64Array(ranges.length);
+    const maxEnds = new Float64Array(ranges.length);
+    let maxEnd = -Infinity;
+    for (let i = 0; i < ranges.length; i++) {
+        starts[i] = ranges[i].start;
+        maxEnd = Math.max(maxEnd, ranges[i].end);
+        maxEnds[i] = maxEnd;
+    }
+    return {
+        starts, maxEnds
+    };
+};
+
+const containsRange = (group, start, end) => {
+    let index = rangeIndices.get(group);
+    if (!index) {
+        index = createRangeIndex(group.groupMap);
+        rangeIndices.set(group, index);
+    }
+    const { starts, maxEnds } = index;
+    let low = 0;
+    let high = starts.length;
+    // The prefix ending at low contains every possible enclosing range.
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (starts[mid] <= start) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
+    }
+    return low > 0 && maxEnds[low - 1] >= end;
+};
+
+const scanMappingPrefix = (mappings, start, end) => {
+    const limit = Math.min(mappingScanLimit, mappings.length);
+    for (let i = 0; i < limit; i++) {
+        const offset = mappings[i].originalOffset;
+        if (offset >= start && offset <= end) {
+            return true;
+        }
+    }
+    // A short list was exhausted; otherwise the answer is still unknown.
+    return mappings.length <= limit ? false : null;
+};
+
+const hasMapping = (group, start, end) => {
+    let offsets = mappingIndices.get(group);
+    if (!offsets) {
+        const mappings = group.state.decodedMappings;
+        // Early hits (or exhausted short lists) need no full copy/sort. Probe
+        // only a bounded prefix so many misses cannot become quadratic scans.
+        const match = scanMappingPrefix(mappings, start, end);
+        if (match !== null) {
+            return match;
+        }
+        // Sort a separate numeric index, not the shared decoded mappings. The
+        // upstream order is by line/column; malformed columns can produce
+        // non-monotonic offsets, so do not assume offset order here.
+        offsets = Float64Array.from(mappings, (item) => item.originalOffset).sort();
+        mappingIndices.set(group, offsets);
+    }
+    let low = 0;
+    let high = offsets.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (offsets[mid] < start) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
+    }
+    // Preserve the old inclusive endpoints, including a mapping at range.end.
+    return low < offsets.length && offsets[low] <= end;
+};
+
+const isUncoveredRange = (range, key, uncoveredGroups) => {
+    for (const group of uncoveredGroups) {
+        if (group.groupMap.has(key)) {
+            continue;
+        }
+        if (containsRange(group, range.start, range.end)) {
+            continue;
+        }
+        if (hasMapping(group, range.start, range.end)) {
+            // Another group maps this range without marking it uncovered.
+            // No later group can change that decision.
+            return false;
+        }
+    }
+    return true;
+};
+
+export { isUncoveredRange };

package/lib/converter/untested.js

@@ -1,10 +1,12 @@
-const fs = require('fs');
-const path = require('path');
-const Util = require('../utils/util.js');
+import fs from 'node:fs';
+import path from 'node:path';
+import { Util } from '../utils/util.js';
 
-const { pathToFileURL, fileURLToPath } = require('url');
+import { pathToFileURL, fileURLToPath } from 'node:url';
 
-const { normalizeSourcePath, getSourcePathReplacer } = require('../utils/source-path.js');
+import {
+    normalizeSourcePath, getSourcePathReplacer, getSourceType, cssTypes
+} from '../utils/source-path.js';
 
 // ========================================================================================================
 
@@ -20,41 +22,7 @@ const resolveAllDirList = (input) => {
     return dirList;
 };
 
-const resolveAllFilter = (input) => {
-    // for function handler
-    if (typeof input === 'function') {
-        return input;
-    }
-
-    // for single minimatch pattern
-    if (input && typeof input === 'string') {
-        // string to multiple patterns "{...}"
-        const obj = Util.strToObj(input);
-        if (obj) {
-            input = obj;
-        } else {
-            return (filePath) => {
-                return Util.betterMinimatch(filePath, input);
-            };
-        }
-    }
-
-    // for patterns
-    if (input && typeof input === 'object') {
-        const patterns = Object.keys(input);
-        return (filePath) => {
-            for (const pattern of patterns) {
-                if (Util.betterMinimatch(filePath, pattern)) {
-                    return input[pattern];
-                }
-            }
-            // false if not matched
-        };
-    }
-
-    // default
-    return () => true;
-};
+const resolveAllFilter = (input) => Util.createFilterHandler(input, (filePath) => filePath);
 
 const resolveAllOptions = (input) => {
     if (!input) {
@@ -101,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) => {
@@ -204,9 +168,22 @@ const getUntestedCoverageData = async (entryList, options, coverageType) => {
     return emptyCoverageList;
 };
 
+const resolveUntestedPath = (entry, baseDir, sourcePathReplacer) => {
+    const sourcePath = normalizeSourcePath(entry.url, baseDir);
+    if (sourcePathReplacer) {
+        const replacement = sourcePathReplacer(sourcePath, entry);
+        if (typeof replacement === 'string' && replacement) {
+            return replacement;
+        }
+    }
+    return sourcePath;
+};
+
 const getEmptyCoverages = async (testedMap, options, coverageType, fileList, fileTransformer) => {
     const sourceFilter = Util.getSourceFilter(options);
     const sourcePathReplacer = getSourcePathReplacer(options);
+    // User callbacks may inspect or mutate entry.source; object replacements cannot.
+    const needsSourceForPath = typeof options.sourcePath === 'function';
     const baseDir = options.baseDir;
 
     // console.log(fileList);
@@ -217,24 +194,16 @@ const getEmptyCoverages = async (testedMap, options, coverageType, fileList, fil
         const { fileType, filePath } = item;
         const type = resolveFileType(fileType, filePath);
         const url = pathToFileURL(filePath).toString();
-        const source = Util.readFileSync(filePath);
         const entry = {
             empty: true,
             type,
-            url,
-            source
+            url
         };
-
-        // normalize sourcePath here
-        let sourcePath = normalizeSourcePath(url, baseDir);
-        if (sourcePathReplacer) {
-            const newSourcePath = sourcePathReplacer(sourcePath, entry);
-            if (typeof newSourcePath === 'string' && newSourcePath) {
-                sourcePath = newSourcePath;
-            }
+        if (needsSourceForPath) {
+            entry.source = Util.readFileSync(filePath);
         }
 
-        // console.log(sourcePath);
+        const sourcePath = resolveUntestedPath(entry, baseDir, sourcePathReplacer);
 
         if (testedMap.has(sourcePath)) {
             continue;
@@ -244,6 +213,9 @@ const getEmptyCoverages = async (testedMap, options, coverageType, fileList, fil
             continue;
         }
 
+        if (!needsSourceForPath) {
+            entry.source = Util.readFileSync(filePath);
+        }
         entry.sourcePath = sourcePath;
 
         await fileTransformer(entry, coverageType);
@@ -302,6 +274,4 @@ const getUntestedList = (testedMap, options, coverageType = 'v8') => {
 };
 
 
-module.exports = {
-    getUntestedList
-};
+export { getUntestedList };