monocart-coverage-reports 2.12.1 → 2.12.2

package/lib/converter/converter.js

@@ -869,6 +869,12 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
 
     const allDecodedMappings = [];
     decodedList.forEach((segments, generatedLine) => {
+
+        if (!segments.length) {
+            return;
+        }
+
+        // line segments
         const lastIndex = segments.length - 1;
         segments.forEach((segment, i) => {
 
@@ -881,12 +887,17 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
             // the segment length could be 1, 4 or 5
 
             if (typeof sourceIndex === 'undefined') {
+                // console.log('============================ sourceIndex undefined');
+                // console.log(segment);
                 return;
             }
 
+            // 1-base
+            const generatedSN = generatedLine + 1;
+
             const generatedOffset = generatedLocator.locationToOffset({
                 // 1-base
-                line: generatedLine + 1,
+                line: generatedSN,
                 column: generatedColumn
             });
 
@@ -910,15 +921,49 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
             }
 
             allDecodedMappings.push(info);
-
             originalDecodedMap.get(sourceIndex).push(info);
 
+            // calculate line end column
+            if (!info.last) {
+                return;
+            }
+
+            const lineItem = generatedLocator.getLine(generatedSN);
+            if (!lineItem) {
+                // console.log('============================== not found line item');
+                return;
+            }
+
+            // console.log(generatedSN, generatedColumn, lineItem.length, lineItem.text);
+
+            if (generatedColumn >= lineItem.length) {
+                return;
+            }
+
+            const endColumn = {
+                generatedOffset: generatedOffset + (lineItem.length - generatedColumn),
+                generatedLine,
+                generatedColumn: lineItem.length,
+
+                end: true,
+
+                sourceIndex,
+                originalLine,
+                originalColumn,
+                nameIndex
+            };
+
+            // console.log(generatedSN, generatedColumn, info, endColumn);
+
+            allDecodedMappings.push(endColumn);
+            originalDecodedMap.get(sourceIndex).push(endColumn);
+
         });
 
 
     });
 
-    // defaults to sort by generated offset, not need sort
+    // defaults to sort by generated offset, no need sort
     // allDecodedMappings.sort((a, b) => {
     //     return a.generatedOffset - b.generatedOffset;
     // });
@@ -934,6 +979,19 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
         return [];
     }
 
+    // calculate line end column
+    decodedMappings.forEach((item) => {
+        if (!item.end) {
+            return;
+        }
+        const originalSN = item.originalLine + 1;
+        const lineItem = locator.getLine(originalSN);
+        // console.log(originalSN, item.originalColumn, lineItem.length, lineItem.text);
+        if (lineItem) {
+            item.originalColumn = lineItem.length;
+        }
+    });
+
     // sort by original line/column
     decodedMappings.sort((a, b) => {
         if (a.originalLine === b.originalLine) {
@@ -1173,16 +1231,10 @@ const filterCoverageList = (item) => {
     // the inline sourcemap could be removed
     const maxOffset = source.length;
 
-    const rootFunctionInfo = {
-        root: true,
-        ranges: [{
-            startOffset: minOffset,
-            endOffset: maxOffset,
-            count: 1
-        }]
-    };
+    const wrapperList = [];
 
     const coverageList = functions.filter((block) => {
+
         const { ranges } = block;
 
         // first one is function coverage info
@@ -1192,31 +1244,31 @@ const filterCoverageList = (item) => {
             return true;
         }
 
-        // blocks
-        const len = ranges.length;
-        if (len > 1) {
-            for (let i = 1; i < len; i++) {
-                const range = ranges[i];
-                if (range.startOffset >= minOffset && range.endOffset <= maxOffset) {
-                    rootFunctionInfo.ranges.push(range);
-                }
-            }
-        }
+        wrapperList.push(block);
 
         return false;
     });
 
-    // first one for root function
-    if (rootFunctionInfo.ranges.length > 1) {
-        coverageList.unshift(rootFunctionInfo);
+    if (wrapperList.length) {
+        const rootBlock = wrapperList.pop();
+        rootBlock.root = true;
+        coverageList.unshift(rootBlock);
     }
 
+    // if (item.sourcePath.includes('PlaceB.tsx')) {
+    //     console.log(coverageList);
+    // }
+
     return coverageList;
 };
 
 const initJsCoverageList = (item) => {
     const coverageList = filterCoverageList(item);
 
+    // if (item.sourcePath.includes('PlaceB.tsx')) {
+    //     console.log(coverageList[0]);
+    // }
+
     // function could be covered even it is defined after an uncovered return, see case closures.js
     // fix uncovered range if there are covered ranges in uncovered range
 

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

@@ -565,9 +565,9 @@ const getFixedOriginalStart = (start, mappings, state, cache, options) => {
         };
     }
 
-    // skip last mapping
+    // skip last and end column mapping
     let startNextLine = false;
-    if (m1.last) {
+    if (m1.end || m1.last) {
         const locStart = state.locator.offsetToLocation(start);
         // 1-base
         const lineIndex = locStart.line - 1;