feat: support monocart report

README.md

@@ -43,6 +43,7 @@ Here is a list of common options. Run `c8 --help` for the full list and document
 | `--per-file` | check thresholds per file | `boolean` | `false` |
 | `--temp-directory` | directory V8 coverage data is written to and read from | `string` | `process.env.NODE_V8_COVERAGE` |
 | `--clean` | should temp files be deleted before script execution | `boolean` | `true` |
+| `--experimental-monocart` | see [section below](#using-monocart-coverage-reports-experimental) for more info | `boolean` | `false` |
 
 ## Checking for "full" source coverage using `--all`
 
@@ -119,6 +120,17 @@ The `--100` flag can be set for the `check-coverage` as well:
 c8 check-coverage --100
 ```
 
+## Using Monocart coverage reports (experimental)
+Monocart will bring additional support for native V8 coverage reports, for example:
+```sh
+c8 --experimental-monocart --reporter=v8 --reporter=console-details node foo.js
+```
+There are some differences as follows:
+- `c8` uses `v8-to-istanbul` by default to convert V8 coverage data and generate Istanbul reports.
+- `c8 --experimental-monocart` will use Monocart's new converter to convert V8 coverage data and generate Istanbul reports, it could provide better data for reports. Moreover, it can also directly generate V8 coverage reports (based on Bytes), such as available reports: `v8`, `console-details`, etc.
+
+See [monocart-coverage-reports](https://github.com/cenfun/monocart-coverage-reports) for more info.
+
 ## Ignoring Uncovered Lines, Functions, and Blocks
 
 Sometimes you might find yourself wanting to ignore uncovered portions of your

lib/commands/report.js

@@ -36,7 +36,8 @@ exports.outputReport = async function (argv) {
     src: argv.src,
     skipFull: argv.skipFull,
     excludeNodeModules: argv.excludeNodeModules,
-    mergeAsync: argv.mergeAsync
+    mergeAsync: argv.mergeAsync,
+    monocartArgv: (argv.experimentalMonocart || process.env.EXPERIMENTAL_MONOCART) ? argv : null
   })
   await report.run()
   if (argv.checkCoverage) await checkCoverages(argv, report)

lib/parse-args.js

@@ -158,6 +158,11 @@ function buildYargs (withCommands = false) {
       describe: 'supplying --merge-async will merge all v8 coverage reports asynchronously and incrementally. ' +
         'This is to avoid OOM issues with Node.js runtime.'
     })
+    .option('experimental-monocart', {
+      default: false,
+      type: 'boolean',
+      describe: 'Using Monocart coverage reports'
+    })
     .pkgConf('c8')
     .demandCommand(1)
     .check((argv) => {

lib/report.js

@@ -16,6 +16,7 @@ const getSourceMapFromFile = require('./source-map-from-file')
 const v8toIstanbul = require('v8-to-istanbul')
 const util = require('util')
 const debuglog = util.debuglog('c8')
+const { CoverageReport } = require('monocart-coverage-reports')
 
 class Report {
   constructor ({
@@ -36,7 +37,8 @@ class Report {
     allowExternal = false,
     skipFull,
     excludeNodeModules,
-    mergeAsync
+    mergeAsync,
+    monocartArgv
   }) {
     this.reporter = reporter
     this.reporterOptions = reporterOptions || {}
@@ -60,6 +62,7 @@ class Report {
     this.src = this._getSrc(src)
     this.skipFull = skipFull
     this.mergeAsync = mergeAsync
+    this.monocartArgv = monocartArgv
   }
 
   _getSrc (src) {
@@ -73,6 +76,9 @@ class Report {
   }
 
   async run () {
+    if (this.monocartArgv) {
+      return this.runMonocart()
+    }
     const context = libReport.createContext({
       dir: this.reportsDirectory,
       watermarks: this.watermarks,
@@ -89,6 +95,128 @@ class Report {
     }
   }
 
+  async runMonocart () {
+    const argv = this.monocartArgv
+    const exclude = this.exclude
+
+    function getEntryFilter () {
+      if (argv.entryFilter) {
+        return argv.entryFilter
+      }
+      if (argv.filter) {
+        return argv.filter
+      }
+      return (entry) => {
+        return exclude.shouldInstrument(fileURLToPath(entry.url))
+      }
+    }
+
+    function getSourceFilter () {
+      if (argv.sourceFilter) {
+        return argv.sourceFilter
+      }
+      if (argv.filter) {
+        return argv.filter
+      }
+      return (sourcePath) => {
+        if (argv.excludeAfterRemap) {
+          // console.log(sourcePath)
+          return exclude.shouldInstrument(sourcePath)
+        }
+        return true
+      }
+    }
+
+    function getReports () {
+      const reports = Array.isArray(argv.reporter) ? argv.reporter : [argv.reporter]
+      const reporterOptions = argv.reporterOptions || {}
+
+      return reports.map((reportName) => {
+        const reportOptions = {
+          ...reporterOptions[reportName]
+        }
+        if (reportName === 'text') {
+          reportOptions.skipEmpty = false
+          reportOptions.skipFull = argv.skipFull
+          reportOptions.maxCols = process.stdout.columns || 100
+        }
+        return [reportName, reportOptions]
+      })
+    }
+
+    // --all: add empty coverage for all files
+    function getAllOptions () {
+      if (!argv.all) {
+        return
+      }
+
+      const src = argv.src
+      const workingDirs = Array.isArray(src) ? src : (typeof src === 'string' ? [src] : [process.cwd()])
+      return {
+        dir: workingDirs,
+        filter: (filePath) => {
+          return exclude.shouldInstrument(filePath)
+        }
+      }
+    }
+
+    function initPct (summary) {
+      Object.keys(summary).forEach(k => {
+        if (summary[k].pct === '') {
+          summary[k].pct = 100
+        }
+      })
+      return summary
+    }
+
+    // adapt coverage options
+    const coverageOptions = {
+      logging: argv.logging,
+      name: argv.name,
+      inline: argv.inline,
+      lcov: argv.lcov,
+      outputDir: argv.reportsDir,
+      clean: argv.clean,
+
+      reports: getReports(),
+      all: getAllOptions(),
+
+      // use default value for istanbul
+      defaultSummarizer: 'pkg',
+
+      entryFilter: getEntryFilter(),
+      sourceFilter: getSourceFilter(),
+
+      onEnd: (coverageResults) => {
+        // for check coverage
+        this._allCoverageFiles = {
+          files: () => {
+            return coverageResults.files.map(it => it.sourcePath)
+          },
+          fileCoverageFor: (file) => {
+            const fileCoverage = coverageResults.files.find(it => it.sourcePath === file)
+            return {
+              toSummary: () => {
+                return initPct(fileCoverage.summary)
+              }
+            }
+          },
+          getCoverageSummary: () => {
+            return initPct(coverageResults.summary)
+          }
+        }
+      }
+    }
+    const coverageReport = new CoverageReport(coverageOptions)
+    coverageReport.cleanCache()
+
+    // read v8 coverage data from tempDirectory
+    await coverageReport.addFromDir(argv.tempDirectory)
+
+    // generate report
+    await coverageReport.generate()
+  }
+
   async getCoverageMapFromAllCoverageFiles () {
     // the merge process can be very expensive, and it's often the case that
     // check-coverage is called immediately after a report. We memoize the