monocart-coverage-reports 2.10.0 → 2.10.1

package/README.md

@@ -116,8 +116,10 @@ For more information, see [Command Line](#command-line)
 ![](./assets/v8.gif)
 
 - `v8-json`
-    - Save `CoverageResults` to a json file
-    - Preview [coverage-report.json](https://cenfun.github.io/monocart-coverage-reports/v8-and-istanbul/coverage-report.json)
+    - Save `CoverageResults` to a json file (defaults to [`coverage-report.json`](https://cenfun.github.io/monocart-coverage-reports/v8-and-istanbul/coverage-report.json)).
+    - Shows native V8 code coverage with VSCode extension [monocart-coverage-vscode](https://github.com/cenfun/monocart-coverage-vscode)
+
+![](./assets/mcv.gif)
 
 > Istanbul build-in reports (both V8 and Istanbul data):
 

package/lib/converter/converter.js

@@ -66,8 +66,8 @@ const applyBytesToLines = (bytes, locator, lineMap) => {
             start, end, count, ignored
         } = range;
 
-        // no need handle ignored and uncovered byte
-        if (count === 0 && ignored) {
+        // no need handle ignored byte
+        if (ignored) {
             return;
         }
 
@@ -141,9 +141,8 @@ const handleLinesCoverage = (bytes, locator, ignoredRanges) => {
             return;
         }
 
-        lineItem.coveredCount = 1;
-        lineItem.uncoveredEntire = null;
-        lineItem.uncoveredPieces = [];
+        Util.initLineCoverage(lineItem);
+
         lineMap.set(line, lineItem);
     });
 
@@ -507,6 +506,11 @@ const handleGeneratedBytesCoverage = (state) => {
     if (js) {
         coverageList.forEach((block) => {
             block.ranges.forEach((range) => {
+
+                const { fixedStart, fixedEnd } = Util.fixSourceRange(state.locator, range.startOffset, range.endOffset);
+                range.startOffset = fixedStart;
+                range.endOffset = fixedEnd;
+
                 addJsBytesCoverage(state, range);
             });
         });
@@ -555,7 +559,9 @@ const handleOriginalFunctionsCoverage = (state, originalStateMap) => {
             start, end, bodyStart, bodyEnd
         } = it;
 
-        const result = findOriginalRange(start, end, state, originalStateMap, true);
+        const result = findOriginalRange(start, end, state, originalStateMap, {
+            checkName: true
+        });
         if (result.error) {
             logMappingErrors('function', result);
             return;
@@ -796,6 +802,7 @@ const handleOriginalEmptyBytesCoverage = (state, originalStateMap) => {
     });
 };
 
+
 const handleAllOriginalBytesCoverage = (state, originalStateMap) => {
 
     const { js, coverageList } = state;
@@ -818,7 +825,9 @@ const handleAllOriginalBytesCoverage = (state, originalStateMap) => {
                 startOffset, endOffset, count
             } = range;
 
-            const result = findOriginalRange(startOffset, endOffset, state, originalStateMap);
+            const result = findOriginalRange(startOffset, endOffset, state, originalStateMap, {
+                fixOriginalRange: true
+            });
             if (result.error) {
                 logMappingErrors('byte', result);
                 return;

package/lib/converter/find-original-range.js

@@ -534,13 +534,13 @@ const getGeneratedText = (m1, m2, state, offset) => {
 };
 
 // ========================================================================================================
-const getFunctionName = (mp, state, checkName) => {
-    if (checkName && typeof mp.nameIndex !== 'undefined') {
+const getFunctionName = (mp, state, options) => {
+    if (options.checkName && typeof mp.nameIndex !== 'undefined') {
         return state.sourceMapNames[mp.nameIndex];
     }
 };
 
-const getFixedOriginalStart = (start, mappings, state, cache, checkName) => {
+const getFixedOriginalStart = (start, mappings, state, cache, options) => {
 
     const [m1, m2] = mappings;
     const { originalState, crossStart } = cache;
@@ -549,7 +549,7 @@ const getFixedOriginalStart = (start, mappings, state, cache, checkName) => {
     if (crossStart) {
         return {
             originalStart: m2.originalOffset,
-            originalName: getFunctionName(m2, state, checkName)
+            originalName: getFunctionName(m2, state, options)
         };
     }
 
@@ -581,7 +581,7 @@ const getFixedOriginalStart = (start, mappings, state, cache, checkName) => {
 
     return {
         originalStart: originalOffset + originalPos,
-        originalName: getFunctionName(m1, state, checkName)
+        originalName: getFunctionName(m1, state, options)
     };
 };
 
@@ -642,18 +642,18 @@ const getFixedOriginalEnd = (end, mappings, state, cache) => {
 
 // ========================================================================================================
 
-const getOriginalStartPosition = (cache, state, checkName) => {
+const getOriginalStartPosition = (cache, state, options) => {
 
     const { start, startMappings } = cache;
 
     if (Array.isArray(startMappings)) {
-        return getFixedOriginalStart(start, startMappings, state, cache, checkName);
+        return getFixedOriginalStart(start, startMappings, state, cache, options);
     }
 
     // Exact match
     return {
         originalStart: startMappings.originalOffset,
-        originalName: getFunctionName(startMappings, state, checkName)
+        originalName: getFunctionName(startMappings, state, options)
     };
 };
 
@@ -880,11 +880,12 @@ const getMappingInfo = (start, end, state) => {
     };
 };
 
-const findOriginalRange = (start, end, state, originalMap, checkName) => {
+
+const findOriginalRange = (start, end, state, originalMap, options = {}) => {
 
     const { sourcePath, rangeCache } = state;
 
-    const key = `${start}_${end}`;
+    const key = `${start}_${end}_${Boolean(options.fixOriginalRange)}`;
     if (rangeCache.has(key)) {
         return rangeCache.get(key);
     }
@@ -909,7 +910,7 @@ const findOriginalRange = (start, end, state, originalMap, checkName) => {
         return createMappingError(cache.errors);
     }
 
-    const originalStartResult = getOriginalStartPosition(cache, state, checkName);
+    const originalStartResult = getOriginalStartPosition(cache, state, options);
     const { originalStart, originalName } = originalStartResult;
     // could be used for end
     cache.originalStart = originalStart;
@@ -926,13 +927,13 @@ const findOriginalRange = (start, end, state, originalMap, checkName) => {
     }
 
     const { originalState } = cache;
+    const locator = originalState.locator;
 
-    const inComment = originalState.locator.lineParser.commentParser.isComment(originalStart, originalEnd);
+    const inComment = locator.lineParser.commentParser.isComment(originalStart, originalEnd);
     if (inComment) {
         return createMappingError(['the range in a original comment']);
     }
 
-
     const res = {
         start: originalStart,
         end: originalEnd,
@@ -940,6 +941,12 @@ const findOriginalRange = (start, end, state, originalMap, checkName) => {
         originalState
     };
 
+    if (options.fixOriginalRange) {
+        const { fixedStart, fixedEnd } = Util.fixSourceRange(locator, originalStart, originalEnd);
+        res.start = fixedStart;
+        res.end = fixedEnd;
+    }
+
     // cache response
     rangeCache.set(key, res);
 

package/lib/generate.js

@@ -32,6 +32,8 @@ const { markdownSummaryReport } = require('./reports/markdown-summary.js');
 
 const { rawReport } = require('./reports/raw.js');
 
+const { customReport } = require('./reports/custom.js');
+
 const allBuiltInReports = {
     // v8
     'v8': 'v8',
@@ -208,7 +210,7 @@ const generateCoverageReports = async (dataList, sourceCache, options) => {
             if (builtInHandler) {
                 await builtInHandler(coverageResults, reportOptions, options);
             } else {
-                await Util.runCustomReporter(reportName, coverageResults, reportOptions, options);
+                await customReport(reportName, coverageResults, reportOptions, options);
             }
             Util.logTime(`┌ [generate] saved report: ${reportName}`, t1);
         }