monocart-coverage-reports 2.8.5 → 2.8.6

package/README.md

@@ -4,7 +4,7 @@
 [![](https://badgen.net/npm/dw/monocart-coverage-reports)](https://www.npmjs.com/package/monocart-coverage-reports)
 ![](https://img.shields.io/librariesio/github/cenfun/monocart-coverage-reports)
 ![](https://img.shields.io/github/license/cenfun/monocart-coverage-reports)
-![](https://img.shields.io/github/actions/workflow/status/cenfun/monocart-coverage-reports/static.yml)
+![](https://img.shields.io/github/actions/workflow/status/cenfun/monocart-coverage-reports/ci.yml)
 
 🌐 English | [简体中文](README.zh-Hans.md)
 

package/README.zh-Hans.md

@@ -4,7 +4,7 @@
 [![](https://badgen.net/npm/dw/monocart-coverage-reports)](https://www.npmjs.com/package/monocart-coverage-reports)
 ![](https://img.shields.io/librariesio/github/cenfun/monocart-coverage-reports)
 ![](https://img.shields.io/github/license/cenfun/monocart-coverage-reports)
-![](https://img.shields.io/github/actions/workflow/status/cenfun/monocart-coverage-reports/static.yml)
+![](https://img.shields.io/github/actions/workflow/status/cenfun/monocart-coverage-reports/ci.yml)
 
 🌐 [English](README.md) | 简体中文
 

package/lib/converter/collect-source-maps.js

@@ -128,18 +128,6 @@ const resolveSourceMap = (data, url) => {
 
 };
 
-const saveSourceFile = async (filePath, data) => {
-    await Util.writeFile(filePath, JSON.stringify(data));
-
-    // save source and sourcemap file for debug
-    // https://evanw.github.io/source-map-visualization
-    // if (data.sourceMap) {
-    //     await Util.writeFile(`${filePath}.js`, data.source);
-    //     await Util.writeFile(`${filePath}.js.map`, JSON.stringify(data.sourceMap));
-    // }
-
-};
-
 const getInlineSourceMap = (content) => {
     let smc;
     try {
@@ -153,7 +141,8 @@ const getInlineSourceMap = (content) => {
 
 const collectSourceMaps = async (v8list, options) => {
 
-    const smList = [];
+    const sourceList = [];
+    const sourcemapList = [];
     const concurrency = new Concurrency();
     for (const item of v8list) {
 
@@ -168,8 +157,8 @@ const collectSourceMaps = async (v8list, options) => {
         delete item.sourceMap;
 
         // source and sourceMap already saved
-        const sourcePath = Util.resolveCacheSourcePath(options.cacheDir, id);
-        if (fs.existsSync(sourcePath)) {
+        const { cachePath } = Util.getCacheFileInfo('source', id, options.cacheDir);
+        if (fs.existsSync(cachePath)) {
             continue;
         }
 
@@ -192,11 +181,11 @@ const collectSourceMaps = async (v8list, options) => {
             const smc = getInlineSourceMap(source);
             if (smc) {
                 sourceData.sourceMap = resolveSourceMap(smc.sourcemap, url);
-                smList.push({
+                sourcemapList.push({
                     url,
                     inline: true
                 });
-                await saveSourceFile(sourcePath, sourceData);
+                sourceList.push(sourceData);
                 continue;
             }
             // from url async
@@ -204,7 +193,6 @@ const collectSourceMaps = async (v8list, options) => {
             if (sourceMapUrl) {
                 concurrency.addItem({
                     sourceMapUrl,
-                    sourcePath,
                     sourceData
                 });
                 continue;
@@ -212,7 +200,7 @@ const collectSourceMaps = async (v8list, options) => {
         }
 
         // no need check sourceMap
-        await saveSourceFile(sourcePath, sourceData);
+        sourceList.push(sourceData);
 
     }
 
@@ -223,15 +211,20 @@ const collectSourceMaps = async (v8list, options) => {
         const data = await loadSourceMap(sourceMapUrl);
         if (data) {
             sourceData.sourceMap = resolveSourceMap(data, url);
-            smList.push({
+            sourcemapList.push({
                 url,
                 sourceMapUrl
             });
         }
-        await saveSourceFile(item.sourcePath, sourceData);
+
+        sourceList.push(sourceData);
+
     });
 
-    return smList;
+    return {
+        sourceList,
+        sourcemapList
+    };
 
 };
 

package/lib/converter/converter.js

@@ -1239,15 +1239,17 @@ const initJsCoverageList = (item) => {
                         inUncoveredRange.coveredList.push(range);
                     }
                 }
-            } else {
-                if (count === 0) {
-                    uncoveredBlocks.push({
-                        ... range,
-                        index: i,
-                        ranges: block.ranges
-                    });
-                }
+                return;
             }
+
+            if (count === 0) {
+                uncoveredBlocks.push({
+                    ... range,
+                    index: i,
+                    ranges: block.ranges
+                });
+            }
+
         });
     });
 
@@ -1283,7 +1285,7 @@ const initJsCoverageList = (item) => {
                 });
             }
 
-            ranges.splice.apply(ranges, args);
+            ranges.splice(... args);
 
         });
     }
@@ -1493,6 +1495,8 @@ const convertV8List = (v8list, options) => {
     for (const item of v8list) {
         // console.log([item.id]);
 
+        const time_start_ast = Date.now();
+
         const {
             type, source, fake, sourcePath
         } = item;
@@ -1513,7 +1517,6 @@ const convertV8List = (v8list, options) => {
         }
 
         // ============================
-        const time_start_ast = Date.now();
         // move functions and ranges to coverageList
         let coverageList = [];
         let astInfo;
@@ -1532,11 +1535,14 @@ const convertV8List = (v8list, options) => {
                 delete item.ranges;
             }
         }
-        Util.logTime(`- parsed ast: ${sourcePath} (${EC.cyan(Util.BSF(maxContentLength))})`, time_start_ast);
+
+        Util.logTime(`  ┌ [convert] parsed ast: ${sourcePath} (${EC.cyan(Util.BSF(maxContentLength))})`, time_start_ast);
 
         // console.log(sourcePath, astInfo.statements.length);
         // ============================
 
+        const time_start_unpack = Date.now();
+
         // current file and it's sources from sourceMap
         // see const originalState
         const state = {
@@ -1549,7 +1555,11 @@ const convertV8List = (v8list, options) => {
             locator,
             maxContentLength,
             decodedMappings: [],
-            cacheMap: new Map(),
+            rangeCache: new Map(),
+            diffCache: new Map(),
+
+            // alignTextList: [],
+
             // coverage info
             bytes: [],
             functions: [],
@@ -1563,19 +1573,25 @@ const convertV8List = (v8list, options) => {
             v8Data: item
         };
 
-        const time_start_unpack = Date.now();
         unpackDistFile(item, state, options);
         const unpackedFiles = EC.cyan(`${state.originalList.length} files`);
-        Util.logTime(`- unpacked dist: ${sourcePath} (${unpackedFiles})`, time_start_unpack);
 
         stateList.push(state);
 
+        Util.logTime(`  ┌ [convert] unpacked sourcemap: ${sourcePath} (${unpackedFiles})`, time_start_unpack);
+
     }
 
     const time_start_convert = Date.now();
+
     const dataList = generateV8DataList(stateList, options);
     const dataFiles = EC.cyan(`${dataList.v8DataList.length} files`);
-    Util.logTime(`- generated data list (${dataFiles})`, time_start_convert);
+
+    // stateList.forEach((st, i) => {
+    // Util.writeFileSync(`align-text-${i}.js`, `window.gridData = ${JSON.stringify(st.alignTextList, null, 4)}`);
+    // });
+
+    Util.logTime(`  ┌ [convert] converted data list (${dataFiles})`, time_start_convert);
 
     return dataList;
 };

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

@@ -39,7 +39,16 @@ const findMapping = (list, offset) => {
 
 // ========================================================================================================
 
-const alignText = (gt, ot) => {
+const alignText = (gt, ot, info) => {
+
+    const { diffCache } = info.state;
+
+    if (diffCache.has(gt)) {
+        const subMap = diffCache.get(gt);
+        if (subMap.has(ot)) {
+            return subMap.get(ot);
+        }
+    }
 
     const toList = (s) => {
         return s.split('').map((v, i) => {
@@ -115,6 +124,15 @@ const alignText = (gt, ot) => {
         mergeList(gList, oList);
     }
 
+    if (diffCache.has(gt)) {
+        const subMap = diffCache.get(gt);
+        subMap.set(ot, gl);
+    } else {
+        const subMap = new Map();
+        diffCache.set(gt, subMap);
+        subMap.set(ot, gl);
+    }
+
     // console.log(gl);
     return gl;
 };
@@ -136,10 +154,19 @@ const getWordEndPosition = (list, gp, direction) => {
     }
 };
 
-const getAlignPosition = (gt, gp, ot, direction) => {
+const getAlignPosition = (info, direction) => {
+
+    const gt = info.generatedText;
+    const gp = info.generatedPos;
+    const ot = info.originalText;
+
+    // const alignTextItem = {
+    //     gt, ot, gp
+    // };
+    // info.state.alignTextList.push(it);
 
     // there is no need to align for long text
-    const maxLength = 500;
+    const maxLength = 100;
     if (gt.length > maxLength || ot.length > maxLength) {
         // console.log(gt.length, ot.length, gp);
         return;
@@ -155,16 +182,16 @@ const getAlignPosition = (gt, gp, ot, direction) => {
     // generatedText: '1;else',
     // generatedLeft: '1;'
 
-    // generatedText: '    var id = options.base ? item[0] + options.base : item[0];\r\n',
-    // originalText: '    var id = options.base ? item[0] + options.base : item[0];\n',
-
     // right matched
     // only for original first line text
 
     // exclusive
-    const list = alignText(gt, ot);
+    const list = alignText(gt, ot, info);
     const item = list[gp];
     if (item && item.original) {
+
+        // alignTextItem.op = item.original.index;
+
         return {
             pos: item.original.index
         };
@@ -280,10 +307,15 @@ const getComparedPosition = (info, direction) => {
     }
 
     // =============================
-    // trim right
-    const gtt = gt.trimEnd();
-    const ott = ot.trimEnd();
+    // trim
+
+    const gtt = gt.trim();
+    // no generated content after trim
+    if (!gtt) {
+        return;
+    }
 
+    const ott = ot.trim();
     // no original content after trim
     if (!ott) {
         return {
@@ -291,21 +323,21 @@ const getComparedPosition = (info, direction) => {
         };
     }
 
-    // no generated content after trim
-    if (!gtt) {
-        return;
-    }
-
     // same content
     if (gtt === ott) {
+        // fix indent
+        const blankBlock = /\S/;
+        const gi = gt.search(blankBlock);
+        const oi = ot.search(blankBlock);
+
         return {
-            pos: gp
+            pos: gp - gi + oi
         };
     }
 
     // =============================
 
-    return getAlignPosition(gt, gp, ot, direction);
+    return getAlignPosition(info, direction);
 
 };
 
@@ -325,7 +357,7 @@ const getSimilarPosition = (info, direction) => {
     }
 
     // no need comparison for fake source
-    if (info.fake) {
+    if (info.state.fake) {
         return;
     }
 
@@ -388,31 +420,48 @@ const getOriginalText = (m1, m2, cache) => {
 
     const o1 = m1.originalOffset;
     const o2 = m2.originalOffset;
+    const sameLine = m2.originalLine === m1.originalLine;
 
     // o1 < o2: most of time
     if (o1 < o2) {
+
+        // could be in comments
+        // it must be wrong sourcemap, do not fix it here
+        // if (originalLocator.lineParser.commentParser.isComment(o1, o2)) {
+        //     console.log('in comments', originalLocator.getSlice(o1, o2), originalLocator.offsetToLocation(o1), originalLocator.offsetToLocation(o2), cache.originalState.sourcePath);
+        //     return {
+        //         originalOffset: o1,
+        //         originalText: ''
+        //     };
+        // }
+
+        if (sameLine) {
+            return {
+                originalOffset: o1,
+                originalText: originalLocator.getSlice(o1, o2)
+            };
+        }
+
         // could be multiple lines for original text
         return {
             originalOffset: o1,
-            originalText: originalLocator.getSlice(o1, o2)
+            originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, cache))
         };
     }
 
     // esbuild fixing two mapping have same original
     // m1 to end line
     if (o1 === o2) {
-        const originalEndOffset = getOriginalEndOffset(m1, cache);
         return {
             originalOffset: o1,
-            originalText: originalLocator.getSlice(o1, originalEndOffset)
+            originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, cache))
         };
     }
 
     // o1 > o2: should be wrong sourcemap
 
-    // just reverse offsets if few cross lines
-    const crossLines = m1.originalLine - m2.originalLine;
-    if (crossLines < 2) {
+    // just reverse offsets if same line
+    if (sameLine) {
         return {
             originalOffset: o2,
             originalText: originalLocator.getSlice(o2, o1)
@@ -426,10 +475,9 @@ const getOriginalText = (m1, m2, cache) => {
     // }
 
     // should be wrong, ignore m2
-    const originalEndOffset = getOriginalEndOffset(m1, cache);
     return {
         originalOffset: o1,
-        originalText: originalLocator.getSlice(o1, originalEndOffset)
+        originalText: originalLocator.getSlice(o1, getOriginalEndOffset(m1, cache))
     };
 
 };
@@ -505,7 +553,7 @@ const getFixedOriginalStart = (start, mappings, state, cache) => {
     const direction = 'start';
 
     const info = {
-        fake: state.fake,
+        state,
         generatedText,
         generatedPos,
         originalText,
@@ -558,7 +606,7 @@ const getFixedOriginalEnd = (end, mappings, state, cache) => {
     const direction = 'end';
 
     const info = {
-        fake: state.fake,
+        state,
         offset: end,
         generatedText,
         generatedPos,
@@ -826,11 +874,11 @@ const getMappingInfo = (start, end, state) => {
 
 const findOriginalRange = (start, end, state, originalMap) => {
 
-    const { sourcePath, cacheMap } = state;
+    const { sourcePath, rangeCache } = state;
 
     const key = `${start}_${end}`;
-    if (cacheMap.has(key)) {
-        return cacheMap.get(key);
+    if (rangeCache.has(key)) {
+        return rangeCache.get(key);
     }
 
     const createMappingError = (errors) => {
@@ -843,7 +891,7 @@ const findOriginalRange = (start, end, state, originalMap) => {
         };
 
         // cache error response
-        cacheMap.set(key, res);
+        rangeCache.set(key, res);
 
         return res;
     };
@@ -884,7 +932,7 @@ const findOriginalRange = (start, end, state, originalMap) => {
     };
 
     // cache response
-    cacheMap.set(key, res);
+    rangeCache.set(key, res);
 
     return res;
 

package/lib/default/template.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">