monocart-coverage-reports 2.7.1 → 2.7.3

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

@@ -129,13 +129,18 @@ const getComparedPosition = (info, direction) => {
     gt = gt.trimEnd();
     ot = ot.trimEnd();
 
-    // no content after trim
-    if (!ot.length) {
+    // no original content after trim
+    if (!ot) {
         return {
             pos: direction === 'start' ? oLen : 0
         };
     }
 
+    // no generated content after trim
+    if (!gt) {
+        return;
+    }
+
     // same content
     if (gt === ot) {
         return {
@@ -273,16 +278,16 @@ const getFixedPosition = (info, direction) => {
 
 // ========================================================================================================
 
-const getOriginalEndOffset = (m, rangeInfo) => {
+const getOriginalEndOffset = (m, cache) => {
     if (!m.originalEndOffset) {
-        const line = rangeInfo.originalState.locator.getLine(m.originalLine + 1);
+        const line = cache.originalState.locator.getLine(m.originalLine + 1);
         m.originalEndOffset = line ? line.end : m.originalOffset;
     }
     return m.originalEndOffset;
 };
 
-const getOriginalText = (m1, m2, rangeInfo) => {
-    const originalLocator = rangeInfo.originalState.locator;
+const getOriginalText = (m1, m2, cache) => {
+    const originalLocator = cache.originalState.locator;
 
     const o1 = m1.originalOffset;
     const o2 = m2.originalOffset;
@@ -299,7 +304,7 @@ const getOriginalText = (m1, m2, rangeInfo) => {
     // esbuild fixing two mapping have same original
     // m1 to end line
     if (o1 === o2) {
-        const originalEndOffset = getOriginalEndOffset(m1, rangeInfo);
+        const originalEndOffset = getOriginalEndOffset(m1, cache);
         return {
             originalOffset: o1,
             originalText: originalLocator.getSlice(o1, originalEndOffset)
@@ -319,12 +324,12 @@ const getOriginalText = (m1, m2, rangeInfo) => {
 
     // if (direction === 'start') {
     // should be m2 ?
-    // console.log(direction, rangeInfo.originalState.sourcePath);
+    // console.log(direction, cache.originalState.sourcePath);
     // console.log(m1, m2);
     // }
 
     // should be wrong, ignore m2
-    const originalEndOffset = getOriginalEndOffset(m1, rangeInfo);
+    const originalEndOffset = getOriginalEndOffset(m1, cache);
     return {
         originalOffset: o1,
         originalText: originalLocator.getSlice(o1, originalEndOffset)
@@ -385,10 +390,10 @@ const getGeneratedText = (m1, m2, state, offset) => {
 
 // ========================================================================================================
 
-const getFixedOriginalStart = (start, mappings, state, rangeInfo) => {
+const getFixedOriginalStart = (start, mappings, state, cache) => {
 
     const [m1, m2] = mappings;
-    const { originalState, crossStart } = rangeInfo;
+    const { originalState, crossStart } = cache;
 
     // cross file from start of line
     if (crossStart) {
@@ -398,7 +403,7 @@ const getFixedOriginalStart = (start, mappings, state, rangeInfo) => {
     }
 
     const direction = 'start';
-    const { originalText, originalOffset } = getOriginalText(m1, m2, rangeInfo);
+    const { originalText, originalOffset } = getOriginalText(m1, m2, cache);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, start);
 
     const info = {
@@ -426,14 +431,14 @@ const getFixedOriginalStart = (start, mappings, state, rangeInfo) => {
     };
 };
 
-const getFixedOriginalEnd = (end, mappings, state, rangeInfo) => {
+const getFixedOriginalEnd = (end, mappings, state, cache) => {
 
     const [m1, m2] = mappings;
-    const { originalState, crossEnd } = rangeInfo;
+    const { originalState, crossEnd } = cache;
 
     // cross file until e1 line end (not file end)
     if (crossEnd) {
-        const originalEndOffset = getOriginalEndOffset(m1, rangeInfo);
+        const originalEndOffset = getOriginalEndOffset(m1, cache);
         return {
             originalEnd: originalEndOffset
         };
@@ -448,33 +453,8 @@ const getFixedOriginalEnd = (end, mappings, state, rangeInfo) => {
         };
     }
 
-    // quick check next one if exact match
-    // most of case is same string
-    if (m2.generatedOffset === end + 1) {
-        const gt = state.locator.source[end];
-        const oi = m2.originalOffset - 1;
-        const ot = originalState.locator.source[oi];
-        // it could be ; but it quite far away
-        if (gt === ot && [';', ','].includes(gt)) {
-            return {
-                originalEnd: oi
-            };
-        }
-
-        // Not applicable
-        // console.log('==================================');
-        // console.log({
-        //     gp: state.sourcePath,
-        //     g: end,
-        //     gt,
-        //     op: originalState.sourcePath,
-        //     o: oi,
-        //     ot
-        // });
-    }
-
     const direction = 'end';
-    const { originalText, originalOffset } = getOriginalText(m1, m2, rangeInfo);
+    const { originalText, originalOffset } = getOriginalText(m1, m2, cache);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, end);
 
     const info = {
@@ -506,23 +486,57 @@ const getFixedOriginalEnd = (end, mappings, state, rangeInfo) => {
 
 // ========================================================================================================
 
-const getOriginalStart = (start, startMapping, state, rangeInfo) => {
-    if (Array.isArray(startMapping)) {
-        return getFixedOriginalStart(start, startMapping, state, rangeInfo);
+const getOriginalStartPosition = (cache, state) => {
+
+    const { start, startMappings } = cache;
+
+    if (Array.isArray(startMappings)) {
+        return getFixedOriginalStart(start, startMappings, state, cache);
     }
+
     // Exact match
     return {
-        originalStart: startMapping.originalOffset
+        originalStart: startMappings.originalOffset
     };
 };
 
-const getOriginalEnd = (end, endMapping, state, rangeInfo) => {
-    if (Array.isArray(endMapping)) {
-        return getFixedOriginalEnd(end, endMapping, state, rangeInfo);
+const getOriginalExclusiveEnd = (cache, state) => {
+    // end, exclusive mappings
+    const { end } = cache;
+    const { decodedMappings } = state;
+    const endMappings = findMapping(decodedMappings, end);
+    if (Array.isArray(endMappings)) {
+        return getFixedOriginalEnd(end, endMappings, state, cache);
     }
-    // Exact match
+
+    // Exact match end
     return {
-        originalEnd: endMapping.originalOffset
+        originalEnd: endMappings.originalOffset
+    };
+};
+
+const getOriginalEndPosition = (cache, state) => {
+
+    const { endMappings, originalState } = cache;
+
+    // (end - 1), inclusive
+    if (Array.isArray(endMappings)) {
+        return getOriginalExclusiveEnd(cache, state);
+    }
+
+    // Exact match (end - 1)
+
+    // check end char
+    const oi = endMappings.originalOffset;
+    const originalEndChar = originalState.locator.getSlice(oi, oi + 1);
+    // the char should never end with "{" or "("
+    if (['{', '('].includes(originalEndChar)) {
+        return getOriginalExclusiveEnd(cache, state);
+    }
+
+    // inclusive to exclusive
+    return {
+        originalEnd: oi + 1
     };
 };
 
@@ -536,9 +550,6 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
                 sourceIndex: s1
             };
         }
-        return {
-            error: true
-        };
     };
 
     const checkIndex21 = (s1, s2, e1) => {
@@ -553,9 +564,6 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
                 sourceIndex: e1
             };
         }
-        return {
-            error: true
-        };
     };
 
     const checkIndex12 = (s1, e1, e2) => {
@@ -570,9 +578,6 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
                 sourceIndex: s1
             };
         }
-        return {
-            error: true
-        };
     };
 
     const checkIndex22 = (s1, s2, e1, e2) => {
@@ -602,10 +607,6 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
         // both between two mappings: 38,39 ~ 38,39
         // if (s1 === e1 && s2 === e2) {
         // }
-
-        return {
-            error: true
-        };
     };
 
     // both exact matched
@@ -626,13 +627,20 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
 
 };
 
-const getOriginalState = (startMappings, endMappings, originalMap) => {
+const getOriginalState = (start, end, state, originalMap) => {
+
+    const mappingInfo = getMappingInfo(start, end, state);
+    if (mappingInfo.error) {
+        return mappingInfo;
+    }
+
+    const { startMappings, endMappings } = mappingInfo;
 
     // check source file indexes
     const startIndexes = [].concat(startMappings).map((it) => it.sourceIndex);
     const endIndexes = [].concat(endMappings).map((it) => it.sourceIndex);
-    const rangeInfo = checkSourceFileIndexes(startIndexes, endIndexes);
-    if (rangeInfo.error) {
+    const results = checkSourceFileIndexes(startIndexes, endIndexes);
+    if (!results) {
         return {
             error: true,
             errors: [`invalid source indexes: ${EC.yellow(`${startIndexes} ~ ${endIndexes}`)}`]
@@ -641,7 +649,7 @@ const getOriginalState = (startMappings, endMappings, originalMap) => {
 
     const {
         sourceIndex, crossStart, crossEnd
-    } = rangeInfo;
+    } = results;
 
     // if (crossStart || crossEnd) {
     //     console.log(EC.magenta('cross file'), EC.yellow(`${startIndexes} ~ ${endIndexes}`));
@@ -655,11 +663,17 @@ const getOriginalState = (startMappings, endMappings, originalMap) => {
         };
     }
 
+    // cache for original info
     return {
         // for debug
         // startIndexes,
         // endIndexes,
 
+        start,
+        end,
+        startMappings,
+        endMappings,
+
         sourceIndex,
         crossStart,
         crossEnd,
@@ -667,7 +681,9 @@ const getOriginalState = (startMappings, endMappings, originalMap) => {
     };
 };
 
-const getMappingInfo = (decodedMappings, start, end) => {
+const getMappingInfo = (start, end, state) => {
+
+    const { decodedMappings } = state;
     // possible no length
     if (decodedMappings.length < 2) {
         return {
@@ -677,9 +693,6 @@ const getMappingInfo = (decodedMappings, start, end) => {
     }
 
     // start: inclusive
-    // end: exclusive
-    // could be 4 mappings found
-
     const startMappings = findMapping(decodedMappings, start);
     if (!startMappings) {
         return {
@@ -688,7 +701,8 @@ const getMappingInfo = (decodedMappings, start, end) => {
         };
     }
 
-    const endMappings = findMapping(decodedMappings, end);
+    // end: exclusive
+    const endMappings = findMapping(decodedMappings, end - 1);
     if (!endMappings) {
         return {
             error: true,
@@ -696,6 +710,7 @@ const getMappingInfo = (decodedMappings, start, end) => {
         };
     }
 
+    // could be 4 mappings found
     return {
         startMappings,
         endMappings
@@ -704,7 +719,7 @@ const getMappingInfo = (decodedMappings, start, end) => {
 
 const findOriginalRange = (start, end, state, originalMap) => {
 
-    const { sourcePath, decodedMappings } = state;
+    const { sourcePath } = state;
 
     const createMappingError = (errors) => {
         return {
@@ -716,29 +731,17 @@ const findOriginalRange = (start, end, state, originalMap) => {
         };
     };
 
-    const mappingInfo = getMappingInfo(decodedMappings, start, end);
-    if (mappingInfo.error) {
-        return createMappingError(mappingInfo.errors);
-    }
-
-    const { startMappings, endMappings } = mappingInfo;
-
-    const rangeInfo = getOriginalState(startMappings, endMappings, originalMap);
-    if (rangeInfo.error) {
-        return createMappingError(rangeInfo.errors);
-    }
-
-    const originalStartResult = getOriginalStart(start, startMappings, state, rangeInfo);
-    if (originalStartResult.error) {
-        return createMappingError(originalStartResult.errors);
-    }
-
-    const originalEndResult = getOriginalEnd(end, endMappings, state, rangeInfo);
-    if (originalEndResult.error) {
-        return createMappingError(originalEndResult.errors);
+    const cache = getOriginalState(start, end, state, originalMap);
+    if (cache.error) {
+        return createMappingError(cache.errors);
     }
 
+    const originalStartResult = getOriginalStartPosition(cache, state);
     const { originalStart } = originalStartResult;
+    // could be used for end
+    cache.originalStart = originalStart;
+
+    const originalEndResult = getOriginalEndPosition(cache, state);
     const { originalEnd } = originalEndResult;
 
     // range start > end
@@ -746,7 +749,7 @@ const findOriginalRange = (start, end, state, originalMap) => {
         return createMappingError([`invalid original start > end: ${EC.yellow(originalStart)} > ${EC.yellow(originalEnd)}`]);
     }
 
-    const { originalState } = rangeInfo;
+    const { originalState } = cache;
 
     return {
         start: originalStart,

package/lib/generate.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const CG = require('console-grid');
 const EC = require('eight-colors');
-const { pathToFileURL } = require('url');
+const { pathToFileURL, fileURLToPath } = require('url');
 
 const Util = require('./utils/util.js');
 const {
@@ -12,6 +12,7 @@ const {
 const { mergeV8Coverage, saveV8Report } = require('./v8/v8.js');
 
 const { convertV8List } = require('./converter/converter.js');
+const { resolveSourceMap } = require('./converter/collect-source-maps.js');
 
 const { minimatch } = require('./packages/monocart-coverage-vendor.js');
 const { getGroupedRows } = require('./utils/snapshot.js');
@@ -720,7 +721,135 @@ const getInputData = async (inputList, all, cacheDir, addHandler) => {
     };
 };
 
+// ========================================================================================================
+
+const resolveEntrySource = (entry, sourceMapCache, sourceCache) => {
+
+    const url = entry.url;
+
+    // source from `source-id.json`
+    const sourceData = sourceCache[url];
+    if (sourceData) {
+        entry.source = sourceData.source;
+        return;
+    }
+
+    // source for typescript file from source map cache
+    // Note: no runtime code but lineLengths
+    const tsExtensionsPattern = /\.([cm]?ts|[tj]sx)($|\?)/;
+    if (tsExtensionsPattern.test(url)) {
+        const sourcemapData = sourceMapCache[url];
+        const lineLengths = sourcemapData && sourcemapData.lineLengths;
+
+        // for fake source file (can not parse to AST)
+        if (lineLengths) {
+            let fakeSource = '';
+            sourcemapData.lineLengths.forEach((length) => {
+                fakeSource += `${''.padEnd(length, '*')}\n`;
+            });
+            entry.fake = true;
+            entry.source = fakeSource;
+            return;
+        }
+
+    }
+
+    // Note: it could be jsx format even extname is `.js`
+    const filePath = fileURLToPath(url);
+    if (fs.existsSync(filePath)) {
+        entry.source = fs.readFileSync(filePath).toString('utf8');
+    }
+
+};
+
+const resolveEntrySourceMap = (entry, sourceMapCache) => {
+    // sourcemap data
+    const sourcemapData = sourceMapCache[entry.url];
+    if (sourcemapData) {
+        if (sourcemapData.data) {
+            entry.sourceMap = resolveSourceMap(sourcemapData.data, entry.url);
+        }
+    }
+};
+
+const readCoverageData = (filePath, entryFilter, sourceCache) => {
+
+    const content = fs.readFileSync(filePath).toString('utf-8');
+    if (!content) {
+        return;
+    }
+
+    const json = JSON.parse(content);
+    let coverageData = json.result;
+    if (!Util.isList(coverageData)) {
+        return;
+    }
+
+    // filter node internal files, should no anonymous for nodejs
+    coverageData = coverageData.filter((entry) => entry.url && entry.url.startsWith('file:'));
+    coverageData = coverageData.filter(entryFilter);
+
+    if (!Util.isList(coverageData)) {
+        // Util.logDebug('No coverage data after filter');
+        return;
+    }
+
+    const sourceMapCache = json['source-map-cache'] || {};
+    for (const entry of coverageData) {
+        resolveEntrySource(entry, sourceMapCache, sourceCache);
+        resolveEntrySourceMap(entry, sourceMapCache);
+    }
+
+    return coverageData;
+};
+
+const readFromDir = async (dir, entryFilter, addHandler) => {
+
+    if (!dir || !fs.existsSync(dir)) {
+        Util.logError(`Invalid V8 coverage dir: ${dir}`);
+        return;
+    }
+
+    const files = fs.readdirSync(dir);
+    if (!files.length) {
+        Util.logInfo(`No coverage files in the dir: ${dir}`);
+        return;
+    }
+
+    const coverageFiles = [];
+    const sourceCache = {};
+    files.forEach((filename) => {
+        const isCoverage = filename.startsWith('coverage-');
+        if (isCoverage) {
+            coverageFiles.push(filename);
+            return;
+        }
+        const isSource = filename.startsWith('source-');
+        if (isSource) {
+            const filePath = path.resolve(dir, filename);
+            const content = fs.readFileSync(filePath).toString('utf-8');
+            if (content) {
+                const json = JSON.parse(content);
+                if (json.url) {
+                    sourceCache[json.url] = json;
+                }
+            }
+        }
+    });
+
+    // filter before adding
+    for (const filename of coverageFiles) {
+        const filePath = path.resolve(dir, filename);
+        const coverageData = readCoverageData(filePath, entryFilter, sourceCache);
+        if (coverageData) {
+            await addHandler(coverageData);
+        }
+    }
+
+};
+
 module.exports = {
     getInputData,
+    readFromDir,
     generateCoverageReports
 };

package/lib/index.d.ts

@@ -347,6 +347,12 @@ declare namespace MCR {
          * @param coverageData {array} V8 format, {object} Istanbul format */
         add: (coverageData: any[] | any) => Promise<AddedResults>;
 
+        /**
+         * add V8 coverage from a dir
+         * @param dir node v8 coverage dir
+         */
+        addFromDir: (dir: string) => Promise<void>;
+
         /** generate report */
         generate: () => Promise<CoverageResults>;
 

package/lib/index.js

@@ -7,7 +7,9 @@ const defaultOptions = require('./default/options.js');
 const Util = require('./utils/util.js');
 
 const { initV8ListAndSourcemap, getEntryFilter } = require('./v8/v8.js');
-const { getInputData, generateCoverageReports } = require('./generate.js');
+const {
+    getInputData, readFromDir, generateCoverageReports
+} = require('./generate.js');
 const { getSnapshot, diffSnapshot } = require('./utils/snapshot.js');
 const CDPClient = require('./client/cdp-client.js');
 
@@ -26,12 +28,15 @@ const resolveConfigOptions = async (configPath) => {
         err = ee;
     }
 
-    if (err || !configOptions) {
+    if (err) {
         Util.logError(`ERROR: failed to load config "${configPath}": ${err && err.message} `);
         return;
     }
 
-    configOptions = configOptions.default || configOptions;
+    // could be multiple level default
+    while (configOptions && configOptions.default) {
+        configOptions = configOptions.default;
+    }
 
     return configOptions;
 };
@@ -113,6 +118,14 @@ class CoverageReport {
         return results;
     }
 
+    // add coverage from dir
+    addFromDir(dir) {
+        const entryFilter = this.getEntryFilter();
+        return readFromDir(dir, entryFilter, (coverageData) => {
+            return this.add(coverageData);
+        });
+    }
+
     // generate report
     async generate() {
 
@@ -227,9 +240,9 @@ class CoverageReport {
             'mcr.config.cjs',
             'mcr.config.mjs',
             'mcr.config.json',
+            'mcr.config.ts',
             '.mcrrc.js',
-            '.mcrrc',
-            'mcr.config.ts'
+            '.mcrrc'
         ];
 
         const existsList = configList.filter((p) => p && fs.existsSync(p));
@@ -252,7 +265,8 @@ class CoverageReport {
             return;
         }
 
-        Util.logInfo(`Loaded config: ${EC.cyan(configPath)}`);
+        Util.logInfo(`Loaded: ${EC.cyan(configPath)}`);
+
         // init options again
         this.options = {
             ... defaultOptions,