monocart-coverage-reports 2.13.2 → 3.1.0

package/lib/reports/raw.js

@@ -1,12 +1,11 @@
-const fs = require('fs');
-const path = require('path');
-const Util = require('../utils/util.js');
-const { ZipFile } = require('../packages/monocart-coverage-vendor.js');
-const { mergeIstanbulDataList } = require('../istanbul/istanbul.js');
-const { mergeV8DataList } = require('../v8/v8.js');
-
-const getMergedData = (type, dataList, options) => {
+import fs from 'node:fs';
+import path from 'node:path';
+import { Util } from '../utils/util.js';
+import { mergeV8DataList } from '../v8/v8.js';
+
+const getMergedData = async (type, dataList, options) => {
     if (type === 'istanbul') {
+        const { mergeIstanbulDataList } = await import('../istanbul/istanbul.js');
         return mergeIstanbulDataList(dataList, options);
     }
     return mergeV8DataList(dataList, options);
@@ -43,7 +42,8 @@ const mergeReport = async (rawDir, options) => {
 
 };
 
-const zipReport = (rawDir, rawParent) => {
+const zipReport = async (rawDir, rawParent) => {
+    const { ZipFile } = await import('yazl');
     const zipName = path.basename(rawDir);
     const zipPath = path.resolve(rawParent, `${zipName}.zip`);
 
@@ -110,6 +110,4 @@ const rawReport = async (reportData, reportOptions, options) => {
 
 };
 
-module.exports = {
-    rawReport
-};
+export { rawReport };

package/lib/reports/v8-json.js

@@ -1,5 +1,5 @@
-const path = require('path');
-const Util = require('../utils/util.js');
+import path from 'node:path';
+import { Util } from '../utils/util.js';
 
 const v8JsonReport = async (reportData, reportOptions, options) => {
     const v8JsonOptions = {
@@ -17,6 +17,4 @@ const v8JsonReport = async (reportData, reportOptions, options) => {
     return reportPath;
 };
 
-module.exports = {
-    v8JsonReport
-};
+export { v8JsonReport };

package/lib/reports/v8.js

@@ -1,5 +1,4 @@
-const path = require('path');
-const Assets = require('../assets.js');
+import path from 'node:path';
 
 const v8Report = async (reportData, reportOptions, options) => {
 
@@ -41,11 +40,10 @@ const v8Report = async (reportData, reportOptions, options) => {
     };
 
     // compress json data for html
+    const { Assets } = await import('../assets.js');
     const htmlPath = await Assets.saveHtmlReport(htmlOptions);
 
     return htmlPath;
 };
 
-module.exports = {
-    v8Report
-};
+export { v8Report };

package/lib/utils/dedupe.js

@@ -115,7 +115,7 @@ const dedupeCountRanges = (ranges) => {
 };
 
 
-module.exports = {
+export {
     sortRanges,
     dedupeFlatRanges,
     mergeRangesWith,

package/lib/utils/gc.js

@@ -1,18 +1,34 @@
+let collect;
 
-const isBun = typeof Bun !== 'undefined' && Boolean(process.versions.bun);
-
-if (typeof global.gc !== 'function') {
+const createGC = () => {
+    const v8 = process.getBuiltinModule('v8');
+    const vm = process.getBuiltinModule('vm');
+    // The host may have replaced global.gc while leaving the flag enabled.
+    const existing = vm.runInNewContext('typeof gc === "function" ? gc : null');
+    if (existing) {
+        return existing;
+    }
+    v8.setFlagsFromString('--expose_gc');
+    try {
+        return vm.runInNewContext('gc');
+    } finally {
+        v8.setFlagsFromString('--no-expose_gc');
+    }
+};
 
-    if (isBun) {
-        global.gc = () => {
-            Bun.gc(true);
-        };
-    } else {
-        const v8 = require('node:v8');
-        const vm = require('node:vm');
-        v8.setFlagsFromString('--expose_gc');
-        global.gc = vm.runInNewContext('gc');
+// Importing MCR must not change V8 flags or install globals in the host process.
+const gc = () => {
+    if (typeof globalThis.gc === 'function') {
+        return globalThis.gc();
+    }
+    if (!collect) {
+        if (typeof Bun !== 'undefined' && process.versions.bun) {
+            collect = () => Bun.gc(true);
+        } else {
+            collect = createGC();
+        }
     }
-}
+    return collect();
+};
 
-module.exports = global.gc;
+export { gc };

package/lib/utils/markdown.js

@@ -1,4 +1,4 @@
-const os = require('os');
+import os from 'node:os';
 
 const renderLine = (ls, padding) => {
     const spacing = ''.padEnd(padding, ' ');
@@ -129,4 +129,4 @@ const markdownGrid = (data) => {
 };
 
 
-module.exports = markdownGrid;
+export { markdownGrid };

package/lib/utils/merge/merge.js

@@ -4,7 +4,7 @@
  * https://github.com/demurgos/v8-coverage
  */
 
-const RangeTree = require('./range-tree.js');
+import { RangeTree } from './range-tree.js';
 
 
 /**
@@ -430,6 +430,4 @@ function mergeV8Coverage(scriptCovs) {
     return merged;
 }
 
-module.exports = {
-    mergeV8Coverage
-};
+export { mergeV8Coverage };

package/lib/utils/merge/range-tree.js

@@ -120,4 +120,4 @@ class RangeTree {
     }
 }
 
-module.exports = RangeTree;
+export { RangeTree };

package/lib/utils/request.js

@@ -1,86 +1,98 @@
-const http = require('http');
-const https = require('https');
+import http from 'node:http';
+import https from 'node:https';
 
-// minimal http request for get sourcemap json
-// https://nodejs.org/docs/latest/api/http.html#httprequesturl-options-callback
-const request = (url, options) => {
-
-    const HTTP = url.startsWith('https') ? https : http;
-    // console.log('request', url);
-
-    return new Promise((resolve) => {
-
-        // get method only
-        HTTP.get(url, options, (res) => {
-            const { statusCode } = res;
-
-            // Any 2xx status code signals a successful response but here we're only checking for 200.
-            if (statusCode !== 200) {
-                // Consume response data to free up memory
-                res.resume();
-                const resErr = new Error(`Request Failed. Status Code: ${statusCode}`);
-                resolve([resErr]);
-                return;
-            }
-
-            res.setEncoding('utf8');
-
-            let rawData = '';
-            res.on('data', (chunk) => {
-                rawData += chunk;
-            });
-
-            res.on('end', () => {
-
-                let dataErr;
-                let data = rawData;
-
-                // parse json
-                const contentType = res.headers['content-type'];
-                if ((/^application\/json/).test(contentType)) {
-                    try {
-                        data = JSON.parse(rawData);
-                    } catch (e) {
-                        dataErr = e;
-                    }
-                }
-
-                res.data = data;
-                resolve([dataErr, res]);
-
-            });
-
-        }).on('error', (httpErr) => {
-
-            resolve([httpErr]);
+const readResponse = async (res) => {
+    if (res.statusCode !== 200) {
+        res.destroy();
+        return [new Error(`Request Failed. Status Code: ${res.statusCode}`)];
+    }
+    res.setEncoding('utf8');
+    let rawData = '';
+    // Async iteration rejects on response errors and premature connection close.
+    for await (const chunk of res) {
+        rawData += chunk;
+    }
+    let dataErr;
+    let data = rawData;
+    if ((/^application\/json/).test(res.headers['content-type'])) {
+        try {
+            data = JSON.parse(rawData);
+        } catch (error) {
+            dataErr = error;
+        }
+    }
+    res.data = data;
+    return [dataErr, res];
+};
 
+// Keep the existing [error, IncomingMessage] API and Node HTTP options.
+// timeout is a total deadline (headers and body); 0 explicitly disables it.
+const requestHTTP = (url, options) => new Promise((resolve) => {
+    const { timeout = 30000, ... requestOptions } = options;
+    const HTTP = url.startsWith('https:') ? https : http;
+    let req;
+    let timer;
+    let settled = false;
+    const finish = (result) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        resolve(result);
+    };
+    const fail = (error) => {
+        finish([error]);
+        req?.destroy();
+    };
+    try {
+        req = HTTP.get(url, requestOptions, (res) => {
+            readResponse(res).then(finish, fail);
         });
+        req.once('error', fail);
+        if (timeout > 0) {
+            timer = setTimeout(() => {
+                const error = new Error(`Request timed out after ${timeout}ms: ${url}`);
+                error.code = 'ETIMEDOUT';
+                fail(error);
+            }, timeout);
+        }
+    } catch (error) {
+        fail(error);
+    }
+});
 
-    });
+const resolveRequestURL = (url, options) => {
+    const urlObj = new URL(url);
+    if (!['http:', 'https:'].includes(urlObj.protocol)) {
+        throw new TypeError(`Unsupported request protocol: ${urlObj.protocol}`);
+    }
+    const { timeout = 30000 } = options;
+    if (!Number.isFinite(timeout) || timeout < 0) {
+        throw new RangeError('Request timeout must be a non-negative finite number');
+    }
+    return urlObj;
 };
 
-module.exports = async (url, options = {}) => {
-    let urlErr;
+const shouldRetryIPv4 = (err, urlObj, options) => err?.code === 'ECONNREFUSED'
+    && urlObj.hostname === 'localhost' && !options.signal?.aborted;
+
+const request = async (url, options = {}) => {
     let urlObj;
     try {
-        urlObj = new URL(url);
-    } catch (err) {
-        // console.error('error url', input);
-        urlErr = err;
+        urlObj = resolveRequestURL(url, options);
+    } catch (error) {
+        return [error];
     }
 
-    if (urlErr) {
-        return [urlErr];
-    }
-
-    const [err, res] = await request(urlObj.toString(), options);
-    if (err) {
-        // replace localhost to 127.0.0.1
-        // ECONNREFUSED on NodeJS 18 https://github.com/node-fetch/node-fetch/issues/1624
-        if (urlObj.hostname === 'localhost') {
-            urlObj.hostname = '127.0.0.1';
-            return request(urlObj.toString(), options);
-        }
+    const [err, res] = await requestHTTP(urlObj.toString(), options);
+    // IPv4-only servers can reject localhost's IPv6 address on modern Node too.
+    // Do not repeat timeouts, aborts, HTTP failures or JSON parsing errors.
+    if (shouldRetryIPv4(err, urlObj, options)) {
+        urlObj.hostname = '127.0.0.1';
+        return requestHTTP(urlObj.toString(), options);
     }
     return [err, res];
 };
+
+export { request };

package/lib/utils/snapshot.js

@@ -1,7 +1,7 @@
-const CG = require('console-grid');
-const EC = require('eight-colors');
+import CG from 'console-grid';
+import EC from 'eight-colors';
 
-const Util = require('./util.js');
+import { Util } from './util.js';
 
 const mergeSingleSubGroups = (item) => {
 
@@ -341,7 +341,7 @@ const diffSnapshot = (oldData, newData, diffOptions) => {
     };
 };
 
-module.exports = {
+export {
     getGroupedRows,
     getSnapshot,
     diffSnapshot

package/lib/utils/source-path.js

@@ -1,7 +1,7 @@
-const fs = require('fs');
-const path = require('path');
-const { fileURLToPath, pathToFileURL } = require('url');
-const Util = require('./util.js');
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Util } from './util.js';
 
 const resolveSourceRootUrl = (sourceName, sourceRoot) => {
     // prepend sourceRoot
@@ -31,8 +31,13 @@ const resolveAnonymousUrl = (url, index, type) => {
 
 const normalizePathDir = (sourcePath) => {
 
-    // decodeURI("%20") to space
-    let str = decodeURI(`${sourcePath}`);
+    let str = `${sourcePath}`;
+    try {
+        // decodeURI("%20") to space
+        str = decodeURI(str);
+    } catch {
+        // Preserve unresolvable URI text instead of aborting the report.
+    }
     str = str.replace(/\\/g, '/');
 
     // remove / of start, end or double, ./ ../
@@ -55,15 +60,21 @@ const betterFileURLToPath = (url) => {
     try {
         url = fileURLToPath(url);
     } catch (e) {
-        url = decodeURIComponent(url);
-        url = fileURLToPath(url);
+        try {
+            url = decodeURIComponent(url);
+            url = fileURLToPath(url);
+        } catch {
+            // in case that it cannot be safely resolved, we pass it verbatim.
+            return url;
+        }
     }
     return url;
 };
 
 const normalizeSourcePath = (sourceUrl, baseDir) => {
 
-    // includes anonymous and everything
+    // Best-effort report paths, not filesystem lookup paths. Leave special cases
+    // to sourcePath, which can use the original URL instead of guessing here.
 
     // file url
     if (sourceUrl.startsWith('file:')) {
@@ -120,11 +131,14 @@ const normalizeSourcePath = (sourceUrl, baseDir) => {
     return normalizePathDir(relPath);
 };
 
+const cssTypes = new Set(['css', 'less', 'sass', 'scss', 'styl', 'stylus', 'postcss', 'pcss', 'sss']);
+
 const getSourceType = (sourcePath) => {
     let ext = path.extname(sourcePath);
     let type = 'js';
     if (ext) {
-        ext = ext.slice(1);
+        // extensions are case-insensitive, e.g. `.CSS` or `.SCSS`
+        ext = ext.slice(1).toLowerCase();
         const reg = /^[a-z0-9]+$/;
         if (reg.test(ext)) {
             type = ext;
@@ -241,10 +255,11 @@ const initSourceMapSourcesPath = (fileUrls, sourceMap, distFile, options) => {
 
 };
 
-module.exports = {
+export {
     resolveAnonymousUrl,
     normalizeSourcePath,
     getSourceType,
+    cssTypes,
     getSourcePathReplacer,
     initIstanbulSourcePath,
     initSourceMapSourcesPath

package/lib/utils/util.js

@@ -1,23 +1,45 @@
-const fs = require('fs');
-const { writeFile, readFile } = require('fs/promises');
-const path = require('path');
-const os = require('os');
-const crypto = require('crypto');
-
-const EC = require('eight-colors');
-const CG = require('console-grid');
-const acornWalk = require('acorn-walk');
-
-const Share = require('../platform/share.js');
-const request = require('./request.js');
-const version = require('../../package.json').version;
-const markdownGrid = require('./markdown.js');
-const { mergeV8Coverage } = require('./merge/merge.js');
-const gc = require('./gc.js');
-
-const {
-    findUpSync, supportsColor, minimatch
-} = require('../packages/monocart-coverage-vendor.js');
+import packageMetadata from '../../package.json' with { type: 'json' };
+import fs from 'node:fs';
+import { writeFile, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+
+import EC from 'eight-colors';
+import CG from 'console-grid';
+import * as acornWalk from 'acorn-walk';
+
+import { Util as Share } from '../platform/share.js';
+import { request } from './request.js';
+import { markdownGrid } from './markdown.js';
+import { mergeV8Coverage } from './merge/merge.js';
+import { gc } from './gc.js';
+
+import {
+    findUpSync, supportsColor, minimatch, Minimatch
+} from '../packages/monocart-coverage-vendor.js';
+
+const version = packageMetadata.version;
+
+// Compile lazily: substring matches need no glob, and invalid patterns should
+// only fail when the old matcher would actually have evaluated them.
+const createPatternMatcher = (pattern) => {
+    let matcher;
+    const match = (value) => {
+        matcher ||= new Minimatch(pattern);
+        return matcher.match(value);
+    };
+    return (value) => Util.betterMinimatch(value, pattern, match);
+};
+
+const getMemoryAfterGC = () => {
+    const memory = Util.getMemory();
+    if (Util.gcThreshold && Util.gcThreshold < memory) {
+        Util.forceGC();
+        return Util.getMemory();
+    }
+    return memory;
+};
 
 // https://github.com/chalk/supports-color
 // disabled color if Terminal stdout does not support color
@@ -185,7 +207,7 @@ const Util = {
         };
     },
 
-    betterMinimatch: (str, pattern) => {
+    betterMinimatch: (str, pattern, match = (value) => minimatch(value, pattern)) => {
         str = `${str}`;
         pattern = `${pattern}`;
 
@@ -199,18 +221,23 @@ const Util = {
         }
 
         // with minimatch
-        if (minimatch(str, pattern)) {
+        if (match(str)) {
             return true;
         }
 
         // after decode url
-        str = decodeURIComponent(str);
+        try {
+            str = decodeURIComponent(str);
+        } catch {
+            // The raw path did not match and cannot be decoded. Let later rules run.
+            return false;
+        }
 
         if (str.includes(pattern)) {
             return true;
         }
 
-        if (minimatch(str, pattern)) {
+        if (match(str)) {
             return true;
         }
 
@@ -229,19 +256,18 @@ const Util = {
             if (obj) {
                 input = obj;
             } else {
-                return (item) => {
-                    return Util.betterMinimatch(fieldAccessor(item), input);
-                };
+                const match = createPatternMatcher(input);
+                return (item) => match(fieldAccessor(item));
             }
         }
 
         // for patterns
         if (input && typeof input === 'object') {
-            const patterns = Object.keys(input);
+            const patterns = Object.keys(input).map((pattern) => [pattern, createPatternMatcher(pattern)]);
             return (item) => {
                 const value = fieldAccessor(item);
-                for (const pattern of patterns) {
-                    if (Util.betterMinimatch(value, pattern)) {
+                for (const [pattern, match] of patterns) {
+                    if (match(value)) {
                         return input[pattern];
                     }
                 }
@@ -426,11 +452,12 @@ const Util = {
             }
         };
 
-        const list = fs.readdirSync(dir);
-        for (const name of list) {
+        const list = fs.readdirSync(dir, {
+            withFileTypes: true
+        });
+        for (const info of list) {
+            const { name } = info;
             const abs = path.resolve(dir, name);
-
-            const info = fs.lstatSync(abs);
             if (info.isSymbolicLink()) {
                 continue;
             }
@@ -879,20 +906,18 @@ const Util = {
     // time is debug level, fix the log info, for checking snapshot
     logTime: (message, time_start) => {
 
-        // memory gc
-        let memory = Util.getMemory();
-        if (Util.gcThreshold && Util.gcThreshold < memory) {
-            Util.forceGC();
+        const logEnabled = Util.loggingLevel >= Util.loggingLevels.debug || Boolean(process.env.MCR_LOG_TIME);
+        if (!logEnabled && !Util.gcThreshold) {
+            return;
         }
-
-        if (Util.loggingLevel < Util.loggingLevels.debug && !process.env.MCR_LOG_TIME) {
+        const memory = getMemoryAfterGC();
+        if (!logEnabled) {
             return;
         }
         const duration = Date.now() - time_start;
         const durationH = Util.TF(duration);
         const ls = [`[MCR] ${message}`];
 
-        memory = Util.getMemory();
         ls.push(` (memory: ${memory}MB)`);
 
         // time
@@ -911,4 +936,4 @@ const Util = {
 
 };
 
-module.exports = Util;
+export { Util };

package/lib/v8/v8-summary.js

@@ -1,4 +1,4 @@
-const Util = require('../utils/util.js');
+import { Util } from '../utils/util.js';
 
 // both css and js
 const getV8SummaryBytes = (item) => {
@@ -133,6 +133,4 @@ const getV8Summary = (v8list, watermarks) => {
     return summary;
 };
 
-module.exports = {
-    getV8Summary
-};
+export { getV8Summary };