monocart-coverage-reports 2.13.2 → 3.1.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();
@@ -345,8 +345,29 @@ const getCssAstInfo = (item, coverageList) => {
             endOffset: it.end
         };
     });
-
-    const ast = parseCss(source);
+    let ast;
+    try {
+        ast = parseCss(source);
+    } catch (error) {
+        // Untested files may use preprocessor syntax that postcss cannot parse.
+        // Mirror the JS empty-file fallback: report the whole file as uncovered
+        // instead of aborting report generation.
+        if (empty) {
+            coverageList.push({
+                start: 0,
+                end: source.length,
+                count: 0
+            });
+            return {
+                functions: [],
+                branches: [],
+                statements: []
+            };
+        }
+        throw new Error(`parse css error in ${item.sourcePath}`, {
+            cause: error
+        });
+    }
 
     addCssRules(ast.nodes, coverageList, coveredRanges, empty);
 
@@ -358,7 +379,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=')) {
@@ -121,27 +121,41 @@ const resolveMapUrl = (filename, url) => {
 
 const resolveSourcesContent = (data, url) => {
 
-    const { sources, sourcesContent } = data;
+    const {
+        sources, sourcesContent, sourceRoot
+    } = data;
+    // sourceRoot is a directory, even when its trailing slash is omitted.
+    let rootUrl;
+    if (typeof sourceRoot === 'string' && sourceRoot) {
+        rootUrl = Util.resolveUrl(sourceRoot.endsWith('/') ? sourceRoot : `${sourceRoot}/`, url);
+    }
 
     // sources [1,2,3]
     // sourcesContent could be [null, null, "content"]
     // some of contents could be missed
 
     let hasSourceContent = false;
+    const missingSources = [];
     sources.forEach((file, i) => {
         if (typeof sourcesContent[i] === 'string') {
             hasSourceContent = true;
             return;
         }
 
-        const sourceUrl = Util.resolveUrl(file, url);
+        const sourceUrl = Util.resolveUrl(file, rootUrl?.href || url);
         if (sourceUrl) {
-            let sourcePath = sourceUrl.toString();
-            // could be no `file:`
-            if (sourcePath.startsWith('file:')) {
-                sourcePath = fileURLToPath(sourcePath);
+            let content;
+            try {
+                let sourcePath = sourceUrl.toString();
+                // Read actual local paths, not normalized virtual report paths.
+                if (sourceUrl.protocol === 'file:') {
+                    sourcePath = fileURLToPath(sourceUrl);
+                }
+                content = Util.readFileSync(path.resolve(sourcePath));
+            } catch {
+                // A foreign or malformed file URL is just an unavailable source.
+                // Keep resolving the other sources instead of discarding the map.
             }
-            const content = Util.readFileSync(path.resolve(sourcePath));
             if (typeof content === 'string') {
                 sourcesContent[i] = content;
                 hasSourceContent = true;
@@ -149,13 +163,18 @@ const resolveSourcesContent = (data, url) => {
             }
         }
 
-        sourcesContent[i] = '';
+        missingSources.push(i);
         Util.logDebug(EC.red(`failed to load source content: ${file}`));
 
     });
 
 
     if (hasSourceContent) {
+        // Only commit placeholders for accepted maps. A rejected map may be
+        // cached by the resolver and must not look like valid empty sources later.
+        missingSources.forEach((i) => {
+            sourcesContent[i] = '';
+        });
         return data;
     }
 };
@@ -233,7 +252,7 @@ const collectSourceMaps = async (v8list, options) => {
     for (const item of v8list) {
 
         const {
-            type, url, id, source, sourceMap
+            url, id, source, sourceMap
         } = item;
 
         // source and sourceMap will be saved as separated file (could be cached)
@@ -258,7 +277,7 @@ const collectSourceMaps = async (v8list, options) => {
 
         // An explicitly supplied, usable map takes precedence over sourceMappingURL.
         // Keep the original source so V8 offsets remain valid.
-        if (type === 'js' && !isUsableSourceMap(sourceData.sourceMap)) {
+        if (!isUsableSourceMap(sourceData.sourceMap)) {
             delete sourceData.sourceMap;
             const candidates = getSourceMapCandidates(source);
             if (candidates.length) {
@@ -279,7 +298,7 @@ const collectSourceMaps = async (v8list, options) => {
         const { url } = sourceData;
         for (const candidate of candidates) {
             let data;
-            let sourceMapUrl;
+            let sourceMapUrl = url;
             try {
                 if (candidate.inline) {
                     data = convertSourceMap.fromComment(candidate.comment).sourcemap;
@@ -293,7 +312,9 @@ const collectSourceMaps = async (v8list, options) => {
                 if (!isUsableSourceMap(data)) {
                     continue;
                 }
-                const sourceMap = resolveSourceMap(data, url);
+                // Inline maps inherit the generated file's URL. External maps
+                // resolve their sources relative to the map, not the bundle.
+                const sourceMap = resolveSourceMap(data, sourceMapUrl);
                 if (!sourceMap) {
                     continue;
                 }
@@ -319,7 +340,7 @@ const collectSourceMaps = async (v8list, options) => {
 
 };
 
-module.exports = {
+export {
     collectSourceMaps,
     resolveSourceMap
 };