monocart-coverage-reports 2.12.1 → 2.12.3

package/lib/cli.js

@@ -93,10 +93,10 @@ const initNodeOptions = async (cliOptions) => {
     // export source after
     if (preloadType === '--import') {
         const importPath = getRegisterPath('register.mjs');
-        nodeOptions.push(`--import ${importPath}`);
+        nodeOptions.unshift(`--import ${importPath}`);
     } else {
         const requirePath = getRegisterPath('register.js');
-        nodeOptions.push(`--require ${requirePath}`);
+        nodeOptions.unshift(`--require ${requirePath}`);
     }
 
     // console.log(nodeOptions);

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) {
@@ -1078,6 +1136,56 @@ const generateCoverageForDist = (state) => {
 
 };
 
+const handleUncoveredInCovered = (state, originalStateMap) => {
+    if (!state.fake) {
+        return;
+    }
+
+    // fake statements/branches/functions
+    originalStateMap.forEach((originalState) => {
+        const { bytes } = originalState;
+        const list = [];
+        originalState.bytes = bytes.filter((item) => {
+            if (item.count === 0) {
+                const range = bytes.find((it) => {
+                    if (it.count === 0) {
+                        return false;
+                    }
+                    if (it.start > item.end) {
+                        return false;
+                    }
+                    if (it.end < item.start) {
+                        return false;
+                    }
+                    return true;
+                });
+                if (range) {
+                    list.push(item);
+                    return false;
+                }
+            }
+            return true;
+        });
+
+        if (!list.length) {
+            return;
+        }
+
+        list.forEach((item) => {
+            ['statements', 'branches', 'functions'].forEach((key) => {
+                originalState[key] = originalState[key].filter((it) => {
+                    if (it.start === item.start && it.end === item.end) {
+                        return false;
+                    }
+                    return true;
+                });
+            });
+        });
+
+    });
+
+};
+
 const unpackSourceMap = (state, options) => {
 
     const { sourceMap, sourcePath } = state;
@@ -1128,6 +1236,9 @@ const unpackSourceMap = (state, options) => {
         handleOriginalBytesCoverage(originalState);
     });
 
+    // remove uncovered in covered for fake
+    handleUncoveredInCovered(state, originalStateMap);
+
     // collect coverage for original list
     collectOriginalList(state, originalStateMap);
 
@@ -1173,16 +1284,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 +1297,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;