monocart-coverage-reports 2.13.0 → 2.13.2

package/README.md

@@ -671,7 +671,7 @@ const coverageOptions = {
 ```
 
 ## Adding Empty Coverage for Untested Files
-By default the untested files will not be included in the coverage report, we can add empty coverage for untested files with option `all`, the untested files will show 0% coverage.
+By default the untested files will not be included in the coverage report. Use `all` to include them with 0% coverage. This also works when no coverage data has been collected: a V8 report is generated from the matching untested files.
 ```js
 const coverageOptions = {
     all: './src',

package/README.zh-Hans.md

@@ -674,7 +674,7 @@ const coverageOptions = {
 ```
 
 ## Adding Empty Coverage for Untested Files
-默认，未测试的文件是不会包含到覆盖率报告的，需要使用`all`选项来为这些文件添加一个空的覆盖率，也就是0%
+默认，未测试的文件不会包含在覆盖率报告中。使用 `all` 选项可将它们以 0% 覆盖率加入报告。即使没有收集到任何覆盖率数据，也会为匹配的未测试文件生成 V8 报告。
 ```js
 const coverageOptions = {
     all: './src',

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

@@ -8,6 +8,72 @@ const { flattenSourceMaps } = require('./flatten-source-maps.js');
 
 const Util = require('../utils/util.js');
 
+const getSourceMapCandidates = (source) => {
+    if (!source.includes('sourceMappingURL=')) {
+        return [];
+    }
+
+    // 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:')) {
@@ -48,27 +114,9 @@ const loadSourceMap = async (url, options) => {
     return defaultSourceMapResolver(url);
 };
 
-const getSourceMapUrl = (content, url) => {
-
-    const m = content.match(convertSourceMap.mapFileCommentRegex);
-    if (!m) {
-        return;
-    }
-
-    const comment = m.pop();
-    const r = convertSourceMap.mapFileCommentRegex.exec(comment);
-    // for some odd reason //# .. captures in 1 and /* .. */ in 2
-    const filename = r[1] || r[2];
-
-    const urlObj = Util.resolveUrl(filename, url);
-    if (urlObj) {
-        return urlObj.toString();
-    }
-
-    const mapUrl = Util.resolveUrl(filename, pathToFileURL(url).toString());
-    if (mapUrl) {
-        return mapUrl.toString();
-    }
+const resolveMapUrl = (filename, url) => {
+    const urlObj = Util.resolveUrl(filename, url) || Util.resolveUrl(filename, pathToFileURL(url).toString());
+    return urlObj?.toString();
 };
 
 const resolveSourcesContent = (data, url) => {
@@ -115,7 +163,7 @@ const resolveSourcesContent = (data, url) => {
 const checkSourcesContent = (data) => {
     const { sourcesContent, sources } = data;
 
-    if (!sourcesContent) {
+    if (!Array.isArray(sourcesContent)) {
         data.sourcesContent = [];
         return false;
     }
@@ -136,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;
         }
 
@@ -159,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;
@@ -167,7 +211,7 @@ const resolveSourceMap = (data, url) => {
         return resolveSectionedSourceMap(data, url, sections);
     }
 
-    if (!sources || !mappings) {
+    if (!Array.isArray(sources) || typeof mappings !== 'string') {
         return;
     }
 
@@ -181,17 +225,6 @@ const resolveSourceMap = (data, url) => {
 
 };
 
-const getInlineSourceMap = (content) => {
-    let smc;
-    try {
-        smc = convertSourceMap.fromSource(content);
-    } catch (e) {
-        // ignore "//# sourceMappingURL=" in a string
-        // console.log(e);
-    }
-    return smc;
-};
-
 const collectSourceMaps = async (v8list, options) => {
 
     const sourceList = [];
@@ -223,55 +256,60 @@ const collectSourceMaps = async (v8list, options) => {
             sourceMap
         };
 
-        // remove comments if not debug
-        if (!Util.isDebug()) {
-            sourceData.source = convertSourceMap.removeComments(source);
-        }
-
-        // check sourceMap only for js
-        if (type === 'js' && !sourceData.sourceMap) {
-            // from inline sync
-            const smc = getInlineSourceMap(source);
-            if (smc) {
-                sourceData.sourceMap = resolveSourceMap(smc.sourcemap, url);
-                sourcemapList.push({
-                    url,
-                    inline: true
-                });
-                sourceList.push(sourceData);
-                continue;
-            }
-            // from url async
-            const sourceMapUrl = getSourceMapUrl(source, item.url);
-            if (sourceMapUrl) {
+        // An explicitly supplied, usable map takes precedence over sourceMappingURL.
+        // Keep the original source so V8 offsets remain valid.
+        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/lib/converter/untested.js

@@ -6,9 +6,6 @@ const { pathToFileURL, fileURLToPath } = require('url');
 
 const { normalizeSourcePath, getSourcePathReplacer } = require('../utils/source-path.js');
 
-// const EC = require('eight-colors');
-const { convertSourceMap } = require('../packages/monocart-coverage-vendor.js');
-
 // ========================================================================================================
 
 const resolveAllDirList = (input) => {
@@ -133,11 +130,6 @@ const saveUntestedFileSource = async (entryFile, options) => {
         sourceMap
     };
 
-    // remove comments if not debug
-    if (!Util.isDebug()) {
-        sourceData.source = convertSourceMap.removeComments(source);
-    }
-
     // console.log('save untested file', id, url);
 
     await Util.saveSourceCacheFile(sourceData, options);

package/lib/generate.js

@@ -321,9 +321,13 @@ const getInputData = async (mcr) => {
     }
 
     if (!dataList.length) {
-        const dirs = inputList.map((dir) => Util.relativePath(dir));
-        Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);
-        return;
+        if (!mcr.options.all) {
+            const dirs = inputList.map((dir) => Util.relativePath(dir));
+            Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);
+            return;
+        }
+        // No coverage input: use V8 so `all` can add untested files.
+        dataList.push({ type: 'v8', data: [] });
     }
 
     return {