monocart-coverage-reports 2.0.6 → 2.0.8

package/lib/converter/converter.js

@@ -1,3 +1,15 @@
+// https://github.com/demurgos/v8-coverage
+/**
+ * @ranges is always non-empty. The first range is called the "root range".
+ * @isBlockCoverage indicates if the function has block coverage information
+ *   @false means that there is a single range and its count is the number of times the function was called.
+ *   @true means that the ranges form a tree of blocks representing how many times each statement or expression inside was executed.
+ *        It detects skipped or repeated statements. The root range counts the number of function calls.
+ *
+ * @functionName can be an empty string. This is common for the FunctionCov representing the whole module.
+ */
+// if you have a line of code that says `var x= 10; console.log(x);` that's one line and 2 statements.
+
 const path = require('path');
 
 const Util = require('../utils/util.js');
@@ -7,6 +19,7 @@ const decodeMappings = require('../utils/decode-mappings.js');
 const { Locator } = require('monocart-formatter/node');
 const findOriginalRange = require('./find-original-range.js');
 const { getJsAstInfo, getCssAstInfo } = require('./ast.js');
+const { getIgnoredRanges } = require('./ignore.js');
 
 const { dedupeCountRanges } = require('../utils/dedupe.js');
 const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path.js');
@@ -14,6 +27,121 @@ const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path
 const InfoLine = require('./info-line.js');
 const InfoBranch = require('./info-branch.js');
 const InfoFunction = require('./info-function.js');
+const findInRanges = require('./find-in-ranges.js');
+
+// ========================================================================================================
+
+const handleIgnoredRanges = (list, ignoredRanges) => {
+    list.forEach((item) => {
+        if (item.count > 0) {
+            return;
+        }
+        const range = findInRanges(item.start, item.end, ignoredRanges);
+        if (range) {
+            // console.log(item, range);
+            item.ignored = true;
+        }
+    });
+};
+
+// ========================================================================================================
+
+const updateLinesCount = (bytes, locator, lineMap) => {
+    bytes.forEach((range) => {
+
+        const {
+            start, end, count, ignored
+        } = range;
+
+        const sLoc = locator.offsetToLocation(start);
+        const eLoc = locator.offsetToLocation(end);
+
+        // update lines coverage
+        const lines = Util.getRangeLines(sLoc, eLoc);
+
+        lines.forEach((it) => {
+            const line = lineMap.get(it.line);
+            if (!line) {
+                return;
+            }
+
+            // from outside into inside, uncovered is certain
+            // default is covered
+            if (it.entire) {
+                line.covered = count > 0;
+                line.count = count;
+
+                if (ignored) {
+                    if (!line.covered) {
+                        line.ignored = true;
+                    }
+                }
+
+            } else {
+
+                if (!ignored) {
+                    if (count > 0) {
+                        line.count = count;
+                    } else {
+                    // not covered if any count = 0
+                        line.covered = false;
+                    }
+                }
+
+            }
+
+            // if (!line.history) {
+            //     line.history = [];
+            // }
+            // line.history.push(`${it.entire}-${count}`);
+
+        });
+
+    });
+
+    // if (state.sourcePath.endsWith('component.js')) {
+    //     console.log('===========================================', state.sourcePath);
+    //     console.log(coverageInfo.lines);
+    // }
+
+};
+
+const handleLinesCoverage = (bytes, locator) => {
+
+    const lines = [];
+    // line 1 based
+    const lineMap = new Map();
+
+    // init lines
+    let blankCount = 0;
+    let commentCount = 0;
+
+    locator.lines.forEach((it) => {
+        // exclude blank and comment
+        if (it.blank) {
+            blankCount += 1;
+            return;
+        }
+        if (it.comment) {
+            commentCount += 1;
+            return;
+        }
+        // line 1-base
+        const line = it.line + 1;
+        // default count to 1, both js and css
+        const lineInfo = new InfoLine(line, it.length, 1);
+        lineMap.set(line, lineInfo);
+        lines.push(lineInfo);
+    });
+
+    updateLinesCount(bytes, locator, lineMap);
+
+    return {
+        lines,
+        blankCount,
+        commentCount
+    };
+};
 
 // ========================================================================================================
 
@@ -25,6 +153,10 @@ const calculateV8Functions = (functions) => {
     };
 
     functions.forEach((fn) => {
+        if (fn.ignored) {
+            return;
+        }
+
         v8Functions.total += 1;
         if (fn.count > 0) {
             v8Functions.covered += 1;
@@ -41,12 +173,13 @@ const calculateV8Branches = (branches) => {
     };
 
     branches.forEach((branch) => {
-        branch.locations.forEach((location) => {
-            v8Branches.total += 1;
-            if (location.count > 0) {
-                v8Branches.covered += 1;
-            }
-        });
+        if (branch.ignored) {
+            return;
+        }
+        v8Branches.total += 1;
+        if (branch.count > 0) {
+            v8Branches.covered += 1;
+        }
     });
 
     return v8Branches;
@@ -61,6 +194,10 @@ const calculateV8Lines = (lines, blankCount, commentCount) => {
     };
 
     lines.forEach((ln) => {
+        if (ln.ignored) {
+            // console.log(ln);
+            return;
+        }
         v8Lines.total += 1;
         // full line covered
         if (ln.covered) {
@@ -71,41 +208,19 @@ const calculateV8Lines = (lines, blankCount, commentCount) => {
     return v8Lines;
 };
 
-const createEmptyCoverageInfo = () => {
-
-    // data for v8 UI
-    const data = {
-        bytes: [],
-        functions: [],
-        branches: []
-    };
-
-    const branches = [];
-
-    const functions = [];
-
-    const lines = [];
-    // line 1 based
-    const lineMap = new Map();
-
-    const blankCount = 0;
-    const commentCount = 0;
-
+// ========================================================================================================
 
+const createEmptyCoverageInfo = () => {
     return {
-        // v8
-        data,
-
+        // v8 UI
+        data: {
+            bytes: [],
+            functions: [],
+            branches: []
+        },
         // istanbul
-        branches,
-
-        functions,
-
-        lines,
-        lineMap,
-        blankCount,
-        commentCount
-
+        functions: [],
+        branches: []
     };
 };
 
@@ -119,32 +234,41 @@ const createEmptyCoverageInfo = () => {
  * * `f` - hit count for functions
  * * `b` - hit count for branches
  */
-const collectFileCoverage = (item, coverageInfo, state) => {
+const collectFileCoverage = (item, state, coverageData, options) => {
 
     const { sourcePath } = item;
+    const { coverageInfo, locator } = state;
 
     const {
-        // v8
         data,
-
-        // istanbul
-        branches,
-
         functions,
-
-        lines,
-        blankCount,
-        commentCount
-
+        branches
     } = coverageInfo;
 
     // ==========================================
     // v8
     data.bytes = dedupeCountRanges(data.bytes);
+
+    const ignoredRanges = getIgnoredRanges(locator, options);
+    if (ignoredRanges) {
+
+        handleIgnoredRanges(data.bytes, ignoredRanges);
+        handleIgnoredRanges(data.functions, ignoredRanges);
+        handleIgnoredRanges(data.branches, ignoredRanges);
+
+        // console.log(ignoredRanges);
+
+    }
+
+    // after bytes with ignored, before calculateV8Lines
+    const {
+        lines, blankCount, commentCount
+    } = handleLinesCoverage(data.bytes, locator);
+
     item.data = data;
     item.summary = {
-        functions: calculateV8Functions(functions),
-        branches: calculateV8Branches(branches),
+        functions: calculateV8Functions(data.functions),
+        branches: calculateV8Branches(data.branches),
         lines: calculateV8Lines(lines, blankCount, commentCount)
     };
 
@@ -178,118 +302,40 @@ const collectFileCoverage = (item, coverageInfo, state) => {
     });
 
     // append to dist file state
-    state.coverageData[sourcePath] = istanbulCoverage;
+    coverageData[sourcePath] = istanbulCoverage;
 
 };
 
 // ========================================================================================================
 
-// https://github.com/demurgos/v8-coverage
-/**
- * @ranges is always non-empty. The first range is called the "root range".
- * @isBlockCoverage indicates if the function has block coverage information
- *   @false means that there is a single range and its count is the number of times the function was called.
- *   @true means that the ranges form a tree of blocks representing how many times each statement or expression inside was executed.
- *        It detects skipped or repeated statements. The root range counts the number of function calls.
- *
- * @functionName can be an empty string. This is common for the FunctionCov representing the whole module.
- */
-// if you have a line of code that says `var x= 10; console.log(x);` that's one line and 2 statements.
-
-const addJsLineCoverage = (state, range) => {
-
-    const { locator, coverageInfo } = state;
-
-    const { data, lineMap } = coverageInfo;
-
+const addJsBytesCoverage = (state, range) => {
+    const { coverageInfo } = state;
+    const { data } = coverageInfo;
     const {
         startOffset, endOffset, count
     } = range;
-
     // add bytes range
     data.bytes.push({
-        // index,
         start: startOffset,
         end: endOffset,
         count
     });
-
-    const sLoc = locator.offsetToLocation(startOffset);
-    const eLoc = locator.offsetToLocation(endOffset);
-
-    // update lines coverage
-    const lines = Util.getRangeLines(sLoc, eLoc);
-
-    lines.forEach((it) => {
-        const line = lineMap.get(it.line);
-        if (!line) {
-            return;
-        }
-
-        // from outside into inside, uncovered is certain
-        // default is covered
-        if (it.entire) {
-            line.covered = count > 0;
-            line.count = count;
-        } else {
-            if (count > 0) {
-                line.count = count;
-            } else {
-                // not covered if any count = 0
-                line.covered = false;
-            }
-        }
-
-        // if (!line.history) {
-        //     line.history = [];
-        // }
-        // line.history.push(`${it.entire}-${count}`);
-
-    });
-
-    // if (state.sourcePath.endsWith('component.js')) {
-    //     console.log('===========================================', state.sourcePath);
-    //     console.log(coverageInfo.lines);
-    // }
-
 };
 
-const addCssLineCoverage = (state, range) => {
-
-    const { coverageInfo, locator } = state;
-
-    const { lineMap, data } = coverageInfo;
-
+const addCssBytesCoverage = (state, range) => {
+    const { coverageInfo } = state;
+    const { data } = coverageInfo;
     const {
         start, end, count
     } = range;
-
-    if (count > 0) {
-        const sLoc = locator.offsetToLocation(start);
-        const eLoc = locator.offsetToLocation(end);
-
-        // covered css lines
-        const lines = Util.getRangeLines(sLoc, eLoc);
-        lines.forEach((it) => {
-            if (!it.entire) {
-                return;
-            }
-            const line = lineMap.get(it.line);
-            if (line) {
-            // default is uncovered
-            // count always 1, covered is certain
-                line.covered = true;
-            }
-        });
-    }
-
-    // add bytes range
-    data.bytes.push(range);
-
+    // add css bytes range, already start, end
+    data.bytes.push({
+        start,
+        end,
+        count
+    });
 };
 
-// ========================================================================================================
-
 const updateOffsetToLocation = (locator, loc) => {
     const sLoc = locator.offsetToLocation(loc.start);
     loc.start = {
@@ -303,6 +349,8 @@ const updateOffsetToLocation = (locator, loc) => {
     };
 };
 
+// ========================================================================================================
+
 const handleFunctionsCoverage = (state) => {
 
     // functions only for js
@@ -401,90 +449,219 @@ const handleBranchesCoverage = (state) => {
         isTanbulBranches.push(branchInfo);
     });
 
-
-};
-
-const handleLinesCoverage = (state) => {
-
-    const {
-        js, locator, coverageInfo
-    } = state;
-
-    const lines = coverageInfo.lines;
-    const lineMap = coverageInfo.lineMap;
-
-    // init lines
-    let blankCount = 0;
-    let commentCount = 0;
-
-    // js: 1 (functions include all uncovered)
-    // css: 0 (ranges include all covered)
-    const baseLineCount = js ? 1 : 0;
-
-    locator.lines.forEach((it) => {
-        // exclude blank and comment
-        if (it.blank) {
-            blankCount += 1;
-            return;
-        }
-        if (it.comment) {
-            commentCount += 1;
-            return;
-        }
-        // line 1-base
-        const line = it.line + 1;
-        const lineInfo = new InfoLine(line, it.length, baseLineCount);
-        lineMap.set(line, lineInfo);
-        lines.push(lineInfo);
-    });
-
-    coverageInfo.blankCount = blankCount;
-    coverageInfo.commentCount = commentCount;
 };
 
-const handleRangesCoverage = (state) => {
+const handleBytesCoverage = (state) => {
 
     const { js, coverageList } = state;
 
     if (js) {
         coverageList.forEach((block) => {
             block.ranges.forEach((range) => {
-                addJsLineCoverage(state, range);
+                addJsBytesCoverage(state, range);
             });
         });
-
     } else {
         coverageList.forEach((range) => {
-            addCssLineCoverage(state, range);
+            addCssBytesCoverage(state, range);
         });
     }
 
 };
 
-const generateCoverageForDist = (item, state) => {
-
-    // handle coverage
-    handleFunctionsCoverage(state);
-    handleBranchesCoverage(state);
-    handleLinesCoverage(state);
-    handleRangesCoverage(state);
-
-    collectFileCoverage(item, state.coverageInfo, state);
-
-};
-
 // ========================================================================================================
 
-const decodeSourceMappings = async (state, originalDecodedMap) => {
-
-    const generatedLocator = state.locator;
+const handleOriginalFunctionsCoverage = (state, originalMap) => {
 
-    const { sources, mappings } = state.sourceMap;
+    // functions only for js
+    if (!state.js) {
+        return;
+    }
 
-    const decodedList = await decodeMappings(mappings);
+    // console.log(state.astInfo.functions);
+
+    // function count
+    state.astInfo.functions.forEach((it) => {
+        const {
+            start, end, wrap
+        } = it;
+
+        // remove webpack wrap functions for functions count, not for ranges here
+        if (wrap) {
+            return;
+        }
+
+        // rename to startOffset and endOffset
+        const range = {
+            startOffset: start,
+            endOffset: end
+        };
+
+        const result = findOriginalRange(range, state, originalMap);
+        if (result.error) {
+            return;
+        }
+        const { originalRange, originalState } = result;
+
+        // add back to original ast
+        originalState.astInfo.functions.push({
+            ... it,
+            generatedStart: start,
+            generatedEnd: end,
+            start: originalRange.startOffset,
+            end: originalRange.endOffset
+        });
+
+        // if (originalState.sourcePath.endsWith('store.js')) {
+        //     console.log('==========================================================');
+        //     console.log(it, result.startMapping, result.endMapping);
+        // }
 
-    sources.forEach((source, i) => {
-        originalDecodedMap.set(i, []);
+    });
+
+};
+
+const handleOriginalBranchesCoverage = (state, originalMap) => {
+
+    // branches only for js
+    if (!state.js) {
+        return;
+    }
+
+    // console.log(state.astInfo.branches);
+
+    // function count
+    state.astInfo.branches.forEach((it) => {
+
+        const {
+            type, loc, locations
+        } = it;
+
+        // rename to startOffset and endOffset
+        const bRange = {
+            startOffset: loc.start,
+            endOffset: loc.end
+        };
+
+        // start
+        const result = findOriginalRange(bRange, state, originalMap);
+        if (result.error) {
+            // not in the original files
+            return;
+        }
+        const { originalRange, originalState } = result;
+
+        const newBranchLoc = {
+            start: originalRange.startOffset,
+            end: originalRange.endOffset
+        };
+
+        let hasError;
+        const newLocations = locations.map((oLoc) => {
+
+            const newLoc = {
+                ... oLoc
+            };
+
+            if (newLoc.none) {
+                return newLoc;
+            }
+
+            const { start, end } = newLoc;
+
+            const lRange = {
+                startOffset: start,
+                endOffset: end
+            };
+            const res = findOriginalRange(lRange, state, originalMap);
+            if (res.error) {
+                // It should not happen unless it is minify files, the SourceMap has some order problems
+
+                hasError = true;
+
+                // console.log('====================================', state.sourcePath, loc);
+                // console.log(res.errors);
+                // Util.logError(`Not found original branch. start: ${start}, end: ${end}`);
+
+                return newLoc;
+            }
+
+            const oRage = res.originalRange;
+            newLoc.start = oRage.startOffset;
+            newLoc.end = oRage.endOffset;
+
+            return newLoc;
+        });
+
+        if (hasError) {
+            return;
+        }
+
+        // add back to original ast
+        originalState.astInfo.branches.push({
+            type,
+            loc: newBranchLoc,
+            locations: newLocations
+        });
+
+    });
+
+};
+
+const handleOriginalBytesCoverage = (state, originalMap) => {
+
+    const { js, coverageList } = state;
+
+    // const time_start_mapping = Date.now();
+    if (js) {
+        // v8 coverage
+        coverageList.forEach((block) => {
+            block.ranges.forEach((range, index) => {
+
+                // remove wrap functions for original files
+                if (range.wrap) {
+                    // console.log(range);
+                    return;
+                }
+
+                const result = findOriginalRange(range, state, originalMap);
+                if (result.error) {
+                    return;
+                }
+
+                const { originalRange, originalState } = result;
+                addJsBytesCoverage(originalState, originalRange);
+
+                // if (originalRange.startOffset === 110 && originalRange.endOffset === 271) {
+                //     console.log('===============================', originalState.sourcePath);
+                //     console.log(result.startMapping, result.endMapping);
+                // }
+
+            });
+        });
+
+    } else {
+        // support css later
+        // current css no sourceMap, so never come in
+        // coverageList.forEach((range) => {
+
+        // });
+    }
+
+};
+
+// ========================================================================================================
+
+const decodeSourceMappings = async (state, originalDecodedMap) => {
+
+    const generatedLocator = state.locator;
+
+    const { sources, mappings } = state.sourceMap;
+
+    const decodedList = await decodeMappings(mappings);
+
+    sources.forEach((source, i) => {
+        originalDecodedMap.set(i, []);
     });
 
     const allDecodedMappings = [];
@@ -566,6 +743,8 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
     return decodedMappings;
 };
 
+// ========================================================================================================
+
 const initOriginalList = (state, originalDecodedMap, options) => {
 
     // source filter
@@ -628,7 +807,7 @@ const initOriginalList = (state, originalDecodedMap, options) => {
     return originalMap;
 };
 
-const collectOriginalList = (item, state, originalMap) => {
+const collectOriginalList = (item, state, originalMap, options) => {
 
     const { fileUrls, sourceMap } = state;
     const distFile = sourceMap.file || path.basename(item.sourcePath);
@@ -638,7 +817,7 @@ const collectOriginalList = (item, state, originalMap) => {
     originalMap.forEach((originalState) => {
 
         const {
-            js, type, sourcePath, source, coverageInfo
+            js, type, sourcePath, source
         } = originalState;
 
         // add file item
@@ -656,7 +835,7 @@ const collectOriginalList = (item, state, originalMap) => {
         };
 
         // generate coverage, coverageInfo for current file, state for dist file
-        collectFileCoverage(sourceItem, coverageInfo, state);
+        collectFileCoverage(sourceItem, originalState, state.coverageData, options);
 
         sourceList.push(sourceItem);
     });
@@ -664,184 +843,15 @@ const collectOriginalList = (item, state, originalMap) => {
     return sourceList;
 };
 
-// =======================================================================================
-
-const handleOriginalFunctionsCoverage = (state, originalMap) => {
-
-    // functions only for js
-    if (!state.js) {
-        return;
-    }
-
-    // console.log(state.astInfo.functions);
-
-    // function count
-    state.astInfo.functions.forEach((it) => {
-        const {
-            start, end, wrap
-        } = it;
-
-        // remove webpack wrap functions for functions count, not for ranges here
-        if (wrap) {
-            return;
-        }
-
-        // rename to startOffset and endOffset
-        const range = {
-            startOffset: start,
-            endOffset: end
-        };
-
-        const result = findOriginalRange(range, state, originalMap);
-        if (result.error) {
-            return;
-        }
-        const { originalRange, originalState } = result;
-
-        // add back to original ast
-        originalState.astInfo.functions.push({
-            ... it,
-            generatedStart: start,
-            generatedEnd: end,
-            start: originalRange.startOffset,
-            end: originalRange.endOffset
-        });
-
-        // if (originalState.sourcePath.endsWith('store.js')) {
-        //     console.log('==========================================================');
-        //     console.log(it, result.startMapping, result.endMapping);
-        // }
-
-    });
-
-};
-
-const handleOriginalBranchesCoverage = (state, originalMap) => {
-
-    // branches only for js
-    if (!state.js) {
-        return;
-    }
-
-    // console.log(state.astInfo.branches);
-
-    // function count
-    state.astInfo.branches.forEach((it) => {
-
-        const {
-            type, loc, locations
-        } = it;
-
-        // rename to startOffset and endOffset
-        const bRange = {
-            startOffset: loc.start,
-            endOffset: loc.end
-        };
-
-        // start
-        const result = findOriginalRange(bRange, state, originalMap);
-        if (result.error) {
-            // not in the original files
-            return;
-        }
-        const { originalRange, originalState } = result;
-
-        const newBranchLoc = {
-            start: originalRange.startOffset,
-            end: originalRange.endOffset
-        };
-
-        let hasError;
-        const newLocations = locations.map((oLoc) => {
-
-            const newLoc = {
-                ... oLoc
-            };
-
-            if (newLoc.none) {
-                return newLoc;
-            }
-
-            const { start, end } = newLoc;
-
-            const lRange = {
-                startOffset: start,
-                endOffset: end
-            };
-            const res = findOriginalRange(lRange, state, originalMap);
-            if (res.error) {
-                // It should not happen unless it is minify files, the SourceMap has some order problems
-
-                hasError = true;
-
-                // console.log('====================================', state.sourcePath, loc);
-                // console.log(res.errors);
-                // Util.logError(`Not found original branch. start: ${start}, end: ${end}`);
-
-                return newLoc;
-            }
-
-            const oRage = res.originalRange;
-            newLoc.start = oRage.startOffset;
-            newLoc.end = oRage.endOffset;
-
-            return newLoc;
-        });
-
-        if (hasError) {
-            return;
-        }
-
-        // add back to original ast
-        originalState.astInfo.branches.push({
-            type,
-            loc: newBranchLoc,
-            locations: newLocations
-        });
-
-    });
-
-};
-
-const handleOriginalRangesCoverage = (state, originalMap) => {
-
-    const { js, coverageList } = state;
-
-    // const time_start_mapping = Date.now();
-    if (js) {
-        // v8 coverage
-        coverageList.forEach((block) => {
-            block.ranges.forEach((range, index) => {
-
-                // remove wrap functions for original files
-                if (range.wrap) {
-                    // console.log(range);
-                    return;
-                }
-
-                const result = findOriginalRange(range, state, originalMap);
-                if (result.error) {
-                    return;
-                }
-
-                const { originalRange, originalState } = result;
-                addJsLineCoverage(originalState, originalRange);
-
-                // if (originalRange.startOffset === 110 && originalRange.endOffset === 271) {
-                //     console.log('===============================', originalState.sourcePath);
-                //     console.log(result.startMapping, result.endMapping);
-                // }
+// ========================================================================================================
 
-            });
-        });
+const generateCoverageForDist = (item, state, options) => {
 
-    } else {
-        // support css later
-        // current css no sourceMap, so never come in
-        // coverageList.forEach((range) => {
+    handleFunctionsCoverage(state);
+    handleBranchesCoverage(state);
+    handleBytesCoverage(state);
 
-        // });
-    }
+    collectFileCoverage(item, state, state.coverageData, options);
 
 };
 
@@ -878,14 +888,9 @@ const unpackSourceMap = async (item, state, options) => {
 
     // handle lines info before handle ranges to update line count
     originalMap.forEach((originalState) => {
+
         handleFunctionsCoverage(originalState);
         handleBranchesCoverage(originalState);
-        handleLinesCoverage(originalState);
-
-        // console.log(originalState.sourcePath, '================================');
-        // console.log(originalState.astInfo.functions);
-        // console.log(originalState.source.length);
-        // console.log(originalState.coverageInfo.functions);
 
         // if (originalState.sourcePath.endsWith('demo.js')) {
         //     console.log('=================================', originalState.sourcePath);
@@ -895,21 +900,20 @@ const unpackSourceMap = async (item, state, options) => {
     });
 
     // handle ranges after lines ready
-    handleOriginalRangesCoverage(state, originalMap);
+    handleOriginalBytesCoverage(state, originalMap);
 
     // collect coverage for original list
-    state.sourceList = collectOriginalList(item, state, originalMap);
+    state.sourceList = collectOriginalList(item, state, originalMap, options);
 
 };
 
-// ========================================================================================================
-
 const unpackDistFile = async (item, state, options) => {
 
     if (state.sourceMap) {
         if (Util.loggingType === 'debug') {
             // js self
-            generateCoverageForDist(item, state);
+            item.debug = true;
+            generateCoverageForDist(item, state, options);
         } else {
             item.dedupe = true;
         }
@@ -920,7 +924,7 @@ const unpackDistFile = async (item, state, options) => {
     } else {
 
         // css/js self
-        generateCoverageForDist(item, state);
+        generateCoverageForDist(item, state, options);
 
     }