monocart-coverage-reports 2.13.1 → 3.0.0

package/lib/converter/converter.js

@@ -4,27 +4,29 @@
  * @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 { handleUncoveredInCovered } from './fake-source-coverage.js';
+import { getJsAstInfo, getCssAstInfo } from './ast.js';
+import { getIgnoredRanges } from './ignore.js';
 
-const { getUntestedList } = require('./untested.js');
+import { getUntestedList } from './untested.js';
 
-const {
+import {
     sortRanges, dedupeCountRanges, mergeRangesWith
-} = require('../utils/dedupe.js');
-const { getSourceType, initSourceMapSourcesPath } = require('../utils/source-path.js');
+} from '../utils/dedupe.js';
+import { getSourceType, initSourceMapSourcesPath } 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 +214,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 +222,6 @@ const collectFileCoverage = (v8Data, state, options) => {
         branches,
         statements,
 
-        sourcePath,
         locator
     } = state;
 
@@ -313,7 +314,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,
 
@@ -906,6 +919,12 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
                 // console.log(segment);
                 return;
             }
+            // A malformed map may refer to a source outside its sources array.
+            // Check when mappings are already decoded, not during map selection.
+            const sourceMappings = originalDecodedMap.get(sourceIndex);
+            if (!sourceMappings) {
+                return;
+            }
 
             // 1-base
             const generatedSN = generatedLine + 1;
@@ -936,7 +955,7 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
             }
 
             allDecodedMappings.push(info);
-            originalDecodedMap.get(sourceIndex).push(info);
+            sourceMappings.push(info);
 
             // calculate line end column
             if (!info.last) {
@@ -971,7 +990,7 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
             // console.log(generatedSN, generatedColumn, info, endColumn);
 
             allDecodedMappings.push(endColumn);
-            originalDecodedMap.get(sourceIndex).push(endColumn);
+            sourceMappings.push(endColumn);
 
         });
 
@@ -1151,56 +1170,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;
@@ -1519,44 +1488,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);
 
@@ -1741,7 +1672,7 @@ const addUntestedFiles = async (stateList, options) => {
 
 };
 
-const generateV8DataList = (stateList, options) => {
+const generateV8DataList = (stateList, options, needsIstanbul) => {
 
     const stateMap = new Map();
 
@@ -1795,11 +1726,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)
@@ -1817,7 +1750,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);
@@ -1826,13 +1760,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/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 };

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) => {
@@ -977,4 +977,4 @@ const findOriginalRange = (start, end, state, originalMap, options = {}) => {
 
 };
 
-module.exports = findOriginalRange;
+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 };