monocart-coverage-reports 2.7.2 → 2.7.4

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

@@ -1,3 +1,4 @@
+const { diff } = require('../packages/monocart-coverage-vendor');
 const Util = require('../utils/util.js');
 const EC = Util.EC;
 
@@ -38,6 +39,133 @@ const findMapping = (list, offset) => {
 
 // ========================================================================================================
 
+const alignText = (gt, ot) => {
+
+    const toList = (s) => {
+        return s.split('').map((v, i) => {
+            return {
+                index: i,
+                value: v
+            };
+        });
+    };
+
+    const mergeList = (gList, oList) => {
+        const oLen = oList.length;
+        if (!oLen) {
+            return;
+        }
+        const gLen = gList.length;
+        if (gLen === oLen) {
+            gList.forEach((item, i) => {
+                item.original = oList[i];
+            });
+        }
+    };
+
+    const gl = toList(gt);
+    const ol = toList(ot);
+
+    // console.log(gl);
+    // console.log(ol);
+
+    const commonItems = [];
+    diff(gl.length, ol.length, (gi, oi) => {
+        return gl[gi].value === ol[oi].value;
+    }, (len, gi, oi) => {
+        commonItems.push([gi, oi, len]);
+    });
+
+    // console.log(commonItems);
+    // console.log('================================================================');
+    // merge list
+    // previous index
+    let gpi = 0;
+    let opi = 0;
+    commonItems.forEach(([gi, oi, len]) => {
+
+        if (gpi !== gi) {
+            const gList = gl.slice(gpi, gi);
+            const oList = ol.slice(opi, oi);
+            mergeList(gList, oList);
+        }
+
+        for (let i = 0; i < len; i++) {
+
+            const gii = gi + i;
+            const oii = oi + i;
+            const gItem = gl[gii];
+            gItem.original = ol[oii];
+
+            // matching a word end
+            if (i === len - 1 && len > 1) {
+                gItem.wordEnd = true;
+            }
+
+        }
+        gpi = gi + len;
+        opi = oi + len;
+    });
+
+    // console.log(JSON.stringify(data.gt));
+    // console.log(JSON.stringify(data.ot));
+    if (gpi < gl.length && opi < ol.length) {
+        const gList = gl.slice(gpi);
+        const oList = ol.slice(opi);
+        mergeList(gList, oList);
+    }
+
+    // console.log(gl);
+    return gl;
+};
+
+const getAlignPosition = (gt, gp, ot, direction) => {
+
+    // generatedText: '"false";\n',
+    // originalText: "'false';\r\n    ",
+    // generatedPos: 7
+
+    // left matched
+
+    // originalText: '1;',
+    // 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 item = list[gp];
+    if (item && item.original) {
+        return {
+            pos: item.original.index
+        };
+    }
+
+    // inclusive, for end only
+    if (gp && direction === 'end') {
+        const prev = list[gp - 1];
+        if (prev && prev.original && prev.wordEnd) {
+            // console.log(direction, '=====================================================================');
+            const op = prev.original.index + 1;
+            // console.log(gp, JSON.stringify(gt));
+            // console.log(op, JSON.stringify(ot));
+
+            return {
+                pos: op
+            };
+
+        }
+    }
+
+};
+
+// ========================================================================================================
+
 const getBlockStartPosition = (originalLineText) => {
     // originalText: 'argument) {',
     // generatedLeft: 'o',
@@ -117,82 +245,56 @@ const getBlockEndPosition = (originalLineText) => {
 
 };
 
+// ========================================================================================================
+
 const getComparedPosition = (info, direction) => {
 
-    let gt = info.generatedText;
+    const gt = info.generatedText;
     const gp = info.generatedPos;
-    let ot = info.originalText;
-
-    // before trim
-    const oLen = ot.length;
-
-    gt = gt.trimEnd();
-    ot = ot.trimEnd();
-
-    // no content after trim
-    if (!ot.length) {
-        return {
-            pos: direction === 'start' ? oLen : 0
-        };
-    }
+    const ot = info.originalText;
 
-    // same content
-    if (gt === ot) {
+    // whole generated text
+    if (gp >= gt.length) {
+        // console.log(JSON.stringify(gt), gt.length, gp);
+        // console.log(JSON.stringify(ot));
         return {
-            pos: gp
+            pos: info.originalLineText.length
         };
     }
 
     // =============================
+    // trim right
+    const gtt = gt.trimEnd();
+    const ott = ot.trimEnd();
 
-    // generatedText: '"false";\n',
-    // originalText: "'false';\r\n    ",
-    // generatedPos: 7
-
-    // length not change, replace " to '
-    gt = gt.replace(/"/g, "'");
-    ot = ot.replace(/"/g, "'");
-
-
-    // same content too
-    if (gt === ot) {
+    // no original content after trim
+    if (!ott) {
         return {
-            pos: gp
+            pos: direction === 'start' ? ot.length : 0
         };
     }
 
-    // ============================
-    // left matched
-
-    // originalText: '1;',
-    // 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',
+    // no generated content after trim
+    if (!gtt) {
+        return;
+    }
 
-    const left = gt.slice(0, gp);
-    if (ot.startsWith(left)) {
+    // same content
+    if (gtt === ott) {
         return {
             pos: gp
         };
     }
 
-    // ============================
-    // right matched
-    // only for original first line text
+    // =============================
 
-    const olt = info.originalLineText;
-    const right = gt.slice(gp);
-    if (olt.endsWith(right)) {
-        return {
-            pos: olt.length - right.length
-        };
-    }
+    return getAlignPosition(gt, gp, ot, direction);
 
 };
 
-const initOriginalLineText = (info) => {
+
+const getSimilarPosition = (info, direction) => {
+
     const originalText = info.originalText;
     // never cross line, using first line of original text
     // trim end remove \r\n and \n
@@ -200,44 +302,27 @@ const initOriginalLineText = (info) => {
     if (originalLines.length === 1) {
         // already single line
         info.originalLineText = originalText.trimEnd();
-        info.originalSingle = true;
-        return;
+    } else {
+        // multiple liens
+        info.originalLineText = originalLines[0].trimEnd();
     }
-    // multiple liens
-    info.originalLineText = originalLines[0].trimEnd();
-};
 
-const getSimilarPosition = (info, direction) => {
-
-    initOriginalLineText(info);
+    // no need comparison for fake source
+    if (info.fake) {
+        return;
+    }
 
     const textPos = getComparedPosition(info, direction);
     if (textPos) {
         return textPos;
     }
 
-    if (info.originalSingle) {
-        return;
-    }
-
-    // multiple lines
-    const { generatedPos, originalLineText } = info;
-    // generatedPos not in first line
-    if (generatedPos > originalLineText.length) {
-        return;
-    }
-
-    const linePos = getComparedPosition(info, direction);
-    if (linePos) {
-        return linePos;
-    }
-
     // console.log('====================================================================');
-    // console.log(`${EC.magenta(direction)} similar position can NOT be fixed`);
+    // console.log(`${EC.magenta(direction)} similar position can NOT be fixed`, info.originalState.sourcePath);
     // console.log({
-    //     sourcePath: info.originalState.sourcePath,
-    //     generatedText,
-    //     generatedPos,
+    //     direction,
+    //     generatedText: info.generatedText,
+    //     generatedPos: info.generatedPos,
     //     originalText
     // });
 
@@ -273,16 +358,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 +384,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 +404,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 +470,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) {
@@ -397,11 +482,13 @@ 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 direction = 'start';
 
     const info = {
+        fake: state.fake,
         generatedText,
         generatedPos,
         originalText,
@@ -426,14 +513,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,36 +535,13 @@ 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 direction = 'end';
 
     const info = {
+        fake: state.fake,
         offset: end,
         generatedText,
         generatedPos,
@@ -506,23 +570,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 +634,6 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
                 sourceIndex: s1
             };
         }
-        return {
-            error: true
-        };
     };
 
     const checkIndex21 = (s1, s2, e1) => {
@@ -553,9 +648,6 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
                 sourceIndex: e1
             };
         }
-        return {
-            error: true
-        };
     };
 
     const checkIndex12 = (s1, e1, e2) => {
@@ -570,9 +662,6 @@ const checkSourceFileIndexes = (startIndexes, endIndexes) => {
                 sourceIndex: s1
             };
         }
-        return {
-            error: true
-        };
     };
 
     const checkIndex22 = (s1, s2, e1, e2) => {
@@ -602,10 +691,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 +711,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 +733,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 +747,17 @@ const getOriginalState = (startMappings, endMappings, originalMap) => {
         };
     }
 
+    // cache for original info
     return {
         // for debug
         // startIndexes,
         // endIndexes,
 
+        start,
+        end,
+        startMappings,
+        endMappings,
+
         sourceIndex,
         crossStart,
         crossEnd,
@@ -667,7 +765,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 +777,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 +785,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 +794,7 @@ const getMappingInfo = (decodedMappings, start, end) => {
         };
     }
 
+    // could be 4 mappings found
     return {
         startMappings,
         endMappings
@@ -704,7 +803,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 +815,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 +833,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,