monocart-coverage-reports 2.2.1 → 2.3.0

package/lib/platform/share.js

@@ -109,6 +109,19 @@ const Util = {
         return false;
     },
 
+    toList: function(data, separator) {
+        if (data instanceof Array) {
+            return data;
+        }
+        if (typeof data === 'string' && (typeof separator === 'string' || separator instanceof RegExp)) {
+            return data.split(separator).map((str) => str.trim()).filter((str) => str);
+        }
+        if (typeof data === 'undefined' || data === null) {
+            return [];
+        }
+        return [data];
+    },
+
     forEach: function(rootList, callback) {
         const isBreak = (res) => {
             return res === 'break' || res === false;

package/lib/utils/dedupe.js

@@ -14,7 +14,7 @@ const filterRanges = (ranges) => {
 };
 
 // apply directly to css ranges
-const dedupeRanges = (ranges) => {
+const dedupeFlatRanges = (ranges) => {
 
     ranges = filterRanges(ranges);
 
@@ -59,11 +59,10 @@ const dedupeRanges = (ranges) => {
     return ranges;
 };
 
-// apply to js count ranges
-const dedupeCountRanges = (ranges) => {
+const mergeRangesWith = (ranges, comparer, handler) => {
 
-    // count ranges format
-    // { start: 0, end: 6, count: 0 }
+    // ranges format
+    // { start: 0, end: 6, ... }
 
     ranges = filterRanges(ranges);
 
@@ -77,9 +76,10 @@ const dedupeCountRanges = (ranges) => {
 
     // merge count for same range
     ranges.reduce((lastRange, range) => {
-        if (range.start === lastRange.start && range.end === lastRange.end) {
+        if (comparer(lastRange, range)) {
             range.dedupe = true;
-            lastRange.count += range.count;
+
+            handler(lastRange, range);
 
             hasDedupe = true;
 
@@ -98,8 +98,21 @@ const dedupeCountRanges = (ranges) => {
     return ranges;
 };
 
+// apply to js count ranges
+const dedupeCountRanges = (ranges) => {
+    const comparer = (lastRange, range) => {
+        return lastRange.start === range.start && lastRange.end === range.end;
+    };
+    const handler = (lastRange, range) => {
+        lastRange.count += range.count;
+    };
+    return mergeRangesWith(ranges, comparer, handler);
+};
+
 
 module.exports = {
-    dedupeRanges,
+    sortRanges,
+    dedupeFlatRanges,
+    mergeRangesWith,
     dedupeCountRanges
 };

package/lib/utils/source-path.js

@@ -39,6 +39,11 @@ const getSourcePath = (url, index = '', type = '') => {
         url = pathToFileURL(['anonymous', index ? `-${index}` : '', type ? `.${type}` : ''].join('')).toString();
     }
 
+    // url could be a absolute path
+    if (path.isAbsolute(url)) {
+        url = pathToFileURL(url).toString();
+    }
+
     if (url.startsWith('file:')) {
         const relPath = Util.relativePath(fileURLToPath(url));
         return filterPath(relPath);

package/lib/utils/util.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const { writeFile, readFile } = require('fs/promises');
 const path = require('path');
+const { pathToFileURL } = require('url');
 const os = require('os');
 const crypto = require('crypto');
 const EC = require('eight-colors');
@@ -48,7 +49,7 @@ const Util = {
         return str;
     },
 
-    calculateSha1(buffer) {
+    calculateSha1: (buffer) => {
         const hash = crypto.createHash('sha1');
         hash.update(buffer);
         return hash.digest('hex');
@@ -204,6 +205,34 @@ const Util = {
         return Util.relativePath(htmlPath);
     },
 
+    runCustomReporter: async (reportName, reportData, reportOptions, globalOptions) => {
+        let CustomReporter;
+        let err;
+        try {
+            CustomReporter = await import(reportName);
+        } catch (e) {
+            err = e;
+            try {
+                CustomReporter = await import(pathToFileURL(reportName));
+            } catch (ee) {
+                err = ee;
+            }
+        }
+
+        if (!CustomReporter) {
+            Util.logError(err.message);
+            return;
+        }
+
+        CustomReporter = CustomReporter.default || CustomReporter;
+
+        const reporter = new CustomReporter(reportOptions, globalOptions);
+
+        const results = await reporter.generate(reportData);
+
+        return results;
+    },
+
     getEOL: function(content) {
         if (!content) {
             return os.EOL;

package/lib/v8/v8.js

@@ -1,12 +1,26 @@
 const path = require('path');
 const Util = require('../utils/util.js');
 const { getV8Summary } = require('./v8-summary.js');
-const { dedupeRanges } = require('../utils/dedupe.js');
+const { dedupeFlatRanges } = require('../utils/dedupe.js');
 const { getSourcePath } = require('../utils/source-path.js');
 const { mergeScriptCovs } = require('../packages/monocart-coverage-vendor.js');
 const collectSourceMaps = require('../converter/collect-source-maps.js');
 const version = require('../../package.json').version;
 
+const getWrapperSource = (offset, source) => {
+    // NO \n because it break line number in mappings
+    let startStr = '';
+    if (offset >= 4) {
+        // fill comments
+        const spaces = ''.padEnd(offset - 4, '*');
+        startStr = `/*${spaces}*/`;
+    } else {
+        // fill spaces (should no chance)
+        startStr += ''.padEnd(offset, ' ');
+    }
+    return startStr + source;
+};
+
 const initV8ListAndSourcemap = async (v8list, options) => {
 
     // filter list first
@@ -18,12 +32,20 @@ const initV8ListAndSourcemap = async (v8list, options) => {
     // filter no source or text
     // init type and css source from text
     // keep functions
-
     v8list = v8list.filter((item) => {
         if (typeof item.source === 'string' && item.functions) {
+            item.type = 'js';
             return true;
         }
         if (typeof item.text === 'string' && item.ranges) {
+            item.type = 'css';
+            return true;
+        }
+        // allow empty coverage
+        if (item.empty) {
+            if (!['js', 'css'].includes(item.type)) {
+                item.type = 'js';
+            }
             return true;
         }
         // 404 css, text will be empty
@@ -39,30 +61,38 @@ const initV8ListAndSourcemap = async (v8list, options) => {
     // init id, sourcePath
     v8list = v8list.map((item, i) => {
 
+        let source = item.source || item.text;
+
+        // fix source with script offset
+        let scriptOffset;
+        const offset = Util.toNum(item.scriptOffset, true);
+        if (offset > 0) {
+            scriptOffset = offset;
+            source = getWrapperSource(offset, source);
+        }
+
         const data = {
-            url: item.url
+            url: item.url,
+            type: item.type,
+            source,
+            // script offset >= 0, for vm script
+            scriptOffset,
+            // Manually Resolve the Sourcemap
+            sourceMap: item.sourceMap,
+            // empty coverage
+            empty: item.empty,
+            // match source if using empty coverage
+            distFile: item.distFile
         };
 
-        if (item.functions) {
-            data.type = 'js';
+        // coverage
+        if (data.type === 'js') {
             data.functions = item.functions;
-            data.source = item.source;
-            // could be existed
-            data.sourceMap = item.sourceMap;
-        } else if (item.ranges) {
-            data.type = 'css';
+        } else {
             data.ranges = item.ranges;
-            data.source = item.text;
-        }
-
-        const idList = [];
-        // could be existed
-        const distFile = item.distFile;
-        if (distFile) {
-            data.distFile = distFile;
-            idList.push(distFile);
         }
 
+        // resolve source path
         let sourcePath = getSourcePath(data.url, i + 1, data.type);
         if (typeof sourcePathHandler === 'function') {
             const newSourcePath = sourcePathHandler(sourcePath, data.url);
@@ -70,13 +100,10 @@ const initV8ListAndSourcemap = async (v8list, options) => {
                 sourcePath = newSourcePath;
             }
         }
-
         data.sourcePath = sourcePath;
 
-        idList.push(sourcePath);
-        idList.push(data.source);
-
-        data.id = Util.calculateSha1(idList.join(''));
+        // calculate source id
+        data.id = Util.calculateSha1(sourcePath + data.source);
 
         return data;
     });
@@ -86,7 +113,7 @@ const initV8ListAndSourcemap = async (v8list, options) => {
     const count = await collectSourceMaps(v8list, options);
     if (count) {
         // debug level time
-        Util.logTime(`loaded ${count} sourcemaps`, time_start);
+        Util.logTime(`loaded sourcemaps: ${count}`, time_start);
     }
 
     return v8list;
@@ -104,7 +131,7 @@ const mergeCssRanges = (itemList) => {
         });
 
         // ranges: [ {start, end} ]
-        const ranges = dedupeRanges(concatRanges);
+        const ranges = dedupeFlatRanges(concatRanges);
 
         resolve(ranges || []);
     });
@@ -120,19 +147,20 @@ const mergeJsFunctions = (itemList) => {
     });
 };
 
-const mergeV8Coverage = async (dataList, options) => {
+const mergeV8Coverage = async (dataList, sourceCache, options) => {
 
-    let list = [];
+    let allList = [];
     dataList.forEach((d) => {
-        list = list.concat(d.data);
+        allList = allList.concat(d.data);
     });
 
-    // console.log('before merge', list.map((it) => it.url));
+    // remove empty items
+    const coverageList = allList.filter((it) => !it.empty);
 
     // connect all functions and ranges
     const itemMap = {};
     const mergeMap = {};
-    list.forEach((item) => {
+    coverageList.forEach((item) => {
         const { id } = item;
         const prev = itemMap[id];
         if (prev) {
@@ -158,44 +186,99 @@ const mergeV8Coverage = async (dataList, options) => {
         }
     }
 
-    list = Object.values(itemMap);
+    // first time filter for empty, (not for sources)
+    // empty and not in item map
+    const emptyList = allList.filter((it) => it.empty).filter((it) => !itemMap[it.id]);
+
+    // empty list + merged list
+    const mergedList = emptyList.concat(Object.values(itemMap));
 
     // try to load coverage and source by id
-    for (const item of list) {
-        const { id } = item;
-        const sourcePath = Util.resolveCacheSourcePath(options.cacheDir, id);
-        const content = await Util.readFile(sourcePath);
-        if (content) {
-            const json = JSON.parse(content);
+    for (const item of mergedList) {
+        const {
+            id, type, empty
+        } = item;
+        const json = sourceCache.get(id);
+        if (json) {
             item.source = json.source;
             item.sourceMap = json.sourceMap;
         } else {
-            Util.logError(`failed to read source: ${item.url}`);
+            Util.logError(`Not found source data: ${Util.relativePath(item.sourcePath)}`);
             item.source = '';
         }
+
+        // add empty coverage after merged
+        if (empty) {
+            if (type === 'js') {
+                item.functions = [{
+                    functionName: '',
+                    ranges: [{
+                        startOffset: 0,
+                        endOffset: item.source.length,
+                        count: 0
+                    }]
+                }];
+            } else {
+                // empty css
+                item.ranges = [];
+            }
+        }
+
     }
 
-    return list;
+    return mergedList;
 };
 
 // ============================================================
 
-const saveV8JsonReport = async (reportData, options, v8JsonOptions) => {
-    const v8MergedOptions = {
+const saveCodecovReport = async (reportData, reportOptions, options) => {
+    const codecovOptions = {
+        outputFile: 'codecov.json',
+        ... reportOptions
+    };
+
+    const jsonPath = path.resolve(options.outputDir, codecovOptions.outputFile);
+
+    // https://docs.codecov.com/docs/codecov-custom-coverage-format
+    const coverage = {};
+    reportData.files.forEach((item) => {
+        const { sourcePath, data } = item;
+        coverage[sourcePath] = data.lines;
+    });
+    const codecovData = {
+        coverage
+    };
+
+    await Util.writeFile(jsonPath, JSON.stringify(codecovData));
+    return Util.relativePath(jsonPath);
+};
+
+const saveV8JsonReport = async (reportData, reportOptions, options) => {
+    const v8JsonOptions = {
         outputFile: 'coverage-report.json',
-        ... v8JsonOptions
+        ... reportOptions
     };
 
-    // console.log(v8MergedOptions);
-    const jsonPath = path.resolve(options.outputDir, v8MergedOptions.outputFile);
-    // console.log(reportPath);
+    // console.log(mergedOptions);
+    const jsonPath = path.resolve(options.outputDir, v8JsonOptions.outputFile);
     await Util.writeFile(jsonPath, JSON.stringify(reportData));
-
     return Util.relativePath(jsonPath);
 };
 
 
-const saveV8HtmlReport = async (reportData, options, v8HtmlOptions) => {
+const saveV8HtmlReport = async (reportData, reportOptions, options) => {
+
+    // V8 only options, merged with root options
+    const v8HtmlOptions = {
+        outputFile: options.outputFile,
+        inline: options.inline,
+        assetsPath: options.assetsPath,
+        metrics: options.metrics,
+        ... reportOptions
+    };
+
+    // add metrics to data for UI
+    reportData.metrics = v8HtmlOptions.metrics;
 
     const {
         outputFile, inline, assetsPath
@@ -252,38 +335,29 @@ const saveV8Report = async (v8list, options) => {
         files: v8list
     };
 
-    let outputPath;
-
     // v8 reports
-    const v8Map = options.reportGroup.v8;
-
-    // v8 html
-    const v8Options = v8Map.v8;
-    if (v8Options) {
-
-        // V8 only options, merged with root options
-        const v8HtmlOptions = {
-            outputFile: options.outputFile,
-            inline: options.inline,
-            assetsPath: options.assetsPath,
-            metrics: options.metrics,
-            ... v8Options
-        };
-
-        // add metrics to data
-        reportData.metrics = v8HtmlOptions.metrics;
-
-        outputPath = await saveV8HtmlReport(reportData, options, v8HtmlOptions);
-    }
+    const buildInV8Reports = {
+        'v8': saveV8HtmlReport,
+        'v8-json': saveV8JsonReport,
+        'codecov': saveCodecovReport
+    };
 
-    // v8 json
-    const v8JsonOptions = v8Map['v8-json'];
-    if (v8JsonOptions) {
-        outputPath = await saveV8JsonReport(reportData, options, v8JsonOptions);
+    const outputs = {};
+    const v8Group = options.reportGroup.v8;
+    const v8Reports = Object.keys(v8Group);
+    for (const reportName of v8Reports) {
+        const reportOptions = v8Group[reportName];
+        const buildInHandler = buildInV8Reports[reportName];
+        if (buildInHandler) {
+            outputs[reportName] = await buildInHandler(reportData, reportOptions, options);
+        } else {
+            outputs[reportName] = await Util.runCustomReporter(reportName, reportData, reportOptions, options);
+        }
     }
 
+    // outputPath, should be html or json
     const reportPath = Util.resolveReportPath(options, () => {
-        return outputPath;
+        return outputs.v8 || outputs['v8-json'] || Object.values(outputs).filter((it) => it && typeof it === 'string').shift();
     });
 
     const coverageResults = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-coverage-reports",
-    "version": "2.2.1",
+    "version": "2.3.0",
     "description": "Monocart coverage reports",
     "main": "./lib/index.js",
     "bin": {
@@ -20,16 +20,18 @@
         "build-docs": "node ./scripts/build-docs.js",
         "build-test": "node ./scripts/build-test.js",
         "build": "sf lint && sf b -p && npm run build-test",
-        "test-node": "npm run test-node-env && npm run test-node-api && npm run test-node-ins && npm run test-node-cdp && npm run test-node-koa",
+        "test-node": "npm run test-node-env && npm run test-node-api && npm run test-node-ins && npm run test-node-cdp && npm run test-node-koa && npm run test-vm",
         "test-node-env": "cross-env NODE_V8_COVERAGE=.temp/v8-coverage-env node ./test/test-node-env.js && node ./test/generate-node-report.js",
         "test-node-api": "cross-env NODE_V8_COVERAGE=.temp/v8-coverage-api node ./test/test-node-api.js",
         "test-node-fgc": "node ./test/test-node-fgc.js",
         "test-node-ins": "node ./test/test-node-ins.js",
         "test-node-cdp": "node --inspect=9229 ./test/test-node-cdp.js",
         "test-node-koa": "node ./test/test-node-koa.js",
+        "test-vm": "node ./test/test-vm.js",
         "test-browser": "node ./test/test.js",
-        "test-cli": "npx mcr \"node ./test/test-node-env.js\" -o docs/cli -r v8,console-summary --lcov -c test/cli-options.js",
-        "test": "npm run test-browser && npm run test-node && npm run test-cli && npm run build-docs",
+        "test-cli": "npx mcr \"node ./test/test-node-env.js\" -o docs/cli -c test/cli-options.js",
+        "test-merge": "node ./test/test-merge.js",
+        "test": "npm run test-browser && npm run test-node && npm run test-cli && npm run test-merge && npm run build-docs",
         "dev": "sf d v8",
         "open": "node ./scripts/open.js",
         "patch": "npm run build && sf publish patch -r"

package/lib/utils/decode-mappings-worker.js

@@ -1,9 +0,0 @@
-const { parentPort } = require('worker_threads');
-const { decode } = require('../packages/monocart-coverage-vendor.js');
-
-parentPort.on('message', (message) => {
-    const result = decode(message);
-    parentPort.postMessage(result);
-});
-
-parentPort.postMessage('workerReady');

package/lib/utils/decode-mappings.js

@@ -1,35 +0,0 @@
-const path = require('path');
-const { Worker } = require('worker_threads');
-const Util = require('./util.js');
-
-// do NOT use isMainThread because it could be executed in worker too. (worker in worker)
-
-const decodeMappings = (mappings = '') => {
-    if (typeof text !== 'string') {
-        mappings = String(mappings);
-    }
-
-    return new Promise((resolve) => {
-
-        const workerPath = path.resolve(__dirname, 'decode-mappings-worker.js');
-        const worker = new Worker(workerPath);
-
-        worker.on('message', (message) => {
-            if (message === 'workerReady') {
-                worker.postMessage(mappings);
-                return;
-            }
-            resolve(message);
-            worker.terminate();
-        });
-
-        worker.on('error', (e) => {
-            Util.logError(e.message);
-            resolve([]);
-            worker.terminate();
-        });
-
-    });
-};
-
-module.exports = decodeMappings;