monocart-coverage-reports 2.12.11 → 2.13.0

package/lib/platform/share.js

@@ -220,18 +220,26 @@ const Util = {
             return;
         }
 
-        // rangeList should be sorted by startKey, but seems useless here
-        const list = rangeList.filter((it) => startPos >= it[startKey] && endPos <= it[endKey]);
-        if (!list.length) {
-            return;
+        // rangeList is sorted by startKey ascending.
+        // Binary search for the rightmost range where startKey <= startPos.
+        let low = 0;
+        let high = rangeList.length;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            if (rangeList[mid][startKey] > startPos) {
+                high = mid;
+            } else {
+                low = mid + 1;
+            }
         }
 
-        // could be multiple results, but seems no case for now
-        // if (list.length > 1) {
-        //     console.log('==============', list);
-        // }
-
-        return list[0];
+        // Scan backwards from the insertion point; the first match is the answer.
+        for (let i = low - 1; i >= 0; i--) {
+            const it = rangeList[i];
+            if (endPos <= it[endKey]) {
+                return it;
+            }
+        }
     },
 
     getRangeLines: (sLoc, eLoc) => {

package/lib/reports/console-details.js

@@ -62,40 +62,7 @@ const getDetailsRows = (files, metrics, cdOptions, color) => {
 };
 
 const getFileFilter = (input) => {
-    // for function handler
-    if (typeof input === 'function') {
-        return input;
-    }
-
-    // for single minimatch pattern
-    if (input && typeof input === 'string') {
-        // string to multiple patterns "{...}"
-        // mcr npx mocha --entryFilter {'**/node_modules/**':false,'**/src/*.js':true}
-        // mcr npx mocha --entryFilter "{'**/node_modules/**': false, '**/src/*.js': true}"
-        const obj = Util.strToObj(input);
-        if (obj) {
-            input = obj;
-        } else {
-            return (file) => {
-                return Util.betterMinimatch(file.sourcePath, input);
-            };
-        }
-    }
-
-    // for patterns
-    if (input && typeof input === 'object') {
-        const patterns = Object.keys(input);
-        return (file) => {
-            const sourcePath = file.sourcePath;
-            for (const pattern of patterns) {
-                if (Util.betterMinimatch(sourcePath, pattern)) {
-                    return input[pattern];
-                }
-            }
-            // false if not matched
-        };
-    }
-
+    return Util.createFilterHandler(input, (file) => file.sourcePath);
 };
 
 const getFilteredFiles = (filter, files) => {

package/lib/utils/gc.js

@@ -1,9 +1,18 @@
-const v8 = require('node:v8');
-const vm = require('node:vm');
+
+const isBun = typeof Bun !== 'undefined' && Boolean(process.versions.bun);
 
 if (typeof global.gc !== 'function') {
-    v8.setFlagsFromString('--expose_gc');
-    global.gc = vm.runInNewContext('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');
+    }
 }
 
 module.exports = global.gc;

package/lib/utils/merge/merge.js

@@ -46,19 +46,15 @@ function fromSortedRanges(ranges) {
         }
         let parent;
         let parentCount;
-        while (true) {
+        while (stack.length > 0) {
             [parent, parentCount] = stack[stack.length - 1];
-            // assert: `top !== undefined` (the ranges are sorted)
             if (range.startOffset < parent.end) {
                 break;
-            } else {
-                stack.pop();
-            }
-
-            // prevent crash when v8 incorrectly merges static_initializer's
-            if (stack.length === 0) {
-                break;
             }
+            stack.pop();
+            // parent / parentCount still hold the last popped values
+            // when v8 incorrectly merges static_initializer's, the stack
+            // may become empty; the while condition handles that.
         }
         node.delta -= parentCount;
         parent.children.push(node);

package/lib/utils/util.js

@@ -39,6 +39,15 @@ const Util = {
     markdownGrid,
     mergeV8Coverage,
 
+    ensureDirSync: function(filePath) {
+        const p = path.dirname(filePath);
+        if (!fs.existsSync(p)) {
+            fs.mkdirSync(p, {
+                recursive: true
+            });
+        }
+    },
+
     forceGC: () => {
         gc();
     },
@@ -97,9 +106,9 @@ const Util = {
         }
     },
 
-    calculateSha1: (buffer) => {
+    calculateSha1: (input) => {
         const hash = crypto.createHash('sha1');
-        hash.update(buffer);
+        hash.update(input);
         return hash.digest('hex');
     },
 
@@ -132,6 +141,10 @@ const Util = {
     },
 
     resolveWatermarks: (defaultWatermarks, watermarks) => {
+        // clone to avoid mutating the input
+        defaultWatermarks = {
+            ... defaultWatermarks
+        };
         if (watermarks) {
             if (Array.isArray(watermarks)) {
                 Object.keys(defaultWatermarks).forEach((k) => {
@@ -204,62 +217,54 @@ const Util = {
         return false;
     },
 
-    // eslint-disable-next-line complexity
-    getEntryFilter: (options) => {
-        // for entry.url
-
-        if (options.entryFilterHandler) {
-            return options.entryFilterHandler;
-        }
-
-        let input = options.entryFilter || options.filter;
-
+    createFilterHandler: function(input, fieldAccessor) {
         // for function handler
         if (typeof input === 'function') {
-            options.entryFilterHandler = input;
             return input;
         }
 
         // for single minimatch pattern
         if (input && typeof input === 'string') {
-            // string to multiple patterns "{...}"
-            // mcr npx mocha --entryFilter {'**/node_modules/**':false,'**/src/*.js':true}
-            // mcr npx mocha --entryFilter "{'**/node_modules/**': false, '**/src/*.js': true}"
             const obj = Util.strToObj(input);
             if (obj) {
                 input = obj;
             } else {
-                const handler = (entry) => {
-                    return Util.betterMinimatch(entry.url, input);
+                return (item) => {
+                    return Util.betterMinimatch(fieldAccessor(item), input);
                 };
-                options.entryFilterHandler = handler;
-                return handler;
             }
         }
 
         // for patterns
         if (input && typeof input === 'object') {
             const patterns = Object.keys(input);
-            const handler = (entry) => {
-                const url = entry.url;
+            return (item) => {
+                const value = fieldAccessor(item);
                 for (const pattern of patterns) {
-                    if (Util.betterMinimatch(url, pattern)) {
+                    if (Util.betterMinimatch(value, pattern)) {
                         return input[pattern];
                     }
                 }
-                // false if not matched
             };
-            options.entryFilterHandler = handler;
-            return handler;
         }
 
         // default
-        const handler = () => true;
+        return () => true;
+    },
+
+    getEntryFilter: (options) => {
+        // for entry.url
+
+        if (options.entryFilterHandler) {
+            return options.entryFilterHandler;
+        }
+
+        const input = options.entryFilter || options.filter;
+        const handler = Util.createFilterHandler(input, (entry) => entry.url);
         options.entryFilterHandler = handler;
         return handler;
     },
 
-    // eslint-disable-next-line complexity
     getSourceFilter: (options) => {
         // for sourcePath
 
@@ -267,48 +272,8 @@ const Util = {
             return options.sourceFilterHandler;
         }
 
-        let input = options.sourceFilter || options.filter;
-
-        // for function handler
-        if (typeof input === 'function') {
-            options.sourceFilterHandler = input;
-            return input;
-        }
-
-        // for single minimatch pattern
-        if (input && typeof input === 'string') {
-        // string to multiple patterns "{...}"
-        // mcr npx mocha --sourceFilter {'**/node_modules/**':false,'**/src/*.js':true}
-        // mcr npx mocha --sourceFilter "{'**/node_modules/**': false, '**/src/*.js': true}"
-            const obj = Util.strToObj(input);
-            if (obj) {
-                input = obj;
-            } else {
-                const handler = (sourcePath) => {
-                    return Util.betterMinimatch(sourcePath, input);
-                };
-                options.sourceFilterHandler = handler;
-                return handler;
-            }
-        }
-
-        // for patterns
-        if (input && typeof input === 'object') {
-            const patterns = Object.keys(input);
-            const handler = (sourcePath) => {
-                for (const pattern of patterns) {
-                    if (Util.betterMinimatch(sourcePath, pattern)) {
-                        return input[pattern];
-                    }
-                }
-            // false if not matched
-            };
-            options.sourceFilterHandler = handler;
-            return handler;
-        }
-
-        // default
-        const handler = () => true;
+        const input = options.sourceFilter || options.filter;
+        const handler = Util.createFilterHandler(input, (sourcePath) => sourcePath);
         options.sourceFilterHandler = handler;
         return handler;
     },
@@ -524,26 +489,12 @@ const Util = {
     },
 
     writeFileSync: function(filePath, content) {
-        if (!fs.existsSync(filePath)) {
-            const p = path.dirname(filePath);
-            if (!fs.existsSync(p)) {
-                fs.mkdirSync(p, {
-                    recursive: true
-                });
-            }
-        }
+        Util.ensureDirSync(filePath);
         fs.writeFileSync(filePath, content);
     },
 
     writeFile: async (filePath, content) => {
-        if (!fs.existsSync(filePath)) {
-            const p = path.dirname(filePath);
-            if (!fs.existsSync(p)) {
-                fs.mkdirSync(p, {
-                    recursive: true
-                });
-            }
-        }
+        Util.ensureDirSync(filePath);
         await writeFile(filePath, content).catch((e) => {
             Util.logError(`write file: ${filePath} ${e.message || e}`);
         });

package/lib/v8/v8.js

@@ -152,20 +152,19 @@ const initV8ListAndSourcemap = async (mcr, v8list) => {
 
 // ========================================================================================================
 
-// force to async
 const mergeCssRanges = (itemList) => {
-    return new Promise((resolve) => {
-
-        let concatRanges = [];
-        itemList.forEach((item) => {
-            concatRanges = concatRanges.concat(item.ranges);
-        });
+    // Concatenate all ranges using push to avoid O(n²) array copying
+    const concatRanges = [];
+    for (const item of itemList) {
+        for (const range of item.ranges) {
+            concatRanges.push(range);
+        }
+    }
 
-        // ranges: [ {start, end} ]
-        const ranges = dedupeFlatRanges(concatRanges);
+    // ranges: [ {start, end} ]
+    const ranges = dedupeFlatRanges(concatRanges);
 
-        resolve(ranges);
-    });
+    return ranges;
 };
 
 const mergeJsFunctions = async (itemList) => {
@@ -212,7 +211,7 @@ const mergeV8DataList = async (dataList, options) => {
         const itemList = mergeMap[id];
         const item = itemMap[id];
         if (item.type === 'css') {
-            item.ranges = await mergeCssRanges(itemList);
+            item.ranges = mergeCssRanges(itemList);
         } else {
             item.functions = await mergeJsFunctions(itemList);
         }