monocart-coverage-reports 2.13.1 → 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,23 +1,79 @@
-const fs = require('fs');
-const path = require('path');
-const EC = require('eight-colors');
-const { CommentParser } = require('monocart-locator');
-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');
-
-const Util = require('../utils/util.js');
-
-const getSourceMapComments = (source) => {
+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';
+
+import { Util } from '../utils/util.js';
+
+const getSourceMapCandidates = (source) => {
     if (!source.includes('sourceMappingURL=')) {
         return [];
     }
-    return new CommentParser(source).comments
-        .map((item) => item.text)
-        .filter((comment) => (/^\/[/*][@#][ \t]+sourceMappingURL=/).test(comment));
+
+    // Match directive-shaped text without parsing JS; valid maps in strings can be selected.
+    const candidates = [];
+    for (const match of source.matchAll(convertSourceMap.commentRegex)) {
+        candidates.push({
+            index: match.index,
+            comment: match[0],
+            inline: true
+        });
+    }
+    for (const match of source.matchAll(convertSourceMap.mapFileCommentRegex)) {
+        const filename = match[1] || match[2];
+        if (filename && !filename.startsWith('data:')) {
+            candidates.push({
+                index: match.index,
+                filename
+            });
+        }
+    }
+    // Like 2.13.0, try inline maps before external ones. Within each kind,
+    // start at the last directive and fall back when it is unusable.
+    return candidates.sort((a, b) => {
+        if (a.inline !== b.inline) {
+            return a.inline ? -1 : 1;
+        }
+        return b.index - a.index;
+    });
 };
 
+// Only check the fields required to resolve a map; decoding is deferred to
+// the downstream converter. A map without sources cannot map to original code.
+const isValidBasicMap = (data) => Array.isArray(data.sources)
+    && data.sources.every((source) => typeof source === 'string')
+    && typeof data.mappings === 'string'
+    && (data.sources.length > 0 || data.mappings === '');
+
+const isValidSection = (section) => section && section.offset
+    && Number.isInteger(section.offset.line) && section.offset.line >= 0
+    && Number.isInteger(section.offset.column) && section.offset.column >= 0
+    && isValidSourceMap(section.map);
+
+const isValidSourceMap = (data) => {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return false;
+    }
+    if (Array.isArray(data.sections)) {
+        return data.sections.every(isValidSection);
+    }
+    return isValidBasicMap(data);
+};
+
+// An empty map cannot map coverage to any original source. Try the next
+// candidate instead, including when an indexed map has only empty sections.
+const hasMappings = (data) => {
+    if (Array.isArray(data.sections)) {
+        return data.sections.some((section) => hasMappings(section.map));
+    }
+    return data.mappings.length > 0;
+};
+
+const isUsableSourceMap = (data) => isValidSourceMap(data) && hasMappings(data);
+
 const defaultSourceMapResolver = async (url = '') => {
 
     if (url.startsWith('file:')) {
@@ -63,24 +119,6 @@ const resolveMapUrl = (filename, url) => {
     return urlObj?.toString();
 };
 
-const getSourceMapUrl = (comments, url) => {
-    for (let i = comments.length - 1; i >= 0; i--) {
-        const r = convertSourceMap.mapFileCommentRegex.exec(comments[i]);
-        if (!r || r.index !== 0) {
-            continue;
-        }
-        // //# captures in 1 and /* */ in 2
-        const filename = r[1] || r[2];
-        if (!filename || filename.startsWith('data:')) {
-            continue;
-        }
-        const mapUrl = resolveMapUrl(filename, url);
-        if (mapUrl) {
-            return mapUrl;
-        }
-    }
-};
-
 const resolveSourcesContent = (data, url) => {
 
     const { sources, sourcesContent } = data;
@@ -125,7 +163,7 @@ const resolveSourcesContent = (data, url) => {
 const checkSourcesContent = (data) => {
     const { sourcesContent, sources } = data;
 
-    if (!sourcesContent) {
+    if (!Array.isArray(sourcesContent)) {
         data.sourcesContent = [];
         return false;
     }
@@ -146,15 +184,7 @@ const resolveSectionedSourceMap = (data, url, sections) => {
         // offset: { line: 1, column: 0 },
         // map: { sources, sourcesContent  }
 
-        const map = item.map;
-
-        if (checkSourcesContent(map)) {
-            hasSourceContent = true;
-            return;
-        }
-
-        const done = resolveSourcesContent(map, url);
-        if (done) {
+        if (resolveSourceMap(item.map, url)) {
             hasSourceContent = true;
         }
 
@@ -169,6 +199,10 @@ const resolveSourceMap = (data, url) => {
     if (!data) {
         return;
     }
+    // Optional metadata may be absent or malformed in otherwise usable maps.
+    if (!Array.isArray(data.names)) {
+        data.names = [];
+    }
     const {
         sections, sources, mappings
     } = data;
@@ -177,7 +211,7 @@ const resolveSourceMap = (data, url) => {
         return resolveSectionedSourceMap(data, url, sections);
     }
 
-    if (!sources || !mappings) {
+    if (!Array.isArray(sources) || typeof mappings !== 'string') {
         return;
     }
 
@@ -191,21 +225,6 @@ const resolveSourceMap = (data, url) => {
 
 };
 
-const getInlineSourceMap = (comments) => {
-    for (let i = comments.length - 1; i >= 0; i--) {
-        const comment = comments[i];
-        const match = convertSourceMap.commentRegex.exec(comment);
-        if (!match || match.index !== 0) {
-            continue;
-        }
-        try {
-            return convertSourceMap.fromComment(comment);
-        } catch (e) {
-            // Ignore invalid inline maps.
-        }
-    }
-};
-
 const collectSourceMaps = async (v8list, options) => {
 
     const sourceList = [];
@@ -237,52 +256,60 @@ const collectSourceMaps = async (v8list, options) => {
             sourceMap
         };
 
+        // An explicitly supplied, usable map takes precedence over sourceMappingURL.
         // Keep the original source so V8 offsets remain valid.
-        // check sourceMap only for js
-        if (type === 'js' && !sourceData.sourceMap) {
-            const comments = getSourceMapComments(source);
-            // from inline sync
-            const smc = getInlineSourceMap(comments);
-            if (smc) {
-                sourceData.sourceMap = resolveSourceMap(smc.sourcemap, url);
-                sourcemapList.push({
-                    url,
-                    inline: true
-                });
-                sourceList.push(sourceData);
-                continue;
-            }
-            // from url async
-            const sourceMapUrl = getSourceMapUrl(comments, url);
-            if (sourceMapUrl) {
+        if (type === 'js' && !isUsableSourceMap(sourceData.sourceMap)) {
+            delete sourceData.sourceMap;
+            const candidates = getSourceMapCandidates(source);
+            if (candidates.length) {
                 concurrency.addItem({
-                    sourceMapUrl,
+                    candidates,
                     sourceData
                 });
-                continue;
             }
         }
 
-        // no need check sourceMap
+        // Keep source entries in input order while maps load concurrently.
         sourceList.push(sourceData);
 
     }
 
-    // from url concurrency
     await concurrency.start(async (item) => {
-        const { sourceMapUrl, sourceData } = item;
+        const { candidates, sourceData } = item;
         const { url } = sourceData;
-        const data = await loadSourceMap(sourceMapUrl, options);
-        if (data) {
-            sourceData.sourceMap = resolveSourceMap(data, url);
-            sourcemapList.push({
-                url,
-                sourceMapUrl
-            });
+        for (const candidate of candidates) {
+            let data;
+            let sourceMapUrl;
+            try {
+                if (candidate.inline) {
+                    data = convertSourceMap.fromComment(candidate.comment).sourcemap;
+                } else {
+                    sourceMapUrl = resolveMapUrl(candidate.filename, url);
+                    if (!sourceMapUrl) {
+                        continue;
+                    }
+                    data = await loadSourceMap(sourceMapUrl, options);
+                }
+                if (!isUsableSourceMap(data)) {
+                    continue;
+                }
+                const sourceMap = resolveSourceMap(data, url);
+                if (!sourceMap) {
+                    continue;
+                }
+                sourceData.sourceMap = sourceMap;
+                sourcemapList.push(candidate.inline ? {
+                    url,
+                    inline: true
+                } : {
+                    url,
+                    sourceMapUrl
+                });
+                break;
+            } catch (e) {
+                // Try an earlier sourceMappingURL if parsing or loading fails.
+            }
         }
-
-        sourceList.push(sourceData);
-
     });
 
     return {
@@ -292,7 +319,7 @@ const collectSourceMaps = async (v8list, options) => {
 
 };
 
-module.exports = {
+export {
     collectSourceMaps,
     resolveSourceMap
 };