monocart-coverage-reports 2.2.2 → 2.3.1

package/lib/converter/converter.js

@@ -1,27 +1,9 @@
-// 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.
+ * V8 Coverage Data Converter
+ * @copyright https://github.com/cenfun/monocart-coverage-reports
+ * @author cenfun@gmail.com
  */
-// https://github.com/bcoe/v8-coverage
-/**
-* @ranges is always non-empty. The first range is called the "root range".
-* @isBlockCoverage indicates if the function has block coverage information.
-    If this is false, it usually means that the functions was never called.
-    It seems to be equivalent to ranges.length === 1 && ranges[0].count === 0.
-* @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');
-const decodeMappings = require('../utils/decode-mappings.js');
 
 // position mapping for conversion between offset and line/column
 const { Locator } = require('monocart-formatter');
@@ -29,8 +11,11 @@ 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 {
+    sortRanges, dedupeCountRanges, mergeRangesWith
+} = require('../utils/dedupe.js');
 const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path.js');
+const { decode } = require('../packages/monocart-coverage-vendor.js');
 
 const InfoLine = require('./info-line.js');
 const InfoBranch = require('./info-branch.js');
@@ -226,13 +211,14 @@ const calculateV8Lines = (lines, blankCount, commentCount) => {
  * * `f` - hit count for functions
  * * `b` - hit count for branches
  */
-const collectFileCoverage = (item, state, coverageData, options) => {
+const collectFileCoverage = (v8Data, state, options) => {
 
-    const { sourcePath } = item;
     const {
         bytes,
         functions,
         branches,
+
+        sourcePath,
         locator
     } = state;
 
@@ -277,11 +263,13 @@ const collectFileCoverage = (item, state, coverageData, options) => {
     data.functions = functions.map((info) => {
         return info.getRange();
     });
+    sortRanges(data.functions);
 
     // branch group with locations to flat branches
     data.branches = branches.map((info) => {
         return info.getRanges();
     }).flat();
+    sortRanges(data.branches);
 
     // ==========================================
     // lines
@@ -292,8 +280,8 @@ const collectFileCoverage = (item, state, coverageData, options) => {
 
     // ==========================================
     // v8 data and summary
-    item.data = data;
-    item.summary = {
+    v8Data.data = data;
+    v8Data.summary = {
         functions: calculateV8Functions(data.functions),
         branches: calculateV8Branches(data.branches),
         lines: calculateV8Lines(lines, blankCount, commentCount)
@@ -301,7 +289,7 @@ const collectFileCoverage = (item, state, coverageData, options) => {
 
     // ==========================================
     // istanbul
-    const istanbulCoverage = {
+    const istanbulData = {
         path: sourcePath,
 
         statementMap: {},
@@ -317,8 +305,8 @@ const collectFileCoverage = (item, state, coverageData, options) => {
     data.lines = {};
 
     lines.filter((it) => !it.ignored).forEach((line, index) => {
-        istanbulCoverage.statementMap[`${index}`] = line.generate();
-        istanbulCoverage.s[`${index}`] = line.count;
+        istanbulData.statementMap[`${index}`] = line.generate();
+        istanbulData.s[`${index}`] = line.count;
 
         let count = 0;
         if (line.covered) {
@@ -331,18 +319,18 @@ const collectFileCoverage = (item, state, coverageData, options) => {
     });
 
     functions.filter((it) => !it.ignored).forEach((fn, index) => {
-        istanbulCoverage.fnMap[`${index}`] = fn.generate(locator);
-        istanbulCoverage.f[`${index}`] = fn.count;
+        istanbulData.fnMap[`${index}`] = fn.generate(locator);
+        istanbulData.f[`${index}`] = fn.count;
     });
 
     branches.filter((it) => !it.ignored).forEach((branch, index) => {
         const { map, counts } = branch.generate(locator);
-        istanbulCoverage.branchMap[`${index}`] = map;
-        istanbulCoverage.b[`${index}`] = counts;
+        istanbulData.branchMap[`${index}`] = map;
+        istanbulData.b[`${index}`] = counts;
     });
 
-    // append to dist file state
-    coverageData[sourcePath] = istanbulCoverage;
+    // istanbul data
+    return istanbulData;
 
 };
 
@@ -430,7 +418,7 @@ const handleBytesCoverage = (state) => {
 
 // ========================================================================================================
 
-const handleOriginalFunctionsCoverage = (state, originalMap) => {
+const handleOriginalFunctionsCoverage = (state, originalStateMap) => {
 
     // functions only for js
     if (!state.js) {
@@ -456,7 +444,7 @@ const handleOriginalFunctionsCoverage = (state, originalMap) => {
             endOffset: end
         };
 
-        const result = findOriginalRange(range, state, originalMap);
+        const result = findOriginalRange(range, state, originalStateMap);
         if (result.error) {
             return;
         }
@@ -480,7 +468,7 @@ const handleOriginalFunctionsCoverage = (state, originalMap) => {
 
 };
 
-const handleOriginalBranchesCoverage = (state, originalMap) => {
+const handleOriginalBranchesCoverage = (state, originalStateMap) => {
 
     // branches only for js
     if (!state.js) {
@@ -501,7 +489,7 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
         };
 
         // start
-        const result = findOriginalRange(bRange, state, originalMap);
+        const result = findOriginalRange(bRange, state, originalStateMap);
         if (result.error) {
             // not in the original files
             return;
@@ -530,7 +518,7 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
                 startOffset: start,
                 endOffset: end
             };
-            const res = findOriginalRange(lRange, state, originalMap);
+            const res = findOriginalRange(lRange, state, originalStateMap);
             if (res.error) {
                 // It should not happen unless it is minify files, the SourceMap has some order problems
 
@@ -568,7 +556,7 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
 
 };
 
-const handleOriginalBytesCoverage = (state, originalMap) => {
+const handleOriginalBytesCoverage = (state, originalStateMap) => {
 
     const { js, coverageList } = state;
 
@@ -584,7 +572,7 @@ const handleOriginalBytesCoverage = (state, originalMap) => {
                     return;
                 }
 
-                const result = findOriginalRange(range, state, originalMap);
+                const result = findOriginalRange(range, state, originalStateMap);
                 if (result.error) {
                     return;
                 }
@@ -608,17 +596,58 @@ const handleOriginalBytesCoverage = (state, originalMap) => {
         // });
     }
 
+    // check original bytes if fully in a wrapper range
+    originalStateMap.forEach((originalState) => {
+        const bytes = originalState.bytes;
+        if (Util.isList(bytes)) {
+            return;
+        }
+
+        const { decodedMappings } = originalState;
+        const len = decodedMappings.length;
+        if (len < 2) {
+            return;
+        }
+        // sort by original line/column
+        const startMapping = decodedMappings[0];
+        const endMapping = decodedMappings[len - 1];
+        // console.log(startMapping, endMapping);
+        const startOffset = startMapping.generatedOffset;
+        const endOffset = endMapping.generatedEndOffset || endMapping.generatedOffset;
+
+        // console.log('===========================================================', originalState.sourcePath);
+        // console.log(originalState.source.length, endMapping);
+
+        // only check uncovered range
+        // because a uncovered range could be in a covered wrapper
+        // { start: 0, end: 12137, count: 1 }, could be { start: > 0, end: < 12137, count: 0 }
+        for (const range of state.bytes) {
+            if (range.count > 0) {
+                continue;
+            }
+            if (startOffset >= range.start && endOffset <= range.end) {
+                bytes.push({
+                    start: 0,
+                    end: originalState.source.length,
+                    count: 0
+                });
+                break;
+            }
+        }
+
+    });
+
 };
 
 // ========================================================================================================
 
-const decodeSourceMappings = async (state, originalDecodedMap) => {
+const decodeSourceMappings = (state, originalDecodedMap) => {
 
     const generatedLocator = state.locator;
 
     const { sources, mappings } = state.sourceMap;
 
-    const decodedList = await decodeMappings(mappings);
+    const decodedList = decode(mappings);
 
     sources.forEach((source, i) => {
         originalDecodedMap.set(i, []);
@@ -679,7 +708,7 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
     // all mappings for the original file sorted
     const decodedMappings = originalDecodedMap.get(sourceIndex);
 
-    if (!decodeMappings) {
+    if (!decodedMappings) {
         return [];
     }
 
@@ -713,10 +742,8 @@ const initOriginalList = (state, originalDecodedMap, options) => {
         sourceFilter = () => true;
     }
 
-    const fileSources = state.fileSources;
-
     // create original content mappings
-    const originalMap = new Map();
+    const originalStateMap = new Map();
 
     const { sources, sourcesContent } = state.sourceMap;
 
@@ -734,9 +761,6 @@ const initOriginalList = (state, originalDecodedMap, options) => {
             return;
         }
 
-        // keep original formatted content
-        fileSources[sourcePath] = sourceContent;
-
         const locator = new Locator(sourceContent);
 
         const decodedMappings = getOriginalDecodedMappings(originalDecodedMap, sourceIndex, locator);
@@ -747,11 +771,11 @@ const initOriginalList = (state, originalDecodedMap, options) => {
 
         const originalState = {
             original: true,
-            // only js sourceMap for now
+            // original file is js
             js: true,
             type,
-            sourcePath,
             source: sourceContent,
+            sourcePath,
             locator,
             decodedMappings,
             // coverage info
@@ -761,24 +785,24 @@ const initOriginalList = (state, originalDecodedMap, options) => {
             astInfo: {
                 functions: [],
                 branches: []
-            }
+            },
+            // coverage data
+            v8Data: {}
         };
 
-        originalMap.set(sourceIndex, originalState);
+        originalStateMap.set(sourceIndex, originalState);
     });
 
-    return originalMap;
+    return originalStateMap;
 };
 
-const collectOriginalList = (item, state, originalMap, options) => {
+const collectOriginalList = (state, originalStateMap) => {
 
-    const { fileUrls, sourceMap } = state;
-    const distFile = sourceMap.file || path.basename(item.sourcePath);
+    const { fileUrls } = state;
+    const distFile = state.sourcePath;
 
     // collect original files
-    const sourceList = [];
-
-    originalMap.forEach((originalState) => {
+    originalStateMap.forEach((originalState) => {
 
         const {
             js, type, sourcePath, source
@@ -788,7 +812,7 @@ const collectOriginalList = (item, state, originalMap, options) => {
         const url = fileUrls[sourcePath] || sourcePath;
 
         // add dist for id
-        const id = Util.calculateSha1(distFile + sourcePath + source);
+        const id = Util.calculateSha1(sourcePath + source);
 
         const sourceItem = {
             url,
@@ -800,31 +824,26 @@ const collectOriginalList = (item, state, originalMap, options) => {
             source
         };
 
-        // generate coverage for current file, state for dist file
-        collectFileCoverage(sourceItem, originalState, state.coverageData, options);
-
-        sourceList.push(sourceItem);
+        // save v8 data and add to originalList
+        originalState.v8Data = sourceItem;
+        state.originalList.push(originalState);
     });
 
-    return sourceList;
 };
 
 // ========================================================================================================
 
-const generateCoverageForDist = (item, state, options) => {
+const generateCoverageForDist = (state) => {
 
     handleFunctionsCoverage(state);
     handleBranchesCoverage(state);
     handleBytesCoverage(state);
 
-    collectFileCoverage(item, state, state.coverageData, options);
-
 };
 
-const unpackSourceMap = async (item, state, options) => {
+const unpackSourceMap = (state, options) => {
 
-    const { sourcePath } = item;
-    const sourceMap = state.sourceMap;
+    const { sourceMap } = state;
 
     // keep original urls
     const fileUrls = {};
@@ -834,26 +853,24 @@ const unpackSourceMap = async (item, state, options) => {
 
     // ===============================================
     // decode mappings for each original file
-    const time_start_decode = Date.now();
+
     const originalDecodedMap = new Map();
     // for find-original-range
-    state.decodedMappings = await decodeSourceMappings(state, originalDecodedMap);
-    // only debug level
-    Util.logTime(`decode source mappings: ${sourcePath}`, time_start_decode);
+    state.decodedMappings = decodeSourceMappings(state, originalDecodedMap);
 
     // filter original list and init list
-    const originalMap = initOriginalList(state, originalDecodedMap, options);
+    const originalStateMap = initOriginalList(state, originalDecodedMap, options);
 
     originalDecodedMap.clear();
 
     // ===============================================
 
     // handle functions before handle original state functions
-    handleOriginalFunctionsCoverage(state, originalMap);
-    handleOriginalBranchesCoverage(state, originalMap);
+    handleOriginalFunctionsCoverage(state, originalStateMap);
+    handleOriginalBranchesCoverage(state, originalStateMap);
 
     // handle lines info before handle ranges to update line count
-    originalMap.forEach((originalState) => {
+    originalStateMap.forEach((originalState) => {
 
         handleFunctionsCoverage(originalState);
         handleBranchesCoverage(originalState);
@@ -865,31 +882,31 @@ const unpackSourceMap = async (item, state, options) => {
     });
 
     // handle ranges after lines ready
-    handleOriginalBytesCoverage(state, originalMap);
+    handleOriginalBytesCoverage(state, originalStateMap);
 
     // collect coverage for original list
-    state.sourceList = collectOriginalList(item, state, originalMap, options);
+    collectOriginalList(state, originalStateMap);
 
 };
 
-const unpackDistFile = async (item, state, options) => {
+const unpackDistFile = (item, state, options) => {
 
     if (state.sourceMap) {
         if (Util.loggingType === 'debug') {
             // js self
             item.debug = true;
-            generateCoverageForDist(item, state, options);
+            generateCoverageForDist(state);
         } else {
             item.dedupe = true;
         }
 
         // unpack source map
-        await unpackSourceMap(item, state, options);
+        unpackSourceMap(state, options);
 
     } else {
 
         // css/js self
-        generateCoverageForDist(item, state, options);
+        generateCoverageForDist(state);
 
     }
 
@@ -897,27 +914,260 @@ const unpackDistFile = async (item, state, options) => {
 
 // ========================================================================================================
 
-const dedupeV8List = (v8list) => {
-    const indexes = [];
-    v8list.forEach((item, i) => {
-        if (item.dedupe) {
-            indexes.push(i);
+const filterCoverageList = (item) => {
+    const {
+        functions, scriptOffset, source
+    } = item;
+
+    // no script offset
+    if (!scriptOffset) {
+        return functions;
+    }
+
+    // vm script offset
+    const minOffset = scriptOffset;
+    // the inline sourcemap could be removed
+    const maxOffset = source.length;
+
+    const rootFunctionInfo = {
+        root: true,
+        ranges: [{
+            startOffset: minOffset,
+            endOffset: maxOffset,
+            count: 1
+        }]
+    };
+
+    const coverageList = functions.filter((block) => {
+        const { ranges } = block;
+
+        // first one is function coverage info
+        const functionRange = ranges[0];
+        const { startOffset, endOffset } = functionRange;
+        if (startOffset >= minOffset && endOffset <= maxOffset) {
+            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);
+                }
+            }
         }
+
+        return false;
     });
-    if (indexes.length) {
-        indexes.reverse();
-        indexes.forEach((i) => {
-            v8list.splice(i, 1);
-        });
+
+    // first one for root function
+    if (rootFunctionInfo.ranges.length > 1) {
+        coverageList.unshift(rootFunctionInfo);
+    }
+
+    return coverageList;
+};
+
+// ========================================================================================================
+
+const isCoveredInRanges = (range, uncoveredBytes) => {
+    if (!uncoveredBytes.length) {
+        return true;
+    }
+    for (const item of uncoveredBytes) {
+        if (range.start >= item.start && range.end <= item.end) {
+            return false;
+        }
     }
+    return true;
+};
+
+const mergeV8Data = (state, stateList) => {
+    // console.log(stateList);
+
+    // const sourcePath = state.sourcePath;
+    // console.log(sourcePath);
+    // if (sourcePath.endsWith('scroll_zoom.ts')) {
+    // console.log('merge v8 data ===================================', sourcePath);
+    // console.log(stateList.map((it) => it.bytes));
+    // console.log(stateList.map((it) => it.functions));
+    // console.log(stateList.map((it) => it.branches.map((b) => [`${b.start}-${b.end}`, JSON.stringify(b.locations.map((l) => l.count))])));
+    // }
+
+    // ===========================================================
+    // bytes
+    const mergedBytes = [];
+    const uncoveredList = [];
+    stateList.forEach((st) => {
+        const bytes = dedupeCountRanges(st.bytes);
+        const uncoveredBytes = [];
+        bytes.forEach((range) => {
+            if (range.count) {
+                mergedBytes.push(range);
+            } else {
+                uncoveredBytes.push(range);
+            }
+        });
+        uncoveredList.push(uncoveredBytes);
+    });
+    // just remove uncovered range
+    uncoveredList.forEach((currentBytes) => {
+        currentBytes.forEach((range) => {
+            for (const targetBytes of uncoveredList) {
+                if (targetBytes === currentBytes) {
+                    continue;
+                }
+                if (isCoveredInRanges(range, targetBytes)) {
+                    return;
+                }
+            }
+            mergedBytes.push(range);
+        });
+    });
+
+    // will be dedupeCountRanges in collectFileCoverage
+    state.bytes = mergedBytes;
+
+    // ===========================================================
+    // functions
+    const allFunctions = stateList.map((it) => it.functions).flat();
+    const functionComparer = (lastRange, range) => {
+        // if (lastRange.start === range.start && lastRange.end === range.end) {
+        //     return true;
+        // }
+
+        // function range could be from sourcemap, not exact matched
+
+        // end is same
+        // {start: 2017, end: 2315, count: 481}
+        // {start: 2018, end: 2315, count: 14}
+
+        // start is same
+        // {start: 10204, end: 10379, count: 0}
+        // {start: 10204, end: 10393, count: 5}
+
+        // only one position matched could be same
+        if (lastRange.start === range.start || lastRange.end === range.end) {
+            // console.log(lastRange.start, range.start, lastRange.end, range.end);
+
+            // if (lastRange.start === range.start) {
+            //     console.log(range.end - lastRange.end, lastRange.start, lastRange.end, 'end', range.end, state.sourcePath);
+            // } else {
+            //     console.log(range.start - lastRange.start, lastRange.start, lastRange.end, 'start', range.start, state.sourcePath);
+            // }
+
+            return true;
+        }
+
+        return false;
+    };
+    const functionHandler = (lastRange, range) => {
+        lastRange.count += range.count;
+    };
+    const mergedFunctions = mergeRangesWith(allFunctions, functionComparer, functionHandler);
+    state.functions = mergedFunctions;
+
+    // ===========================================================
+    // branches
+    const allBranches = stateList.map((it) => it.branches).flat();
+    const branchComparer = (lastRange, range) => {
+        // exact matched because the branch range is generated from ast
+        return lastRange.start === range.start && lastRange.end === range.end;
+    };
+    const branchHandler = (lastRange, range) => {
+        // merge locations count
+        lastRange.locations.forEach((item, i) => {
+            const loc = range.locations[i];
+            if (loc) {
+                item.count += loc.count;
+            }
+        });
+    };
+    const mergedBranches = mergeRangesWith(allBranches, branchComparer, branchHandler);
+    state.branches = mergedBranches;
+
+    // if (sourcePath.endsWith('scroll_zoom.ts')) {
+    // console.log(mergedBytes);
+    // console.log(mergedFunctions);
+    // console.log(mergedBranches.map((b) => [`${b.start}-${b.end}`, JSON.stringify(b.locations.map((l) => l.count))]));
+    // }
+
+
 };
 
-const convertV8List = async (v8list, options) => {
+const generateV8DataList = (stateList, options) => {
+
+    const stateMap = new Map();
+
+    // all original files from dist
+    const allOriginalList = [];
+    stateList.forEach((state) => {
+        const { v8Data, originalList } = state;
+        // dedupe dist file if not debug
+        if (!v8Data.dedupe) {
+            stateMap.set(v8Data.id, state);
+        }
+        allOriginalList.push(originalList);
+    });
+
+    // merge istanbul and v8(converted)
+    const mergeMap = new Map();
+    allOriginalList.flat().forEach((originalState) => {
+        const { v8Data } = originalState;
+        const id = v8Data.id;
+        // exists item
+        const prevState = stateMap.get(id);
+        if (prevState) {
+            // ignore empty item, just override it
+            if (!prevState.v8Data.empty) {
+                if (mergeMap.has(id)) {
+                    mergeMap.get(id).push(originalState);
+                } else {
+                    mergeMap.set(id, [prevState, originalState]);
+                }
+                return;
+            }
+        }
+        stateMap.set(id, originalState);
+    });
 
-    // global file sources and coverage
+    const mergeIds = mergeMap.keys();
+    for (const id of mergeIds) {
+        const state = stateMap.get(id);
+        // for source the type could be ts, so just use js (boolean)
+        if (state.js) {
+            mergeV8Data(state, mergeMap.get(id));
+        } else {
+            // should no css here, css can not be in sources
+        }
+    }
+
+    // new v8 data list (includes sources)
+    const v8DataList = [];
+    // global file sources and istanbul coverage data
     const fileSources = {};
     const coverageData = {};
-    let sourceList = [];
+    stateMap.forEach((state) => {
+        const { v8Data } = state;
+        const istanbulData = collectFileCoverage(v8Data, state, options);
+        const { sourcePath, source } = v8Data;
+        v8DataList.push(v8Data);
+        fileSources[sourcePath] = source;
+        coverageData[sourcePath] = istanbulData;
+    });
+
+    return {
+        v8DataList,
+        fileSources,
+        coverageData
+    };
+};
+
+const convertV8List = (v8list, options) => {
+
+    const stateList = [];
 
     for (const item of v8list) {
         // console.log([item.id]);
@@ -930,14 +1180,11 @@ const convertV8List = async (v8list, options) => {
         const js = type === 'js';
         item.js = js;
 
-        // append file source
-        fileSources[sourcePath] = source;
-
         // source mapping
         const locator = new Locator(source);
 
         // ============================
-        // move  sourceMap
+        // move sourceMap
         const sourceMap = item.sourceMap;
         if (sourceMap) {
             delete item.sourceMap;
@@ -948,7 +1195,7 @@ const convertV8List = async (v8list, options) => {
         let coverageList = [];
         let astInfo;
         if (js) {
-            coverageList = item.functions;
+            coverageList = filterCoverageList(item);
             // remove original functions
             if (Util.loggingType !== 'debug') {
                 delete item.functions;
@@ -966,57 +1213,34 @@ const convertV8List = async (v8list, options) => {
         // ============================
 
         // current file and it's sources from sourceMap
+        // see const originalState
         const state = {
             js,
             type,
+            source,
             sourcePath,
             sourceMap,
-            coverageList,
             locator,
+            decodedMappings: [],
             // coverage info
             bytes: [],
             functions: [],
             branches: [],
             astInfo,
-            // for istanbul
-            fileSources: {},
-            coverageData: {}
+            // for sub source files
+            coverageList,
+            originalList: [],
+            // coverage data
+            v8Data: item
         };
 
-        await unpackDistFile(item, state, options);
+        unpackDistFile(item, state, options);
 
-        // merge state
-        Object.assign(fileSources, state.fileSources);
-        Object.assign(coverageData, state.coverageData);
-
-        if (Util.isList(state.sourceList)) {
-            sourceList = sourceList.concat(state.sourceList);
-        }
+        stateList.push(state);
 
     }
 
-    // add all sources
-    if (sourceList.length) {
-        sourceList.forEach((item) => {
-
-            // second time filter for empty source
-            // exists same id, mark previous item as dedupe
-            const prevItem = v8list.find((it) => it.id === item.id);
-            if (prevItem) {
-                prevItem.dedupe = true;
-            }
-
-            v8list.push(item);
-        });
-    }
-
-    // dedupe
-    dedupeV8List(v8list);
-
-    return {
-        fileSources,
-        coverageData
-    };
+    return generateV8DataList(stateList, options);
 
 };