monocart-coverage-reports 2.12.0 → 2.12.2

package/README.md

@@ -724,6 +724,18 @@ if (platform === 'linux') {
     console.log('hello linux');
 }
 ```
+- Compatible with [c8 coverage](https://github.com/bcoe/c8/?tab=readme-ov-file#ignoring-all-lines-until-told) or [nodejs coverage](https://nodejs.org/docs/latest/api/test.html#collecting-code-coverage) syntax
+```js
+/* c8 ignore start */
+function uncovered() {
+}
+/* c8 ignore stop */
+
+/* node:coverage disable */
+function uncovered() {
+}
+/* node:coverage enable */
+```
 
 ## Multiprocessing Support
 > The data will be added to `[outputDir]/.cache`, After the generation of the report, this data will be removed unless debugging has been enabled or a raw report has been used, see [Debug for Coverage and Sourcemap](#debug-for-coverage-and-sourcemap)

package/README.zh-Hans.md

@@ -727,6 +727,18 @@ if (platform === 'linux') {
     console.log('hello linux');
 }
 ```
+- 兼容支持 [c8 coverage](https://github.com/bcoe/c8/?tab=readme-ov-file#ignoring-all-lines-until-told) 或 [nodejs coverage](https://nodejs.org/docs/latest/api/test.html#collecting-code-coverage) 的语法格式
+```js
+/* c8 ignore start */
+function uncovered() {
+}
+/* c8 ignore stop */
+
+/* node:coverage disable */
+function uncovered() {
+}
+/* node:coverage enable */
+```
 
 ## Multiprocessing Support
 > 多进程支持可以很好的解决异步并行的情况。所有的覆盖率数据会保存到`[outputDir]/.cache`，在报告生成之后，这些缓存数据会被清除。除非开启了[调试模式](#debug-for-coverage-and-sourcemap)，或者使用了`raw`报告

package/lib/converter/ast.js

@@ -281,6 +281,10 @@ const addAtRule = (item, coverageList, coveredRanges, empty) => {
 
 const addCssRules = (list, coverageList, coveredRanges, empty) => {
 
+    if (!Util.isList(list)) {
+        return 0;
+    }
+
     let count = 0;
 
     // line and line is 1-base

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;