monocart-coverage-reports 2.13.2 → 3.0.0

package/lib/client/ws-session.js

@@ -1,63 +1,141 @@
-const { EventEmitter } = require('events');
+import { EventEmitter } from 'node:events';
+
+const parseMessage = (data) => {
+    const message = JSON.parse(data);
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        throw new Error('Expected a CDP message object');
+    }
+    return message;
+};
 
 class WSSession extends EventEmitter {
-    constructor(ws) {
+    constructor(ws, { timeout = 30000 } = {}) {
         super();
+        if (!Number.isFinite(timeout) || timeout < 0) {
+            throw new RangeError('WebSocket request timeout must be a non-negative finite number');
+        }
         this.ws = ws;
+        this.timeout = timeout;
         this.requestId = 1;
         this.requestCache = new Map();
-        ws.on('message', (data, isBinary) => {
-
-            const message = JSON.parse(data);
-            // console.log(message);
-
-            const { id, method } = message;
-            if (id) {
-                const request = this.requestCache.get(id);
-                this.requestCache.delete(id);
-                if (request) {
-                    request.resolve(message.result);
-                }
-                return;
+        this.events = {
+            message: (data) => this.onMessage(data),
+            error: (error) => this.disconnect(error),
+            close: () => {
+                this.disconnect(new Error('WebSocket closed'));
+                this.unbind(ws);
             }
+        };
+        for (const [name, handler] of Object.entries(this.events)) {
+            ws.on(name, handler);
+        }
+    }
 
-            if (method) {
-                this.emit(method, message.params, message.sessionId);
+    onMessage(data) {
+        let message;
+        try {
+            message = parseMessage(data);
+        } catch (cause) {
+            this.disconnect(new Error('Invalid WebSocket JSON message', {
+                cause
+            }));
+            return;
+        }
+        const { id, method } = message;
+        if (id) {
+            const pending = this.requestCache.get(id);
+            if (!pending) {
+                return;
+            }
+            let error;
+            if (message.error) {
+                error = new Error(`Protocol error (${pending.method}): ${message.error.message}`);
+                error.code = message.error.code;
+                error.data = message.error.data;
             }
+            this.settleRequest(id, error, message.result);
+        } else if (typeof method === 'string') {
+            this.emit(method, message.params, message.sessionId);
+        }
+    }
 
-        });
+    settleRequest(id, error, result) {
+        const pending = this.requestCache.get(id);
+        if (!pending) {
+            return;
+        }
+        this.requestCache.delete(id);
+        clearTimeout(pending.timer);
+        if (error) {
+            pending.reject(error);
+        } else {
+            pending.resolve(result);
+        }
     }
 
     send(method, params) {
         return new Promise((resolve, reject) => {
-            if (!this.ws) {
-                reject(new Error('Invalid websocket'));
+            const ws = this.ws;
+            if (!ws || (typeof ws.readyState === 'number' && ws.readyState !== 1)) {
+                reject(new Error('Invalid or closed websocket'));
                 return;
             }
             const id = this.requestId++;
-            const message = {
-                id,
-                method,
-                params: params || {}
+            const pending = {
+                resolve, reject, method, timer: null
             };
-            this.ws.send(JSON.stringify(message), (err) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                this.requestCache.set(id, {
-                    resolve
+            // Register before send: a response may arrive before its callback.
+            this.requestCache.set(id, pending);
+            if (this.timeout > 0) {
+                pending.timer = setTimeout(() => {
+                    const error = new Error(`WebSocket request timed out: ${method}`);
+                    error.code = 'ETIMEDOUT';
+                    this.settleRequest(id, error);
+                }, this.timeout);
+            }
+            try {
+                ws.send(JSON.stringify({
+                    id, method, params: params || {}
+                }), (error) => {
+                    if (error) {
+                        this.settleRequest(id, error);
+                    }
                 });
-            });
+            } catch (error) {
+                this.settleRequest(id, error);
+            }
         });
     }
 
-    detach() {
-        if (this.ws) {
-            this.ws.terminate();
-            this.ws = null;
+    disconnect(error) {
+        const ws = this.ws;
+        this.ws = null;
+        for (const id of this.requestCache.keys()) {
+            this.settleRequest(id, error);
         }
+        if (ws) {
+            ws.off('message', this.events.message);
+            if (ws.readyState === 3) {
+                this.unbind(ws);
+            } else {
+                // Keep error/close handlers until close to consume termination errors.
+                ws.terminate();
+            }
+        }
+    }
+
+    unbind(ws) {
+        if (this.events) {
+            for (const [name, handler] of Object.entries(this.events)) {
+                ws.off(name, handler);
+            }
+            this.events = null;
+        }
+    }
+
+    detach() {
+        this.disconnect(new Error('WebSocket detached'));
     }
 }
 
-module.exports = WSSession;
+export { WSSession };

package/lib/converter/ast-visitor.js

@@ -1,4 +1,5 @@
-const Util = require('../utils/util.js');
+import { Util } from '../utils/util.js';
+import { findContainingRange } from './range-index.js';
 
 const BranchTypes = {
     ConditionalExpression: 'ConditionalExpression',
@@ -83,17 +84,14 @@ const getFunctionBlock = (start, end, functionState) => {
         return block;
     }
 
-    const uncoveredBlock = Util.findInRanges(start, end, blockUncoveredRanges, 'startOffset', 'endOffset');
+    const uncoveredBlock = findContainingRange(blockUncoveredRanges, start, end);
     if (uncoveredBlock) {
         return uncoveredBlock;
     }
 
     // the block is not exact correct, if there is a block wrapped
     // [x8]{ var a = b || [x4]c }, b is no block, but it can be found in x8 block
-    const coveredBlocks = blockCoveredRanges.filter((it) => start >= it.startOffset && end <= it.endOffset);
-    if (coveredBlocks.length) {
-        return coveredBlocks.pop();
-    }
+    return findContainingRange(blockCoveredRanges, start, end);
 
 };
 
@@ -803,7 +801,7 @@ const collectAstInfo = (ast, coverageInfo) => {
 
 };
 
-module.exports = {
+export {
     BranchTypes,
     collectAstInfo
 };

package/lib/converter/ast.js

@@ -1,9 +1,9 @@
-const acorn = require('acorn');
-const acornLoose = require('acorn-loose');
-const { parseCss } = require('../packages/monocart-coverage-vendor.js');
-const Util = require('../utils/util.js');
+import * as acorn from 'acorn';
+import * as acornLoose from 'acorn-loose';
+import { parseCss } from '../packages/monocart-coverage-converter.js';
+import { Util } from '../utils/util.js';
 
-const { collectAstInfo } = require('./ast-visitor.js');
+import { collectAstInfo } from './ast-visitor.js';
 
 const getCoverageInfo = (coverageList) => {
     const functionMap = new Map();
@@ -358,7 +358,7 @@ const getCssAstInfo = (item, coverageList) => {
 };
 
 
-module.exports = {
+export {
     getJsAstInfo,
     getCssAstInfo
 };

package/lib/converter/collect-source-maps.js

@@ -1,12 +1,12 @@
-const fs = require('fs');
-const path = require('path');
-const EC = require('eight-colors');
-const { fileURLToPath, pathToFileURL } = require('url');
-const Concurrency = require('../platform/concurrency.js');
-const { convertSourceMap } = require('../packages/monocart-coverage-vendor.js');
-const { flattenSourceMaps } = require('./flatten-source-maps.js');
+import fs from 'node:fs';
+import path from 'node:path';
+import EC from 'eight-colors';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Concurrency } from '../platform/concurrency.js';
+import convertSourceMap from 'convert-source-map';
+import { flattenSourceMaps } from './flatten-source-maps.js';
 
-const Util = require('../utils/util.js');
+import { Util } from '../utils/util.js';
 
 const getSourceMapCandidates = (source) => {
     if (!source.includes('sourceMappingURL=')) {
@@ -319,7 +319,7 @@ const collectSourceMaps = async (v8list, options) => {
 
 };
 
-module.exports = {
+export {
     collectSourceMaps,
     resolveSourceMap
 };

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,
 
@@ -1157,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;
@@ -1525,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);
 
@@ -1747,7 +1672,7 @@ const addUntestedFiles = async (stateList, options) => {
 
 };
 
-const generateV8DataList = (stateList, options) => {
+const generateV8DataList = (stateList, options, needsIstanbul) => {
 
     const stateMap = new Map();
 
@@ -1801,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)
@@ -1823,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);
@@ -1832,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 };