monocart-coverage-reports 2.1.0 → 2.2.1

package/README.md

@@ -11,20 +11,22 @@
 * [Usage](#usage)
 * [Default Options](#default-options)
 * [Available Reports](#available-reports)
-* [Multiprocessing Support](#multiprocessing-support)
+* [Using `entryFilter` and `sourceFilter` to filter the results for V8 report](#using-entryfilter-and-sourcefilter-to-filter-the-results-for-v8-report)
 * [onEnd Hook](#onend-hook)
+* [`mcr` CLI](#mcr-cli)
 * [Compare Reports](#compare-reports)
 * [Compare Workflows](#compare-workflows)
 * [Collecting Istanbul Coverage Data](#collecting-istanbul-coverage-data)
 * [Collecting V8 Coverage Data](#collecting-v8-coverage-data)
 * [Node.js V8 Coverage Report for Server Side](#nodejs-v8-coverage-report-for-server-side)
-* [Using `entryFilter` and `sourceFilter` to filter the results for V8 report](#using-entryfilter-and-sourcefilter-to-filter-the-results-for-v8-report)
+* [Multiprocessing Support](#multiprocessing-support)
+* [Integration](#integration)
+* [Ignoring Uncovered Codes](#ignoring-uncovered-codes)
+* [Chromium Coverage API](#chromium-coverage-api)
+* [V8 Coverage Data Format](#v8-coverage-data-format)
 * [How to convert V8 to Istanbul](#how-to-convert-v8-to-istanbul)
     - [Using `v8-to-istanbul`](#using-v8-to-istanbul)
     - [How Monocart Works](#how-monocart-works)
-* [Ignoring Uncovered Lines](#ignoring-uncovered-lines)
-* [Chromium Coverage API](#chromium-coverage-api)
-* [V8 Coverage Data Format](#v8-coverage-data-format)
 * [Istanbul Introduction](#istanbul-introduction)
 * [Thanks](#thanks)
 
@@ -49,9 +51,14 @@ console.log(coverageResults.summary);
 
 ## Available Reports
 - `v8` (V8 data only)
-    - [V8 html](https://cenfun.github.io/monocart-coverage-reports/v8) - Example for browser, build with webpack, and also [Rollup](https://cenfun.github.io/monocart-coverage-reports/v8-rollup) and [Esbuild](https://cenfun.github.io/monocart-coverage-reports/v8-esbuild)
-    - [V8 Node](https://cenfun.github.io/monocart-coverage-reports/v8-node-env) - Example for Node.js using env, and also [V8 API](https://cenfun.github.io/monocart-coverage-reports/v8-node-api), [Inspector](https://cenfun.github.io/monocart-coverage-reports/v8-node-ins) and [CDP](https://cenfun.github.io/monocart-coverage-reports/v8-node-cdp)
-    - [V8 Minify](https://cenfun.github.io/monocart-coverage-reports/v8-minify)
+    - Test in browser
+        - Build with webpack: [V8](https://cenfun.github.io/monocart-coverage-reports/v8) and [V8 Minify](https://cenfun.github.io/monocart-coverage-reports/v8-minify)
+        - Build with [Rollup](https://cenfun.github.io/monocart-coverage-reports/v8-rollup) and [Esbuild](https://cenfun.github.io/monocart-coverage-reports/v8-esbuild)
+        - Collect with [puppeteer](https://cenfun.github.io/monocart-coverage-reports/puppeteer/) 
+        - [anonymous](https://cenfun.github.io/monocart-coverage-reports/anonymous/) and [css](https://cenfun.github.io/monocart-coverage-reports/css/)
+    - Test in Node.js
+        - Collect with [env](https://cenfun.github.io/monocart-coverage-reports/v8-node-env), and also V8 [API](https://cenfun.github.io/monocart-coverage-reports/v8-node-api), [Inspector](https://cenfun.github.io/monocart-coverage-reports/v8-node-ins) and [CDP](https://cenfun.github.io/monocart-coverage-reports/v8-node-cdp)
+        - Web server example: [koa](https://cenfun.github.io/monocart-coverage-reports/v8-node-koa/)
 
 ![](test/v8.gif)
 
@@ -100,37 +107,34 @@ const options = {
 const coverageReport = MCR(options);
 ```
 
-## Integration
-- [monocart-reporter](https://cenfun.github.io/monocart-reporter/) - Test reporter for [Playwright](https://github.com/microsoft/playwright)
-- [vitest-monocart-coverage](https://github.com/cenfun/vitest-monocart-coverage) - Integration with [Vitest](https://github.com/vitest-dev/vitest) coverage
-
-
-## Multiprocessing Support
-The data will be added to `[outputDir]/.cache`, and the cache will be removed after reports generated.
-- sub process 1
-```js
-const MCR = require('monocart-coverage-reports');
-const options = require('path-to/same-options.js');
-const coverageReport = MCR(options);
-await coverageReport.add(coverageData1);
+## Using `entryFilter` and `sourceFilter` to filter the results for V8 report
+When V8 coverage data collected, it actually contains the data of all entry files, for example:
 ```
-
-- sub process 2
-```js
-const MCR = require('monocart-coverage-reports');
-const options = require('path-to/same-options.js');
-const coverageReport = MCR(options);
-await coverageReport.add(coverageData2);
+dist/main.js
+dist/vendor.js
+dist/something-else.js
 ```
-
-- main process
+We can use `entryFilter` to filter the entry files. For example, we should remove `vendor.js` and `something-else.js` if they are not in our coverage scope. 
+```
+dist/main.js
+```
+When inline or linked sourcemap exists to the entry file, the source files will be extracted from the sourcemap for the entry file, and the entry file will be removed if `logging` is not `debug`.
+```
+> src/index.js
+> src/components/app.js
+> node_modules/dependency/dist/dependency.js
+```
+We can use `sourceFilter` to filter the source files. For example, we should remove `dependency.js` if it is not in our coverage scope.
+```
+> src/index.js
+> src/components/app.js
+```
+Example:
 ```js
-// after all sub processes finished
-const MCR = require('monocart-coverage-reports');
-const options = require('path-to/same-options.js');
-const coverageReport = MCR(options);
-const coverageResults = await coverageReport.generate();
-console.log(coverageResults.summary);
+const coverageOptions = {
+    entryFilter: (entry) => entry.url.indexOf("main.js") !== -1,
+    sourceFilter: (sourcePath) => sourcePath.search(/src\//) !== -1
+};
 ```
 
 ## onEnd Hook
@@ -164,6 +168,44 @@ const coverageOptions = {
 }
 ```
 
+## `mcr` CLI
+> The CLI will run the program as a [child process](https://nodejs.org/docs/latest/api/child_process.html) with `NODE_V8_COVERAGE=dir` until it exits gracefully, and generate the coverage report with the coverage data from the `dir`.
+- Global mode
+```sh
+npm i monocart-coverage-reports -g
+mcr "node ./test/test-node-env.js" -r v8,console-summary --lcov
+```
+- Current working directory mode
+```sh
+npm i monocart-coverage-reports
+npx mcr "node ./test/test-node-env.js" -r v8,console-summary --lcov
+```
+- CLI Options
+```sh
+Usage: mcr [options] <command>
+
+CLI to generate coverage reports
+
+Arguments:
+  command                      command to execute
+
+Options:
+  -V, --version                output the version number
+  -c, --config <path>          config path for options
+  -o, --outputDir <dir>        output dir for reports
+  -r, --reports <name[,name]>  coverage reports to use
+  -n, --name <name>            report name for title
+  --outputFile <path>          output file for v8 report
+  --inline                     inline html for v8 report
+  --assetsPath <path>          assets path if not inline
+  --lcov                       generate lcov.info file
+  -h, --help                   display help for command
+```
+- Using configuration file for more [options](#default-options)
+```sh
+mcr "node ./test/test-node-env.js" -c test/cli-options.js
+```
+
 ## Compare Reports
 | | Istanbul | V8 | V8 to Istanbul |
 | :--------------| :------ | :------ | :----------------------  |
@@ -192,133 +234,103 @@ const coverageOptions = {
 ## Collecting Istanbul Coverage Data
 - Instrumenting source code
     > Before collecting Istanbul coverage data, It requires your source code is instrumented with Istanbul
-    - Webpack: [babel-plugin-istanbul](https://github.com/istanbuljs/babel-plugin-istanbul), example: [webpack.config-istanbul.js](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/webpack.config-istanbul.js)
-    - Rollup: [rollup-plugin-istanbul](https://github.com/artberri/rollup-plugin-istanbul)
-    - Vite: [vite-plugin-istanbul](https://github.com/ifaxity/vite-plugin-istanbul)
+    - webpack: [babel-plugin-istanbul](https://github.com/istanbuljs/babel-plugin-istanbul), example: [webpack.config-istanbul.js](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/webpack.config-istanbul.js)
+    - rollup: [rollup-plugin-istanbul](https://github.com/artberri/rollup-plugin-istanbul)
+    - vite: [vite-plugin-istanbul](https://github.com/ifaxity/vite-plugin-istanbul)
 - Browser
-    > Collecting coverage data from `window.__coverage__`, example: [test-istanbul.js](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-istanbul.js)
+    - Collecting coverage data from `window.__coverage__`, example: [test-istanbul.js](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-istanbul.js)
 - Node.js
-    > Collecting coverage data from `global.__coverage__`
+    - Collecting coverage data from `global.__coverage__`
 
 ## Collecting V8 Coverage Data
 - For source code: enable `sourcemap` and do not compress/minify:
-    - Webpack: build with `source-map` [devtool](https://webpack.js.org/configuration/devtool/) and `development` [mode](https://webpack.js.org/configuration/mode/), example [webpack.config-v8.js](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/webpack.config-v8.js)
-    - Rollup: build with [options](https://rollupjs.org/configuration-options/) `sourcemap: true`
-    - Vite: build with [options](https://vitejs.dev/config/build-options.html) `sourcemap: true` and `minify: false` 
+    - [webpack](https://webpack.js.org/configuration/): `devtool: source-map` and `mode: development`, example [webpack.config-v8.js](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/webpack.config-v8.js)
+    - [rollup](https://rollupjs.org/configuration-options/): `sourcemap: true`
+    - [vite](https://vitejs.dev/config/build-options.html): `sourcemap: true` and `minify: false`
+    - [esbuild](https://esbuild.github.io/api/): `sourcemap: true` and `minify: false`
 - Browser (Chromium Only)
-    > Collecting coverage data with [Chromium Coverage API](#chromium-coverage-api), see [example](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-v8.js)
+    > Collecting coverage data with [Chromium Coverage API](#chromium-coverage-api):
+    - [Playwright example](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-v8.js), and [anonymous](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-anonymous.js), [css](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-css.js)
+    - [Puppeteer example](https://github.com/cenfun/monocart-coverage-reports/blob/main/test/test-puppeteer.js)
 - Node.js
-    > see [Node.js V8 Coverage Report for Server Side](#nodejs-v8-coverage-report-for-server-side)
+    - see following [Node.js V8 Coverage Report for Server Side](#nodejs-v8-coverage-report-for-server-side)
 
 
 ## Node.js V8 Coverage Report for Server Side
-- Using Node.js env [NODE_V8_COVERAGE](https://nodejs.org/docs/latest/api/cli.html#node_v8_coveragedir)=`dir`
-    - Before running your Node.js application, set env `NODE_V8_COVERAGE`=`dir`. After the application runs and exits, the coverage data will be saved to the `dir` directory in JSON file format
-    - Read the json file(s) from the `dir` and generate coverage report
-    - example:
+Possible solutions:
+- [NODE_V8_COVERAGE](https://nodejs.org/docs/latest/api/cli.html#node_v8_coveragedir)=`dir`
+    - Sets Node.js env `NODE_V8_COVERAGE`=`dir` before the program running, the coverage data will be saved to the `dir` after the program exits gracefully.
+    - Read the JSON file(s) from the `dir` and generate coverage report.
+    - Example:
     > cross-env NODE_V8_COVERAGE=`.temp/v8-coverage-env` node [./test/test-node-env.js](./test/test-node-env.js) && node [./test/generate-node-report.js](./test/generate-node-report.js)
 
-- Using [V8](https://nodejs.org/docs/latest/api/v8.html#v8takecoverage) API + NODE_V8_COVERAGE
-    - Writing the coverage started by NODE_V8_COVERAGE to disk on demand with `v8.takeCoverage()` and stopping with `v8.stopCoverage()`. 
-    - example:
+- [V8](https://nodejs.org/docs/latest/api/v8.html#v8takecoverage) API + NODE_V8_COVERAGE
+    - Writing the coverage started by NODE_V8_COVERAGE to disk on demand with `v8.takeCoverage()`, it does not require waiting until the program exits gracefully.
+    - Example:
     > cross-env NODE_V8_COVERAGE=`.temp/v8-coverage-api` node [./test/test-node-api.js](./test/test-node-api.js)
 
-- Using [Inspector](https://nodejs.org/docs/latest/api/inspector.html) API (or module [collect-v8-coverage](https://github.com/SimenB/collect-v8-coverage))
+- [Inspector](https://nodejs.org/docs/latest/api/inspector.html) API
    - Connecting to the V8 inspector and enable V8 coverage.
-   - Taking coverage data and adding to the report after your application runs.
-   - example: [./test/test-node-ins.js](./test/test-node-ins.js)
+   - Taking coverage data and adding it to the report.
+   - Example: 
+   > node [./test/test-node-ins.js](./test/test-node-ins.js)
    
-- Using [CDP](https://chromedevtools.github.io/devtools-protocol/) API
-    - Enabling [Node Debugging](https://nodejs.org/en/guides/debugging-getting-started/)
+- [CDP](https://chromedevtools.github.io/devtools-protocol/) API
+    - Enabling [Node Debugging](https://nodejs.org/en/guides/debugging-getting-started/).
     - Collecting coverage data with CDP API.
-    - example: [./test/test-node-cdp.js](./test/test-node-cdp.js)
+    - Example: 
+    > node --inspect=9229 [./test/test-node-cdp.js](./test/test-node-cdp.js)
 
-## Using `entryFilter` and `sourceFilter` to filter the results for V8 report
-When V8 coverage data collected, it actually contains the data of all entry files, for example:
-```
-dist/main.js
-dist/vendor.js
-dist/something-else.js
-```
-We can use `entryFilter` to filter the entry files. For example, we should remove `vendor.js` and `something-else.js` if they are not in our coverage scope. 
-```
-dist/main.js
-```
-When inline or linked sourcemap exists to the entry file, the source files will be extracted from the sourcemap for the entry file, and the entry file will be removed if `logging` is not `debug`.
-```
-> src/index.js
-> src/components/app.js
-> node_modules/dependency/dist/dependency.js
-```
-We can use `sourceFilter` to filter the source files. For example, we should remove `dependency.js` if it is not in our coverage scope.
-```
-> src/index.js
-> src/components/app.js
-```
-Example:
+- [Node Debugging](https://nodejs.org/en/guides/debugging-getting-started) + CDP + NODE_V8_COVERAGE + V8 API
+    - When the program starts a server, it will not exit on its own, thus requiring a manual invocation of the `v8.takeCoverage()` interface to manually collect coverage data. Remote invocation of the `v8.takeCoverage()` interface can be accomplished through the `Runtime.evaluate` of the CDP.
+    - Example for [koa](https://github.com/koajs/koa) web server:
+    > node [./test/test-node-koa.js](./test/test-node-koa.js)
+
+- [Child Process](https://nodejs.org/docs/latest/api/child_process.html) + NODE_V8_COVERAGE
+    - see [`mcr` CLI](#mcr-cli)
+
+## Multiprocessing Support
+The data will be added to `[outputDir]/.cache`, and the cache will be removed after reports generated.
+- sub process 1
 ```js
-const coverageOptions = {
-    entryFilter: (entry) => entry.url.indexOf("main.js") !== -1,
-    sourceFilter: (sourcePath) => sourcePath.search(/src\//) !== -1
-};
+const MCR = require('monocart-coverage-reports');
+const options = require('path-to/same-options.js');
+const coverageReport = MCR(options);
+await coverageReport.add(coverageData1);
 ```
 
-## How to convert V8 to Istanbul
-### Using [v8-to-istanbul](https://github.com/istanbuljs/v8-to-istanbul)
-It is a popular library which is used to convert V8 coverage format to istanbul's coverage format. Most test frameworks are using it, such as [Jest](https://github.com/jestjs/jest/), [Vitest](https://github.com/vitest-dev/vitest), but it has two major problems:
-- 1, The source mapping does not work well if the position is between the two consecutive mappings. for example: 
+- sub process 2
 ```js
-const a = tf ? 'true' : 'false';
-               ^     ^  ^
-              m1     p  m2
+const MCR = require('monocart-coverage-reports');
+const options = require('path-to/same-options.js');
+const coverageReport = MCR(options);
+await coverageReport.add(coverageData2);
 ```
-> `m1` and `m2` are two consecutive mappings, `p` is the position we looking for. However, we can only get the position of the `m1` if we don't fix it to `p`. Especially the generated code is different from the original code, such as minified, compressed or converted, then it becomes very difficult to find the middle position between two mappings.
 
-- 2, The coverage of functions and branches is incorrect. V8 only provided coverage at functions and it's blocks. But if a function is uncovered (count = 0), there is no information for it's blocks and sub-level functions.
-And also there are some problems about counting the functions and branches:
+- main process
 ```js
-functions.forEach(block => {
-    block.ranges.forEach((range, i) => {
-        if (block.isBlockCoverage) {
-            // v8-to-istanbul: new CovBranch() 
-            // Problem: not every block is branch, and the first block is actually function.
-            if (block.functionName && i === 0) {
-                // v8-to-istanbul: new CovFunction()
-                // Problem: no anonymous function
-            }
-        } else if (block.functionName) {
-            // v8-to-istanbul: new CovFunction()
-            // Problem: no anonymous function
-        }
-    }
-});
-// Problem: When the function or parent-level function is uncovered, then its sub-level functions will never be counted.
+// after all sub processes finished
+const MCR = require('monocart-coverage-reports');
+const options = require('path-to/same-options.js');
+const coverageReport = MCR(options);
+const coverageResults = await coverageReport.generate();
+console.log(coverageResults.summary);
 ```
-see source code [v8-to-istanbul.js](https://github.com/istanbuljs/v8-to-istanbul/blob/master/lib/v8-to-istanbul.js)
 
-### How Monocart Works
-We have removed `v8-to-istanbul` because of the two major problems and implemented new converter:
-- 1, Trying to fix the middle position if not found the exact mapping.
-- 2, Finding all functions and branches by parsing the source code [AST](https://github.com/acornjs/acorn), however the V8 cannot provide effective branch coverage information, so the branches is still not perfect.
-
-| AST | V8 | 
-| :--------------| :------ | 
-| AssignmentPattern | 🛇 Not Support | 
-| ConditionalExpression | ✔ Not Perfect | 
-| IfStatement | ✔ Not Perfect | 
-| LogicalExpression | ✔ Not Perfect | 
-| SwitchStatement | ✔ Not Perfect | 
+## Integration
+- [monocart-reporter](https://cenfun.github.io/monocart-reporter/) - Test reporter for [Playwright](https://github.com/microsoft/playwright)
+- [vitest-monocart-coverage](https://github.com/cenfun/vitest-monocart-coverage) - Integration with [Vitest](https://github.com/vitest-dev/vitest) coverage
 
 ## Ignoring Uncovered Codes
 To ignore codes, use the special comment which starts with `v8 ignore `:
-- ignoring all until told
+- Ignoring all until stop
 ```js
 /* v8 ignore start */
 function uncovered() {
 }
 /* v8 ignore stop */
 ```
-- ignoring the next line or next N lines
+- Ignoring the next line or next N lines
 ```js
 /* v8 ignore next */
 const os = platform === 'wind32' ? 'Windows' : 'Other';
@@ -333,8 +345,8 @@ if (platform === 'linux') {
 
 ## Chromium Coverage API
 - [V8 coverage report](https://v8.dev/blog/javascript-code-coverage) - Native support for JavaScript code coverage to V8. (Chromium only)
-- [Puppeteer Coverage Class](https://pptr.dev/api/puppeteer.coverage)
 - [Playwright Coverage Class](https://playwright.dev/docs/api/class-coverage)
+- [Puppeteer Coverage class](https://pptr.dev/api/puppeteer.coverage)
 - [DevTools Protocol for Coverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#method-startPreciseCoverage)
 
 ## V8 Coverage Data Format
@@ -380,6 +392,71 @@ export type V8CoverageData = ScriptCoverage[];
 ```
 see devtools-protocol [ScriptCoverage](https://chromedevtools.github.io/devtools-protocol/tot/Profiler/#type-ScriptCoverage) and [v8-coverage](https://github.com/bcoe/v8-coverage)
 
+### Collect raw v8 coverage data with Puppeteer
+```js
+await page.coverage.startJSCoverage({
+    // provide raw v8 coverage data
+    includeRawScriptCoverage: true
+});
+
+await page.goto(url);
+
+const jsCoverage = await page.coverage.stopJSCoverage();
+const rawV8CoverageData = jsCoverage.map((it) => {
+    // Convert to raw v8 coverage format
+    return {
+        source: it.text,
+        ... it.rawScriptCoverage
+    };
+}
+```
+see example: [./test/test-puppeteer.js](./test/test-puppeteer.js)
+
+## How to convert V8 to Istanbul
+### Using [v8-to-istanbul](https://github.com/istanbuljs/v8-to-istanbul)
+It is a popular library which is used to convert V8 coverage format to istanbul's coverage format. Most test frameworks are using it, such as [Jest](https://github.com/jestjs/jest/), [Vitest](https://github.com/vitest-dev/vitest), but it has two major problems:
+- 1, The source mapping does not work well if the position is between the two consecutive mappings. for example: 
+```js
+const a = tf ? 'true' : 'false';
+               ^     ^  ^
+              m1     p  m2
+```
+> `m1` and `m2` are two consecutive mappings, `p` is the position we looking for. However, we can only get the position of the `m1` or `m2` if we don't fix it to `p`. Especially the generated code is different from the original code, such as the code was minified, compressed or converted, it is difficult to find the exact position.
+
+- 2, The coverage of functions and branches is incorrect. V8 only provided coverage at functions and it's blocks. But if a function is uncovered (count = 0), there is no information for it's blocks and sub-level functions.
+And also there are some problems about counting the functions and branches:
+```js
+// Problem: When the function or parent-level function is uncovered, then its sub-level functions will never be counted.
+functions.forEach(block => {
+    block.ranges.forEach((range, i) => {
+        if (block.isBlockCoverage) {
+            // v8-to-istanbul: new CovBranch() 
+            // Problem: not every block is branch, and the first block could be function.
+            if (block.functionName && i === 0) {
+                // v8-to-istanbul: new CovFunction()
+                // Problem: no anonymous function
+            }
+        } else if (block.functionName) {
+            // v8-to-istanbul: new CovFunction()
+            // Problem: no anonymous function
+        }
+    }
+});
+```
+see source code [v8-to-istanbul.js](https://github.com/istanbuljs/v8-to-istanbul/blob/master/lib/v8-to-istanbul.js)
+
+### How Monocart Works
+We implemented new converter instead of v8-to-istanbul:
+- 1, Trying to fix the middle position if not found the exact mapping for the position.
+- 2, Finding all functions and branches by parsing the source code [AST](https://github.com/acornjs/acorn), however the V8 cannot provide effective branch coverage information, so the branches is still not perfect but close to reality.
+
+| AST                   | V8             | 
+| :---------------------| :------------- | 
+| AssignmentPattern     | 🛇 Not Support | 
+| ConditionalExpression | ✔ Not Perfect | 
+| IfStatement           | ✔ Not Perfect | 
+| LogicalExpression     | ✔ Not Perfect | 
+| SwitchStatement       | ✔ Not Perfect | 
 
 ## Istanbul Introduction
 - [Istanbul coverage report](https://istanbul.js.org/) - Instrumenting source codes and generating coverage reports

package/lib/cli.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const EC = require('eight-colors');
+const { fileURLToPath } = require('url');
+
+const {
+    foregroundChild,
+    program
+} = require('./packages/monocart-coverage-vendor.js');
+
+const MCR = require('./index.js');
+const Util = require('./utils/util.js');
+const defaultOptions = require('./default/options.js');
+const version = require('../package.json').version;
+
+const cleanDir = (dir) => {
+    if (fs.existsSync(dir)) {
+        fs.rmSync(dir, {
+            recursive: true,
+            force: true
+        });
+    }
+};
+
+const initOptions = (cliOptions) => {
+    // merge all cli options
+    const configPath = cliOptions.config;
+    if (configPath) {
+        if (fs.existsSync(configPath)) {
+            const config = require(path.resolve(configPath));
+            Object.assign(cliOptions, config);
+        } else {
+            EC.logRed(`Not found config: ${configPath}`);
+        }
+    }
+
+    // init reports to list with `,`
+    const reports = cliOptions.reports;
+    if (reports) {
+        cliOptions.reports = reports.split(',');
+    }
+
+    // report options
+    const options = {
+        ... defaultOptions
+    };
+    Object.keys(cliOptions).forEach((k) => {
+        if (Util.hasOwn(options, k)) {
+            options[k] = cliOptions[k];
+        }
+    });
+
+    return options;
+};
+
+const executeCommand = async (command, cliOptions) => {
+
+    const options = initOptions(cliOptions);
+
+    console.log('Execute:', EC.cyan(command));
+    // console.log(options);
+
+    const nodeV8CoverageDir = path.resolve(options.outputDir, '.v8-coverage');
+    process.env.NODE_V8_COVERAGE = nodeV8CoverageDir;
+
+    cleanDir(nodeV8CoverageDir);
+
+    // console.log('nodeV8CoverageDir', nodeV8CoverageDir);
+
+    const coverageReport = MCR(options);
+    coverageReport.cleanCache();
+
+    // on start hook
+    const onStart = cliOptions.onStart;
+    if (typeof onStart === 'function') {
+        await onStart(coverageReport);
+    }
+
+    foregroundChild(command, {
+        shell: true
+    }, async () => {
+
+        if (!fs.existsSync(nodeV8CoverageDir)) {
+            EC.logRed(`Not found coverage data: ${Util.relativePath(nodeV8CoverageDir)}`);
+            return 1;
+        }
+
+        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;
+
+            // filter node internal files
+            coverageList = coverageList.filter((entry) => entry.url && entry.url.startsWith('file:'));
+
+            if (!coverageList.length) {
+                continue;
+            }
+            // attached source content
+            coverageList.forEach((entry) => {
+                const filePath = fileURLToPath(entry.url);
+                if (fs.existsSync(filePath)) {
+                    entry.source = fs.readFileSync(filePath).toString('utf8');
+                } else {
+                    EC.logRed('not found file', Util.relativePath(filePath));
+                }
+            });
+
+            await coverageReport.add(coverageList);
+        }
+
+        await coverageReport.generate();
+
+        // remove nodeV8CoverageDir
+        if (options.logging !== 'debug') {
+            cleanDir(nodeV8CoverageDir);
+        }
+
+        return process.exitCode;
+    });
+
+};
+
+program
+    .name('mcr')
+    .description('CLI to generate coverage reports')
+    .version(version)
+    .argument('<command>', 'command to execute')
+    .option('-c, --config <path>', 'config path for options')
+    .option('-o, --outputDir <dir>', 'output dir for reports')
+    .option('-r, --reports <name[,name]>', 'coverage reports to use')
+    .option('-n, --name <name>', 'report name for title')
+
+    .option('--outputFile <path>', 'output file for v8 report')
+    .option('--inline', 'inline html for v8 report')
+    .option('--assetsPath <path>', 'assets path if not inline')
+
+    .option('--lcov', 'generate lcov.info file')
+
+    .action((command, cliOptions) => {
+        executeCommand(command, cliOptions);
+    });
+
+program.parse();

package/lib/converter/ast.js

@@ -170,7 +170,7 @@ const getJsAstInfo = (item, coverageList) => {
     try {
         ast = acorn.parse(source, options);
     } catch (e) {
-        Util.logError(`failed to parse source file and fall back to loose: ${item.sourcePath} ${e.message}`);
+        Util.logInfo(`failed to parse source file: ${item.sourcePath} ${e.message}`);
         // https://github.com/acornjs/acorn/tree/master/acorn-loose
         // It is recommended to always try a parse with the regular acorn parser first,
         // and only fall back to this parser when that one finds syntax errors.

package/lib/converter/converter.js

@@ -774,8 +774,9 @@ const collectOriginalList = (item, state, originalMap, options) => {
 
         // add file item
         const url = fileUrls[sourcePath] || sourcePath;
+
         // add dist for id
-        const id = Util.calculateSha1(distFile + url + source);
+        const id = Util.calculateSha1(distFile + sourcePath + source);
 
         const sourceItem = {
             url,
@@ -975,22 +976,30 @@ const convertV8List = async (v8list, options) => {
         // merge state
         Object.assign(fileSources, state.fileSources);
         Object.assign(coverageData, state.coverageData);
-        if (state.sourceList) {
+
+        if (Util.isList(state.sourceList)) {
             sourceList = sourceList.concat(state.sourceList);
         }
 
     }
 
-    // dedupe
-    dedupeV8List(v8list);
-
     // add all sources
     if (sourceList.length) {
         sourceList.forEach((item) => {
+
+            // exists same id, mark previous item as dedupe
+            const prevItem = v8list.find((it) => it.id === item.id);
+            if (prevItem) {
+                prevItem.dedupe = true;
+            }
+
             v8list.push(item);
         });
     }
 
+    // dedupe
+    dedupeV8List(v8list);
+
     return {
         fileSources,
         coverageData