monocart-coverage-reports 2.0.6 → 2.0.8

package/lib/utils/dedupe.js

@@ -62,11 +62,6 @@ const dedupeRanges = (ranges) => {
 // apply to js count ranges
 const dedupeCountRanges = (ranges) => {
 
-    // v8 ranges format
-    // { startOffset: 0, endOffset: 6, count: 0 },
-    // { startOffset: 0, endOffset: 6, count: 1 },
-    // { startOffset: 0, endOffset: 297, count: 1 }
-
     // count ranges format
     // { start: 0, end: 6, count: 0 }
 

package/lib/v8/v8-summary.js

@@ -1,32 +1,7 @@
-// https://playwright.dev/docs/api/class-coverage
-
-// url, text, ranges: [ {start, end} ]
-const getCssSummaryBytes = (item) => {
-
-    const source = item.source;
-    const total = source.length;
-
-    let covered = 0;
-    const bytes = item.data.bytes;
-    if (bytes) {
-        bytes.forEach((range) => {
-            if (range.count > 0) {
-                covered += range.end - range.start;
-            }
-        });
-    }
-
-    // no functions for css
-    return {
-        total,
-        covered
-    };
-
-};
-
-// url, source, ranges:[{start,end, count}]
-const getJsSummaryBytes = (item) => {
+const Util = require('../utils/util.js');
 
+// both css and js
+const getV8SummaryBytes = (item) => {
     const source = item.source;
     const total = source.length;
 
@@ -36,6 +11,10 @@ const getJsSummaryBytes = (item) => {
 
     let endPos = 0;
     uncoveredBytes.forEach((range) => {
+        if (range.ignored) {
+            return;
+        }
+
         const { start, end } = range;
 
         if (start > endPos) {
@@ -63,13 +42,85 @@ const getJsSummaryBytes = (item) => {
     };
 };
 
-const getV8SummaryBytes = (item) => {
-    if (item.type === 'css') {
-        return getCssSummaryBytes(item);
-    }
-    return getJsSummaryBytes(item);
+// calculate uncovered, pct, status
+const calculatePctAndStatus = (item, watermarks) => {
+    Object.keys(item).forEach((k) => {
+        const indicateData = item[k];
+        indicateData.uncovered = indicateData.total - indicateData.covered;
+
+        let pct = '';
+        let status = 'unknown';
+
+        if (indicateData.total) {
+            pct = Util.PNF(indicateData.covered, indicateData.total, 2);
+            status = Util.getStatus(pct, watermarks[k]);
+        }
+
+        indicateData.pct = pct;
+        indicateData.status = status;
+
+    });
+};
+
+const getV8Summary = (v8list, watermarks) => {
+
+    // get bytes summary
+    v8list.forEach((entry) => {
+        entry.summary.bytes = getV8SummaryBytes(entry);
+    });
+
+    // overall summary
+    const summary = {
+        bytes: {
+            total: 0,
+            covered: 0
+        },
+        functions: {
+            total: 0,
+            covered: 0
+        },
+        branches: {
+            total: 0,
+            covered: 0
+        },
+        lines: {
+            total: 0,
+            covered: 0,
+            blank: 0,
+            comment: 0
+        }
+    };
+
+    v8list.forEach((entry) => {
+        const entrySummary = entry.summary;
+        calculatePctAndStatus(entrySummary, watermarks);
+
+        // do NOT add debug file
+        if (entry.debug) {
+            return;
+        }
+
+        Object.keys(entrySummary).forEach((k) => {
+            const indicateData = entrySummary[k];
+            if (!indicateData) {
+                return;
+            }
+            summary[k].total += indicateData.total;
+            summary[k].covered += indicateData.covered;
+
+            if (k === 'lines') {
+                summary[k].blank += indicateData.blank;
+                summary[k].comment += indicateData.comment;
+            }
+        });
+    });
+
+    // calculate overall summary
+    calculatePctAndStatus(summary, watermarks);
+
+    return summary;
 };
 
 module.exports = {
-    getV8SummaryBytes
+    getV8Summary
 };

package/lib/v8/v8.js

@@ -1,6 +1,6 @@
 const path = require('path');
 const Util = require('../utils/util.js');
-const { getV8SummaryBytes } = require('./v8-summary.js');
+const { getV8Summary } = require('./v8-summary.js');
 const { dedupeRanges } = require('../utils/dedupe.js');
 const { getSourcePath } = require('../utils/source-path.js');
 const { mergeScriptCovs } = require('../packages/monocart-coverage-vendor.js');
@@ -186,17 +186,9 @@ const saveV8JsonReport = async (reportData, options, v8JsonOptions) => {
 
 const saveV8HtmlReport = async (reportData, options, v8HtmlOptions) => {
 
-    // V8 only options, merged with root options
-    const v8MergedOptions = {
-        outputFile: options.outputFile,
-        inline: options.inline,
-        assetsPath: options.assetsPath,
-        ... v8HtmlOptions
-    };
-
     const {
         outputFile, inline, assetsPath
-    } = v8MergedOptions;
+    } = v8HtmlOptions;
 
     // resolve full report path
     const reportPath = path.resolve(options.outputDir, outputFile);
@@ -229,27 +221,8 @@ const saveV8HtmlReport = async (reportData, options, v8HtmlOptions) => {
     return htmlPath;
 };
 
-// calculate uncovered, pct, status
-const calculatePctAndStatus = (item, watermarks) => {
-    Object.keys(item).forEach((k) => {
-        const indicateData = item[k];
-        indicateData.uncovered = indicateData.total - indicateData.covered;
-
-        let pct = '';
-        let status = 'unknown';
-
-        if (indicateData.total) {
-            pct = Util.PNF(indicateData.covered, indicateData.total, 2);
-            status = Util.getStatus(pct, watermarks[k]);
-        }
-
-        indicateData.pct = pct;
-        indicateData.status = status;
-
-    });
-};
-
 const saveV8Report = async (v8list, options) => {
+
     const defaultWatermarks = {
         bytes: [50, 80],
         functions: [50, 80],
@@ -258,51 +231,7 @@ const saveV8Report = async (v8list, options) => {
     };
     const watermarks = Util.resolveWatermarks(defaultWatermarks, options.watermarks);
 
-    // init summary
-    v8list.forEach((entry) => {
-        entry.summary.bytes = getV8SummaryBytes(entry);
-    });
-
-    // overall summary
-    const summaryList = v8list.map((entry) => entry.summary);
-    const summary = {
-        bytes: {
-            total: 0,
-            covered: 0
-        },
-        functions: {
-            total: 0,
-            covered: 0
-        },
-        branches: {
-            total: 0,
-            covered: 0
-        },
-        lines: {
-            total: 0,
-            covered: 0,
-            blank: 0,
-            comment: 0
-        }
-    };
-    summaryList.forEach((item) => {
-        calculatePctAndStatus(item, watermarks);
-        Object.keys(item).forEach((k) => {
-            const indicateData = item[k];
-            if (!indicateData) {
-                return;
-            }
-            summary[k].total += indicateData.total;
-            summary[k].covered += indicateData.covered;
-
-            if (k === 'lines') {
-                summary[k].blank += indicateData.blank;
-                summary[k].comment += indicateData.comment;
-            }
-        });
-    });
-
-    calculatePctAndStatus(summary, watermarks);
+    const summary = getV8Summary(v8list, watermarks);
 
     const reportData = {
         name: options.name,
@@ -317,23 +246,38 @@ const saveV8Report = async (v8list, options) => {
     // 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);
+    }
+
     // v8 json
     const v8JsonOptions = v8Map['v8-json'];
     if (v8JsonOptions) {
         outputPath = await saveV8JsonReport(reportData, options, v8JsonOptions);
     }
 
-    // v8 html
-    const v8HtmlOptions = v8Map.v8;
-    if (v8HtmlOptions) {
-        outputPath = await saveV8HtmlReport(reportData, options, v8HtmlOptions);
-    }
-
     const reportPath = Util.resolveReportPath(options, () => {
         return outputPath;
     });
 
-    const report = {
+    const summaryList = v8list.map((entry) => entry.summary);
+
+    const coverageResults = {
         type: 'v8',
         reportPath,
         name: options.name,
@@ -342,7 +286,7 @@ const saveV8Report = async (v8list, options) => {
         files: summaryList
     };
 
-    return report;
+    return coverageResults;
 };
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-coverage-reports",
-    "version": "2.0.6",
+    "version": "2.0.8",
     "description": "Monocart coverage reports",
     "main": "lib/index.js",
     "exports": {