monocart-reporter 1.6.33 → 1.6.35

package/lib/plugins/coverage/istanbul/istanbul.js

@@ -14,18 +14,31 @@ const {
     convertSourceMap
 } = require('../../../runtime/monocart-coverage.js');
 
+const { initSourceMapRootAndUrl } = require('../coverage-utils.js');
+
 // const V8toIstanbul = require('v8-to-istanbul');
 // const istanbulLibCoverage = require('istanbul-lib-coverage');
 // const istanbulLibReport = require('istanbul-lib-report');
 
-const {
-    getSourcePath, mergeSourceRoot, collectSourceMaps
-} = require('../coverage-utils.js');
+const saveIstanbulReport = (coverageData, fileSources, options) => {
 
+    // source path handler
+    let data = coverageData;
+    if (typeof options.sourcePath === 'function') {
+        data = {};
+        Object.keys(coverageData).forEach((sourcePath) => {
+            const d = coverageData[sourcePath];
+            const newSourcePath = options.sourcePath(sourcePath, fileSources);
+            if (newSourcePath) {
+                sourcePath = newSourcePath;
+            }
+            d.path = sourcePath;
+            data[sourcePath] = d;
+        });
+    }
 
-const saveIstanbulReport = (coverageData, fileSources, options) => {
 
-    const coverageMap = istanbulLibCoverage.createCoverageMap(coverageData);
+    const coverageMap = istanbulLibCoverage.createCoverageMap(data);
 
     // https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-lib-report
     const contextOptions = {
@@ -99,46 +112,15 @@ const saveIstanbulReport = (coverageData, fileSources, options) => {
 
 // ===================================================================================================
 
-const initIstanbulV8List = async (v8list, options) => {
-
-    // filter list
-    const entryFilter = options.entryFilter;
-    if (typeof entryFilter === 'function') {
-        v8list = v8list.filter(entryFilter);
-    }
-
-    // only js with source (without css)
-    v8list = v8list.filter((item) => {
-        if (typeof item.source === 'string' && item.functions) {
-            return true;
-        }
-    });
-
-    // collect source maps
-    if (options.unpackSourceMap) {
-        await collectSourceMaps(v8list);
-    }
-
-    // init list properties
-    v8list.forEach((item, i) => {
-        const sourcePath = getSourcePath(item.url, i + 1, 'js');
-        const filename = path.basename(sourcePath);
-        item.filename = filename;
-        item.sourcePath = sourcePath;
-        // console.log(sourcePath);
-    });
-
-    return v8list;
-};
-
 const getConversionSources = (item, fileSources) => {
+
     const { source, sourceMap } = item;
 
     fileSources[item.sourcePath] = source;
 
     const sources = {
         //  remove map file
-        source: convertSourceMap.removeMapFileComments(source)
+        source: convertSourceMap.removeComments(source)
     };
 
     if (!sourceMap) {
@@ -151,17 +133,8 @@ const getConversionSources = (item, fileSources) => {
     // 'webpack://monocart-v8/external umd "monocart-code-viewer"'
     // format the url to sourcePath
 
-    // reset sourceRoot
-    const sourceRoot = sourceMap.sourceRoot || '';
-    sourceMap.sourceRoot = '';
-
-    // resolve source path and add to file sources cache for html report sourceFinder
-    sourceMap.sources = sourceMap.sources.map((sourceName, i) => {
-        const sourceUrl = mergeSourceRoot(sourceRoot, sourceName);
-        const newSourceName = getSourcePath(sourceUrl, i + 1);
-        fileSources[newSourceName] = sourceMap.sourcesContent[i];
-        return newSourceName;
-    });
+    const fileUrls = {};
+    initSourceMapRootAndUrl(sourceMap, fileUrls, fileSources);
 
     // console.log(sourceMap.sources);
 
@@ -177,7 +150,8 @@ const convertV8ToIstanbul = async (v8list, options) => {
 
     // console.log('v8list before', v8list.map((it) => it.url));
 
-    v8list = await initIstanbulV8List(v8list, options);
+    // only js with source (without css)
+    v8list = v8list.filter((item) => item.type === 'js');
 
     // console.log('v8list after', v8list.map((it) => it.url));
     // console.log('has map', v8list.filter((it) => it.sourceMap));
@@ -226,7 +200,7 @@ const convertV8ToIstanbul = async (v8list, options) => {
 
     const coverageData = coverageMap.toJSON();
 
-    // console.log('convertV8ToIstanbul coverageData', Object.keys(coverageData));
+    // console.log('coverageData', Object.keys(coverageData));
 
     return {
         coverageData,

package/lib/plugins/coverage/v8/dedupe.js

@@ -71,35 +71,26 @@ const dedupeCountRanges = (ranges) => {
 
     sortRanges(ranges);
 
+    let hasDedupe = false;
+
     // merge count for same range
     ranges.reduce((lastRange, range) => {
         if (range.start === lastRange.start && range.end === lastRange.end) {
             range.dedupe = true;
             lastRange.count += range.count;
+
+            hasDedupe = true;
+
             return lastRange;
         }
         return range;
     });
 
-    ranges = ranges.filter((it) => !it.dedupe);
-
-    // console.log('ranges length before', ranges.length);
-
-    // connect uncovered ranges (count = 0)
-    const coveredRanges = [];
-    const uncoveredRanges = [];
-    for (const range of ranges) {
-        if (range.count > 0) {
-            coveredRanges.push(range);
-        } else {
-            uncoveredRanges.push(range);
-        }
+    if (hasDedupe) {
+        // console.log(ranges);
+        ranges = ranges.filter((it) => !it.dedupe);
     }
 
-    ranges = [].concat(dedupeRanges(uncoveredRanges)).concat(coveredRanges);
-
-    sortRanges(ranges);
-
     // console.log('ranges length after', ranges.length);
 
     return ranges;

package/lib/plugins/coverage/v8/source-map.js

@@ -1,12 +1,16 @@
+const fs = require('fs');
+const path = require('path');
 const EC = require('eight-colors');
 
 const { SourceMapConsumer } = require('source-map');
 
 const PositionMapping = require('./position-mapping.js');
 const { dedupeCountRanges } = require('./dedupe.js');
-const {
-    getSourcePath, mergeSourceRoot, collectSourceMaps
-} = require('../coverage-utils.js');
+const { initSourceMapRootAndUrl } = require('../coverage-utils.js');
+
+const Concurrency = require('../../../platform/concurrency.js');
+const { convertSourceMap, axios } = require('../../../runtime/monocart-coverage.js');
+const Util = require('../../../utils/util.js');
 
 // SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
 // SourceMapConsumer.LEAST_UPPER_BOUND = 2;
@@ -134,6 +138,7 @@ const addOriginalRange = (originalMapping, start, end, count) => {
 
 // =========================================================================================================
 
+
 const unpackJsSourceMap = async (item, v8list, options) => {
     // console.log('------------------------------------------------------');
     // console.log(item.type, item.url);
@@ -141,17 +146,9 @@ const unpackJsSourceMap = async (item, v8list, options) => {
 
     const sourceMap = item.sourceMap;
 
-    // reset sourceRoot
-    const sourceRoot = sourceMap.sourceRoot || '';
-    sourceMap.sourceRoot = '';
-
-    const urlMap = {};
-    sourceMap.sources = sourceMap.sources.map((sourceName, i) => {
-        const sourceUrl = mergeSourceRoot(sourceRoot, sourceName);
-        const newSourceName = getSourcePath(sourceUrl, i + 1);
-        urlMap[newSourceName] = sourceUrl;
-        return newSourceName;
-    });
+    const fileUrls = {};
+    const fileSources = {};
+    initSourceMapRootAndUrl(sourceMap, fileUrls, fileSources);
 
     const generatedMapping = new PositionMapping(item.source);
     const consumer = await new SourceMapConsumer(sourceMap);
@@ -216,18 +213,34 @@ const unpackJsSourceMap = async (item, v8list, options) => {
     // append to v8list
     originalMappings.forEach((originalMapping, currentSource) => {
 
-        const url = urlMap[currentSource] || currentSource;
+        const url = fileUrls[currentSource] || currentSource;
         const ranges = dedupeCountRanges(originalMapping.ranges);
 
         //  console.log('add source url', url);
 
+        // original source and id
+        const source = originalMapping.source;
+        const id = Util.calculateSha1(url + source);
+
+        let ext = path.extname(currentSource);
+        let type = '';
+        if (ext) {
+            ext = ext.slice(1);
+            const reg = /^[a-z0-9]+$/;
+            if (reg.test(ext)) {
+                type = ext;
+            }
+        }
+
+
         v8list.push({
             url,
-            type: item.type,
+            id,
+            type,
             sourcePath: currentSource,
             distFile: item.sourceMap.file,
             ranges,
-            source: originalMapping.source
+            source
         });
 
     });
@@ -235,6 +248,160 @@ const unpackJsSourceMap = async (item, v8list, options) => {
 
 // =========================================================================================================
 
+const request = async (options) => {
+    if (typeof options === 'string') {
+        options = {
+            url: options
+        };
+    }
+    let err;
+    const res = await axios(options).catch((e) => {
+        err = e;
+    });
+    return [err, res];
+};
+
+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];
+
+    let mapUrl;
+
+    try {
+        mapUrl = new URL(filename, url);
+    } catch (e) {
+        // console.log(e)
+    }
+    if (mapUrl) {
+        return mapUrl.toString();
+    }
+};
+
+const resolveSourceMap = (data) => {
+    if (data) {
+        const { sources, sourcesContent } = data;
+        if (!sources || !sourcesContent) {
+            return;
+        }
+        return data;
+    }
+};
+
+const collectInlineSourceMaps = async (v8list) => {
+    const concurrency = new Concurrency();
+    for (const item of v8list) {
+
+        const { type, source } = item;
+
+        // only for js
+        if (type === 'js') {
+            const converter = convertSourceMap.fromSource(source);
+            if (converter) {
+                item.sourceMap = resolveSourceMap(converter.sourcemap);
+                continue;
+            }
+            const sourceMapUrl = getSourceMapUrl(source, item.url);
+            if (sourceMapUrl) {
+                item.sourceMapUrl = sourceMapUrl;
+                concurrency.addItem(item);
+            }
+        }
+    }
+    await concurrency.start(async (item) => {
+        const [err, res] = await request({
+            url: item.sourceMapUrl
+        });
+        if (!err && res) {
+            item.sourceMap = resolveSourceMap(res.data);
+        }
+    });
+};
+
+const collectFileSourceMaps = async (v8list, options) => {
+    const concurrency = new Concurrency();
+    for (const item of v8list) {
+
+        const {
+            type, url, source, id
+        } = item;
+
+        // remove source just keep functions to reduce artifacts size
+        delete item.source;
+
+        const sourcePath = Util.resolveArtifactSourcePath(options.artifactsDir, id);
+        if (fs.existsSync(sourcePath)) {
+            continue;
+        }
+
+        const sourceData = {
+            url,
+            id,
+            source: convertSourceMap.removeComments(source)
+        };
+
+        // only for js
+        if (type === 'js') {
+            const converter = convertSourceMap.fromSource(source);
+            if (converter) {
+                sourceData.sourceMap = resolveSourceMap(converter.sourcemap);
+                await saveSourceFile(sourcePath, sourceData);
+                continue;
+            }
+            const sourceMapUrl = getSourceMapUrl(source, item.url);
+            if (sourceMapUrl) {
+                concurrency.addItem({
+                    sourceMapUrl,
+                    sourcePath,
+                    sourceData
+                });
+                continue;
+            }
+        }
+
+        await saveSourceFile(sourcePath, sourceData);
+
+    }
+
+    await concurrency.start(async (item) => {
+        const [err, res] = await request({
+            url: item.sourceMapUrl
+        });
+        const sourceData = item.sourceData;
+        if (!err && res) {
+            sourceData.sourceMap = resolveSourceMap(res.data);
+        }
+        await saveSourceFile(item.sourcePath, sourceData);
+    });
+};
+
+const saveSourceFile = async (filePath, data) => {
+    await Util.writeFile(filePath, JSON.stringify(data));
+};
+
+const collectSourceMaps = async (v8list, options, inlineSourceMap) => {
+
+    if (!options.unpackSourceMap) {
+        return;
+    }
+
+    if (inlineSourceMap) {
+        await collectInlineSourceMaps(v8list);
+        return;
+    }
+
+    await collectFileSourceMaps(v8list, options);
+
+};
+
+// =========================================================================================================
 const filterSourceMapList = (v8list, options) => {
     const sourceMapList = [];
     const indexes = [];
@@ -262,16 +429,14 @@ const filterSourceMapList = (v8list, options) => {
     return sourceMapList;
 };
 
+// requires ranges before unpack
 const unpackSourceMaps = async (v8list, options) => {
 
+    // collect source maps
     if (!options.unpackSourceMap) {
         return;
     }
 
-    // console.log(v8list.map((it) => it.url).join(', '));
-
-    await collectSourceMaps(v8list);
-
     const sourceMapList = filterSourceMapList(v8list, options);
     if (!sourceMapList) {
         // nothing to unpack
@@ -288,5 +453,6 @@ const unpackSourceMaps = async (v8list, options) => {
 
 
 module.exports = {
+    collectSourceMaps,
     unpackSourceMaps
 };