monocart-coverage-reports 2.6.0 → 2.6.1

package/README.md

@@ -39,6 +39,7 @@
     - [Vitest](#vitest)
     - [CodeceptJS](#codeceptjs)
     - [WebdriverIO](#webdriverio)
+    - [Storybook Test Runner](#storybook-test-runner)
     - [Codecov](#codecov)
     - [Coveralls](#coveralls)
     - [Sonar Cloud](#sonar-cloud)
@@ -723,6 +724,9 @@ When `logging` is `debug`, the raw report data will be preserved in `[outputDir]
 ### [WebdriverIO](https://github.com/webdriverio/webdriverio)
 - [wdio-monocart-service](https://github.com/cenfun/wdio-monocart-service) - A WebdriverIO service for coverage reports
 
+### [Storybook Test Runner](https://github.com/storybookjs/test-runner)
+- [storybook-monocart-coverage](https://github.com/cenfun/storybook-monocart-coverage) - Storybook V8 Coverage Example
+
 ### [Codecov](https://codecov.com/)
 [![codecov](https://codecov.io/gh/cenfun/monocart-coverage-reports/graph/badge.svg?token=H0LW7UKYU3)](https://codecov.io/gh/cenfun/monocart-coverage-reports)
 - Supports native `codecov` built-in report ([specification](https://docs.codecov.com/docs/codecov-custom-coverage-format))

package/lib/cli.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const EC = require('eight-colors');
 const { fileURLToPath, pathToFileURL } = require('url');
+
 const {
     foregroundChild,
     program
@@ -98,6 +99,71 @@ const initOptions = async (cliOptions) => {
     return options;
 };
 
+const resolveEntrySource = (entry, sourceMapCache = {}) => {
+    let source;
+    const filePath = fileURLToPath(entry.url);
+    const extname = path.extname(filePath);
+    if (fs.existsSync(filePath)) {
+        source = fs.readFileSync(filePath).toString('utf8');
+    }
+
+    // not for typescript
+    if (source && !['.ts', '.tsx'].includes(extname)) {
+        entry.source = source;
+        return;
+    }
+
+    const sourcemapData = sourceMapCache[entry.url];
+    const lineLengths = sourcemapData && sourcemapData.lineLengths;
+
+    // for fake source file (can not parse to AST)
+    if (lineLengths) {
+        // get runtime code with ts-node
+        let fakeSource = '';
+        sourcemapData.lineLengths.forEach((length) => {
+            fakeSource += `${''.padEnd(length, '*')}\n`;
+        });
+        entry.fake = true;
+        entry.source = fakeSource;
+    }
+
+    // Note: no runtime code in source map cache
+    // This is a problem for typescript
+
+};
+
+const resolveEntrySourceMap = (entry, sourceMapCache = {}) => {
+    // sourcemap data
+    const sourcemapData = sourceMapCache[entry.url];
+    if (sourcemapData) {
+        if (sourcemapData.data) {
+            entry.sourceMap = resolveSourceMap(sourcemapData.data, entry.url);
+        }
+    }
+};
+
+const collectCoverageData = (coverageList, entryFilterHandler, sourceMapCache = {}) => {
+
+    if (!Util.isList(coverageList)) {
+        return;
+    }
+
+    // filter node internal files
+    coverageList = coverageList.filter((entry) => entry.url && entry.url.startsWith('file:'));
+    coverageList = coverageList.filter(entryFilterHandler);
+
+    if (!Util.isList(coverageList)) {
+        return;
+    }
+
+    for (const entry of coverageList) {
+        resolveEntrySource(entry, sourceMapCache);
+        resolveEntrySourceMap(entry, sourceMapCache);
+    }
+
+    return coverageList;
+};
+
 const executeCommand = async (command, cliOptions) => {
 
     const options = await initOptions(cliOptions);
@@ -130,49 +196,18 @@ const executeCommand = async (command, cliOptions) => {
             return 1;
         }
 
+        const entryFilterHandler = coverageReport.getEntryFilter();
+
         const files = fs.readdirSync(nodeV8CoverageDir);
         for (const filename of files) {
             const content = fs.readFileSync(path.resolve(nodeV8CoverageDir, filename)).toString('utf-8');
             const json = JSON.parse(content);
-            let coverageList = json.result;
-
-            // for node sourcemap
-            const sourceMapCache = json['source-map-cache'] || {};
-
-            // filter node internal files
-            coverageList = coverageList.filter((entry) => entry.url && entry.url.startsWith('file:'));
-
-            if (!coverageList.length) {
-                continue;
+            const coverageList = json.result;
+            const sourceMapCache = json['source-map-cache'];
+            const coverageData = await collectCoverageData(coverageList, entryFilterHandler, sourceMapCache);
+            if (coverageData) {
+                await coverageReport.add(coverageData);
             }
-            // attached source content
-            coverageList.forEach((entry) => {
-                // source content
-                const filePath = fileURLToPath(entry.url);
-                if (fs.existsSync(filePath)) {
-                    entry.source = fs.readFileSync(filePath).toString('utf8');
-                }
-
-                // sourcemap data
-                const sourcemapData = sourceMapCache[entry.url];
-                if (sourcemapData) {
-                    if (sourcemapData.data) {
-                        entry.sourceMap = resolveSourceMap(sourcemapData.data, entry.url);
-                    }
-                    // sourcemapData.lineLengths just for fake source file (can not parse to AST)
-                    if (!entry.source && sourcemapData.lineLengths) {
-                        // get runtime code with ts-node
-                        let source = '';
-                        sourcemapData.lineLengths.forEach((length) => {
-                            source += `${''.padEnd(length, '*')}\n`;
-                        });
-                        entry.fake = true;
-                        entry.source = source;
-                    }
-                }
-            });
-
-            await coverageReport.add(coverageList);
         }
 
         await coverageReport.generate();

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

@@ -135,8 +135,8 @@ const collectSourceMaps = async (v8list, options) => {
 
         // save source and sourceMap to separated json file
         const sourceData = {
-            url,
             id,
+            url,
             source,
             sourceMap
         };

package/lib/index.js

@@ -3,7 +3,7 @@ const path = require('path');
 const defaultOptions = require('./default/options.js');
 const Util = require('./utils/util.js');
 
-const { initV8ListAndSourcemap } = require('./v8/v8.js');
+const { initV8ListAndSourcemap, getEntryFilter } = require('./v8/v8.js');
 const { getInputData, generateCoverageReports } = require('./generate.js');
 const { getSnapshot, diffSnapshot } = require('./utils/snapshot.js');
 
@@ -63,12 +63,12 @@ class CoverageReport {
         const dataPath = path.resolve(this.options.cacheDir, dataName);
 
         const results = {
-            id: dataId,
-            path: dataPath
+            id: dataId
         };
 
         if (Array.isArray(data)) {
             results.type = 'v8';
+            // could be empty list after entryFilter
             results.data = await initV8ListAndSourcemap(data, this.options);
         } else {
             results.type = 'istanbul';
@@ -170,6 +170,10 @@ class CoverageReport {
         return false;
     }
 
+    getEntryFilter() {
+        return getEntryFilter(this.options);
+    }
+
 }
 
 /** create coverage report */

package/lib/v8/v8.js

@@ -395,5 +395,6 @@ const saveV8Report = async (v8list, options) => {
 module.exports = {
     initV8ListAndSourcemap,
     mergeV8Coverage,
-    saveV8Report
+    saveV8Report,
+    getEntryFilter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-coverage-reports",
-    "version": "2.6.0",
+    "version": "2.6.1",
     "description": "Monocart coverage reports",
     "main": "./lib/index.js",
     "bin": {