monocart-coverage-reports 2.13.2 → 3.0.0

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,10 @@
-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 } from '../utils/source-path.js';
 
 // ========================================================================================================
 
@@ -20,41 +20,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) {
@@ -204,9 +170,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 +196,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 +215,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 +276,4 @@ const getUntestedList = (testedMap, options, coverageType = 'v8') => {
 };
 
 
-module.exports = {
-    getUntestedList
-};
+export { getUntestedList };

package/lib/default/options.js

@@ -1,4 +1,4 @@
-module.exports = {
+const defaultOptions = {
 
     // {string} logging levels: off, error, info, debug
     logging: 'info',
@@ -24,6 +24,12 @@ module.exports = {
     // {string|string[]} input raw dir(s)
     inputDir: null,
 
+    // (mcr test only) {string|string[]|null} Test file paths or glob patterns accepted by node --test.
+    // A string is one positional argument; an array supplies multiple arguments unchanged.
+    // Used when no CLI targets are supplied; null skips tests and is not passed to Node.
+    // Ignored by other CLI commands and the API.
+    test: null,
+
     // {string} base dir for normalizing the relative source path, defaults to cwd
     baseDir: null,
 
@@ -43,6 +49,10 @@ module.exports = {
     // sourceFilter: (sourcePath) => sourcePath.search(/src\/.+/) !== -1,
     sourceFilter: null,
 
+    // (V8 only) Filter final files by sourcePath after sourcemap conversion and adding untested files.
+    // outputFilter: (entry) => entry.sourcePath.startsWith('src/'),
+    outputFilter: null,
+
     // The combined filter for entryFilter and sourceFilter
     filter: null,
 
@@ -105,3 +115,5 @@ module.exports = {
     // onEnd: async (reportData) => {}
     onEnd: null
 };
+
+export { defaultOptions };

package/lib/generate.js

@@ -1,35 +1,28 @@
-const fs = require('fs');
-const path = require('path');
-const { fileURLToPath } = require('url');
-const EC = require('eight-colors');
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import EC from 'eight-colors';
 
-const Util = require('./utils/util.js');
-const { convertV8List } = require('./converter/converter.js');
-const { resolveSourceMap } = require('./converter/collect-source-maps.js');
-const { StreamZip } = require('./packages/monocart-coverage-vendor.js');
+import { Util } from './utils/util.js';
+import { resolveSourceMap } from './converter/collect-source-maps.js';
 
 // ========================================================================================================
 // built-in reports
 
-// istanbul
-const { mergeIstanbulCoverage, saveIstanbulReports } = require('./istanbul/istanbul.js');
-
 // v8
-const { mergeV8Coverage, saveV8Report } = require('./v8/v8.js');
+import { mergeV8Coverage, saveV8Report } from './v8/v8.js';
 
 // both
-const { codecovReport } = require('./reports/codecov.js');
-const { codacyReport } = require('./reports/codacy.js');
-
-const { consoleDetailsReport } = require('./reports/console-details.js');
-const { consoleSummaryReport } = require('./reports/console-summary.js');
+import { codecovReport } from './reports/codecov.js';
+import { codacyReport } from './reports/codacy.js';
 
-const { markdownDetailsReport } = require('./reports/markdown-details.js');
-const { markdownSummaryReport } = require('./reports/markdown-summary.js');
+import { consoleDetailsReport } from './reports/console-details.js';
+import { consoleSummaryReport } from './reports/console-summary.js';
 
-const { rawReport } = require('./reports/raw.js');
+import { markdownDetailsReport } from './reports/markdown-details.js';
+import { markdownSummaryReport } from './reports/markdown-summary.js';
 
-const { customReport } = require('./reports/custom.js');
+import { customReport } from './reports/custom.js';
 
 const allBuiltInReports = {
     // v8
@@ -71,7 +64,10 @@ const bothBuiltInReports = {
     'markdown-details': markdownDetailsReport,
     'markdown-summary': markdownSummaryReport,
 
-    'raw': rawReport
+    'raw': async (... args) => {
+        const { rawReport } = await import('./reports/raw.js');
+        return rawReport(... args);
+    }
 };
 
 // ========================================================================================================
@@ -146,6 +142,7 @@ const generateV8ListReports = async (v8list, coverageData, fileSources, options)
     let istanbulReportPath;
     // v8 to istanbul reports
     if (options.reportGroup.has('istanbul')) {
+        const { saveIstanbulReports } = await import('./istanbul/istanbul.js');
         const istanbulCoverageResults = await saveIstanbulReports(coverageData, fileSources, options);
         istanbulReportPath = istanbulCoverageResults.reportPath;
     }
@@ -175,17 +172,34 @@ const getCoverageResults = async (dataList, sourceCache, options) => {
         // console.log('after merge', v8list.map((it) => it.url));
 
         const t2 = Date.now();
-        const results = await convertV8List(v8list, options);
+        const { convertV8List } = await import('./converter/converter.js');
+        const results = await convertV8List(v8list, options, options.reportGroup.has('istanbul'));
         Util.logTime(`${EC.magenta('├')} [generate] converted coverage data`, t2);
 
         const {
             v8DataList, coverageData, fileSources
         } = results;
-        return generateV8ListReports(v8DataList, coverageData, fileSources, options);
+
+        let filteredV8DataList = v8DataList;
+        if (options.outputFilter) {
+            const outputFilter = Util.createFilterHandler(options.outputFilter, (entry) => entry.sourcePath);
+            filteredV8DataList = v8DataList.filter(outputFilter);
+            // Keep V8 and converted Istanbul reports in sync.
+            const sourcePaths = new Set(filteredV8DataList.map((entry) => entry.sourcePath));
+            Object.keys(coverageData).forEach((sourcePath) => {
+                if (!sourcePaths.has(sourcePath)) {
+                    delete coverageData[sourcePath];
+                    delete fileSources[sourcePath];
+                }
+            });
+        }
+
+        return generateV8ListReports(filteredV8DataList, coverageData, fileSources, options);
     }
 
     // istanbul data
     const t3 = Date.now();
+    const { mergeIstanbulCoverage, saveIstanbulReports } = await import('./istanbul/istanbul.js');
     const istanbulData = await mergeIstanbulCoverage(dataList, options);
     Util.logTime(`${EC.magenta('├')} [generate] prepared istanbul coverage data`, t3);
     const fileSources = options.fileSources || {};
@@ -277,6 +291,8 @@ const addDirData = async (mcr, dataList, sourceCache, dir) => {
 };
 
 const addZipData = async (mcr, dataList, sourceCache, dir) => {
+    const { default: StreamZipModule } = await import('node-stream-zip');
+    const StreamZip = StreamZipModule.async;
     const zip = new StreamZip({
         file: dir
     });
@@ -327,7 +343,9 @@ const getInputData = async (mcr) => {
             return;
         }
         // No coverage input: use V8 so `all` can add untested files.
-        dataList.push({ type: 'v8', data: [] });
+        dataList.push({
+            type: 'v8', data: []
+        });
     }
 
     return {
@@ -491,7 +509,7 @@ const readFromDir = async (mcr, dir) => {
 
 };
 
-module.exports = {
+export {
     getInputData,
     readFromDir,
     generateCoverageReports

package/lib/index.d.ts

@@ -322,6 +322,14 @@ declare namespace MCR {
             [pattern: string]: boolean;
         } | ((sourcePath: string) => boolean);
 
+        /** (V8 only) Filter final files after sourcemap conversion and adding untested files.
+         * Applies to V8 reports and converted Istanbul reports. Defaults to null (disabled).
+         * Strings and object keys match sourcePath using the same rules as entryFilter and sourceFilter.
+         */
+        outputFilter?: string | {
+            [pattern: string]: boolean;
+        } | ((entry: CoverageFile) => boolean) | null;
+
         /**
          * The combined filter for entryFilter and sourceFilter
          */
@@ -405,7 +413,7 @@ declare namespace MCR {
         cleanCache?: boolean;
 
         /**
-         * {number} gc threshold
+         * {number} JavaScript heapUsed threshold in MB
          * for example: sets gc to 1024 means that force gc when the memory > 1024M at certain critical stages
          * https://nodejs.org/docs/latest/api/v8.html#v8setflagsfromstringflags
          */
@@ -432,6 +440,15 @@ declare namespace MCR {
 
     export interface McrCliOptions extends CoverageReportOptions {
 
+        /** Only used by `mcr test`. Test file paths or glob patterns accepted by node --test.
+         * A string is one positional argument; an array supplies multiple arguments unchanged.
+         * Node handles parsing and discovery relative to cwd; null is not passed to Node.
+         * Positional CLI targets override this option.
+         * Defaults to null (skip tests unless CLI targets are supplied).
+         * Requires Node.js >= 22.15.0. Ignored by other commands and the API.
+         */
+        test?: string | string[] | null;
+
         /** (CLI only) {function} onStart hook */
         onStart?: (coverageReport: CoverageReport) => void | Promise<void>;
 
@@ -479,6 +496,8 @@ declare namespace MCR {
         /** load config file. 
          * 
          * @param configFile custom config file path
+         * Throws if a custom config is missing or a discovered config fails to load.
+         * If no custom config is specified and no default config is found, returns normally.
          * 
          * Supports loading default config file if no custom config specified: 
             'mcr.config.js',
@@ -532,6 +551,9 @@ declare namespace MCR {
     //=====================================================================================================
 
     export class CoverageClient {
+        /** Best-effort command: logs failures at debug level and resolves to null instead of rejecting. */
+        safeSend: (method: string, params?: any) => Promise<any>;
+
         /** start js coverage */
         startJSCoverage: () => Promise<void>;
         /** stop and return js coverage */
@@ -567,7 +589,8 @@ declare namespace MCR {
 
     /** custom websocket CDPSession */
     export class WSSession implements CDPSession {
-        constructor(ws: any);
+        /** Request timeout defaults to 30000ms; 0 disables the deadline. */
+        constructor(ws: any, options?: { timeout?: number });
         send: (method: string, params?: any) => Promise<any>;
         on: (type: string, handler: (e: any) => void) => void;
         detach: () => Promise<void>;
@@ -588,8 +611,10 @@ declare namespace MCR {
         target?: (targets: any) => any;
         /** websocket options */
         ws?: any;
-        /** timeout, defaults to 10 * 1000 */
+        /** HTTP discovery / WebSocket connection timeout, defaults to 10000ms; 0 disables it. */
         timeout?: number;
+        /** Per-command timeout for built-in WebSocket sessions, defaults to 30000ms; 0 disables it. */
+        requestTimeout?: number;
     }
 
     export function CDPClient(cdpOptions: CDPOptions): Promise<CoverageClient | undefined>;
@@ -603,4 +628,27 @@ declare namespace MCR {
 /** create coverage report */
 declare function MCR(options?: MCR.CoverageReportOptions): MCR.CoverageReport;
 
-export = MCR;
+export { MCR as default, MCR };
+export import V8CoverageEntry = MCR.V8CoverageEntry;
+export import Watermarks = MCR.Watermarks;
+export import ReportDescription = MCR.ReportDescription;
+export import AddedResults = MCR.AddedResults;
+export import MetricsSummary = MCR.MetricsSummary;
+export import CoverageSummary = MCR.CoverageSummary;
+export import CoverageRange = MCR.CoverageRange;
+export import IgnoredRange = MCR.IgnoredRange;
+export import CoverageFile = MCR.CoverageFile;
+export import CoverageResults = MCR.CoverageResults;
+export import LoggingType = MCR.LoggingType;
+export import CoverageReportOptions = MCR.CoverageReportOptions;
+export import McrCliOptions = MCR.McrCliOptions;
+export import CoverageSnapshot = MCR.CoverageSnapshot;
+export import CoverageClient = MCR.CoverageClient;
+export import CDPSession = MCR.CDPSession;
+export import CDPOptions = MCR.CDPOptions;
+export import CoverageReport = MCR.CoverageReport;
+export import getSnapshot = MCR.getSnapshot;
+export import diffSnapshot = MCR.diffSnapshot;
+export import WSSession = MCR.WSSession;
+export import CDPClient = MCR.CDPClient;
+export import Util = MCR.Util;