monocart-coverage-reports 2.13.1 → 2.13.2

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

@@ -1,7 +1,6 @@
 const fs = require('fs');
 const path = require('path');
 const EC = require('eight-colors');
-const { CommentParser } = require('monocart-locator');
 const { fileURLToPath, pathToFileURL } = require('url');
 const Concurrency = require('../platform/concurrency.js');
 const { convertSourceMap } = require('../packages/monocart-coverage-vendor.js');
@@ -9,15 +8,72 @@ const { flattenSourceMaps } = require('./flatten-source-maps.js');
 
 const Util = require('../utils/util.js');
 
-const getSourceMapComments = (source) => {
+const getSourceMapCandidates = (source) => {
     if (!source.includes('sourceMappingURL=')) {
         return [];
     }
-    return new CommentParser(source).comments
-        .map((item) => item.text)
-        .filter((comment) => (/^\/[/*][@#][ \t]+sourceMappingURL=/).test(comment));
+
+    // Match directive-shaped text without parsing JS; valid maps in strings can be selected.
+    const candidates = [];
+    for (const match of source.matchAll(convertSourceMap.commentRegex)) {
+        candidates.push({
+            index: match.index,
+            comment: match[0],
+            inline: true
+        });
+    }
+    for (const match of source.matchAll(convertSourceMap.mapFileCommentRegex)) {
+        const filename = match[1] || match[2];
+        if (filename && !filename.startsWith('data:')) {
+            candidates.push({
+                index: match.index,
+                filename
+            });
+        }
+    }
+    // Like 2.13.0, try inline maps before external ones. Within each kind,
+    // start at the last directive and fall back when it is unusable.
+    return candidates.sort((a, b) => {
+        if (a.inline !== b.inline) {
+            return a.inline ? -1 : 1;
+        }
+        return b.index - a.index;
+    });
+};
+
+// Only check the fields required to resolve a map; decoding is deferred to
+// the downstream converter. A map without sources cannot map to original code.
+const isValidBasicMap = (data) => Array.isArray(data.sources)
+    && data.sources.every((source) => typeof source === 'string')
+    && typeof data.mappings === 'string'
+    && (data.sources.length > 0 || data.mappings === '');
+
+const isValidSection = (section) => section && section.offset
+    && Number.isInteger(section.offset.line) && section.offset.line >= 0
+    && Number.isInteger(section.offset.column) && section.offset.column >= 0
+    && isValidSourceMap(section.map);
+
+const isValidSourceMap = (data) => {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return false;
+    }
+    if (Array.isArray(data.sections)) {
+        return data.sections.every(isValidSection);
+    }
+    return isValidBasicMap(data);
+};
+
+// An empty map cannot map coverage to any original source. Try the next
+// candidate instead, including when an indexed map has only empty sections.
+const hasMappings = (data) => {
+    if (Array.isArray(data.sections)) {
+        return data.sections.some((section) => hasMappings(section.map));
+    }
+    return data.mappings.length > 0;
 };
 
+const isUsableSourceMap = (data) => isValidSourceMap(data) && hasMappings(data);
+
 const defaultSourceMapResolver = async (url = '') => {
 
     if (url.startsWith('file:')) {
@@ -63,24 +119,6 @@ const resolveMapUrl = (filename, url) => {
     return urlObj?.toString();
 };
 
-const getSourceMapUrl = (comments, url) => {
-    for (let i = comments.length - 1; i >= 0; i--) {
-        const r = convertSourceMap.mapFileCommentRegex.exec(comments[i]);
-        if (!r || r.index !== 0) {
-            continue;
-        }
-        // //# captures in 1 and /* */ in 2
-        const filename = r[1] || r[2];
-        if (!filename || filename.startsWith('data:')) {
-            continue;
-        }
-        const mapUrl = resolveMapUrl(filename, url);
-        if (mapUrl) {
-            return mapUrl;
-        }
-    }
-};
-
 const resolveSourcesContent = (data, url) => {
 
     const { sources, sourcesContent } = data;
@@ -125,7 +163,7 @@ const resolveSourcesContent = (data, url) => {
 const checkSourcesContent = (data) => {
     const { sourcesContent, sources } = data;
 
-    if (!sourcesContent) {
+    if (!Array.isArray(sourcesContent)) {
         data.sourcesContent = [];
         return false;
     }
@@ -146,15 +184,7 @@ const resolveSectionedSourceMap = (data, url, sections) => {
         // offset: { line: 1, column: 0 },
         // map: { sources, sourcesContent  }
 
-        const map = item.map;
-
-        if (checkSourcesContent(map)) {
-            hasSourceContent = true;
-            return;
-        }
-
-        const done = resolveSourcesContent(map, url);
-        if (done) {
+        if (resolveSourceMap(item.map, url)) {
             hasSourceContent = true;
         }
 
@@ -169,6 +199,10 @@ const resolveSourceMap = (data, url) => {
     if (!data) {
         return;
     }
+    // Optional metadata may be absent or malformed in otherwise usable maps.
+    if (!Array.isArray(data.names)) {
+        data.names = [];
+    }
     const {
         sections, sources, mappings
     } = data;
@@ -177,7 +211,7 @@ const resolveSourceMap = (data, url) => {
         return resolveSectionedSourceMap(data, url, sections);
     }
 
-    if (!sources || !mappings) {
+    if (!Array.isArray(sources) || typeof mappings !== 'string') {
         return;
     }
 
@@ -191,21 +225,6 @@ const resolveSourceMap = (data, url) => {
 
 };
 
-const getInlineSourceMap = (comments) => {
-    for (let i = comments.length - 1; i >= 0; i--) {
-        const comment = comments[i];
-        const match = convertSourceMap.commentRegex.exec(comment);
-        if (!match || match.index !== 0) {
-            continue;
-        }
-        try {
-            return convertSourceMap.fromComment(comment);
-        } catch (e) {
-            // Ignore invalid inline maps.
-        }
-    }
-};
-
 const collectSourceMaps = async (v8list, options) => {
 
     const sourceList = [];
@@ -237,52 +256,60 @@ const collectSourceMaps = async (v8list, options) => {
             sourceMap
         };
 
+        // An explicitly supplied, usable map takes precedence over sourceMappingURL.
         // Keep the original source so V8 offsets remain valid.
-        // check sourceMap only for js
-        if (type === 'js' && !sourceData.sourceMap) {
-            const comments = getSourceMapComments(source);
-            // from inline sync
-            const smc = getInlineSourceMap(comments);
-            if (smc) {
-                sourceData.sourceMap = resolveSourceMap(smc.sourcemap, url);
-                sourcemapList.push({
-                    url,
-                    inline: true
-                });
-                sourceList.push(sourceData);
-                continue;
-            }
-            // from url async
-            const sourceMapUrl = getSourceMapUrl(comments, url);
-            if (sourceMapUrl) {
+        if (type === 'js' && !isUsableSourceMap(sourceData.sourceMap)) {
+            delete sourceData.sourceMap;
+            const candidates = getSourceMapCandidates(source);
+            if (candidates.length) {
                 concurrency.addItem({
-                    sourceMapUrl,
+                    candidates,
                     sourceData
                 });
-                continue;
             }
         }
 
-        // no need check sourceMap
+        // Keep source entries in input order while maps load concurrently.
         sourceList.push(sourceData);
 
     }
 
-    // from url concurrency
     await concurrency.start(async (item) => {
-        const { sourceMapUrl, sourceData } = item;
+        const { candidates, sourceData } = item;
         const { url } = sourceData;
-        const data = await loadSourceMap(sourceMapUrl, options);
-        if (data) {
-            sourceData.sourceMap = resolveSourceMap(data, url);
-            sourcemapList.push({
-                url,
-                sourceMapUrl
-            });
+        for (const candidate of candidates) {
+            let data;
+            let sourceMapUrl;
+            try {
+                if (candidate.inline) {
+                    data = convertSourceMap.fromComment(candidate.comment).sourcemap;
+                } else {
+                    sourceMapUrl = resolveMapUrl(candidate.filename, url);
+                    if (!sourceMapUrl) {
+                        continue;
+                    }
+                    data = await loadSourceMap(sourceMapUrl, options);
+                }
+                if (!isUsableSourceMap(data)) {
+                    continue;
+                }
+                const sourceMap = resolveSourceMap(data, url);
+                if (!sourceMap) {
+                    continue;
+                }
+                sourceData.sourceMap = sourceMap;
+                sourcemapList.push(candidate.inline ? {
+                    url,
+                    inline: true
+                } : {
+                    url,
+                    sourceMapUrl
+                });
+                break;
+            } catch (e) {
+                // Try an earlier sourceMappingURL if parsing or loading fails.
+            }
         }
-
-        sourceList.push(sourceData);
-
     });
 
     return {

package/lib/converter/converter.js

@@ -906,6 +906,12 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
                 // console.log(segment);
                 return;
             }
+            // A malformed map may refer to a source outside its sources array.
+            // Check when mappings are already decoded, not during map selection.
+            const sourceMappings = originalDecodedMap.get(sourceIndex);
+            if (!sourceMappings) {
+                return;
+            }
 
             // 1-base
             const generatedSN = generatedLine + 1;
@@ -936,7 +942,7 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
             }
 
             allDecodedMappings.push(info);
-            originalDecodedMap.get(sourceIndex).push(info);
+            sourceMappings.push(info);
 
             // calculate line end column
             if (!info.last) {
@@ -971,7 +977,7 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
             // console.log(generatedSN, generatedColumn, info, endColumn);
 
             allDecodedMappings.push(endColumn);
-            originalDecodedMap.get(sourceIndex).push(endColumn);
+            sourceMappings.push(endColumn);
 
         });
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-coverage-reports",
-    "version": "2.13.1",
+    "version": "2.13.2",
     "description": "A code coverage tool to generate native V8 reports or Istanbul reports.",
     "main": "./lib/index.js",
     "bin": {