monocart-coverage-reports 2.7.7 → 2.7.9

package/README.md

@@ -28,6 +28,8 @@
 * [Command Line](#command-line)
 * [Config File](#config-file)
 * [Merge Coverage Reports](#merge-coverage-reports)
+    - [Automatic Merging](#automatic-merging)
+    - [Manual Merging](#manual-merging)
 * [Common issues](#common-issues)
     - [Unexpected coverage](#unexpected-coverage)
     - [Unparsable source](#unparsable-source)
@@ -50,10 +52,16 @@
     - [Codecov](#codecov)
     - [Coveralls](#coveralls)
     - [Sonar Cloud](#sonar-cloud)
+* [Contributing](#contributing)
+* [Changelog](CHANGELOG.md)
 * [Thanks](#thanks)
 
 ## Usage
 > It's recommended to use [Node.js 20+](https://nodejs.org/).
+- Install
+```sh
+npm install monocart-coverage-reports
+```
 - API
 ```js
 const MCR = require('monocart-coverage-reports');
@@ -81,16 +89,8 @@ mcr node my-app.js -r v8,console-details
 For more information, see [Command Line](#command-line)
 
 ## Options
-- Default Options: [lib/default/options.js](./lib/default/options.js)
-    - `reports` [Available Reports](#available-reports)
-    - `entryFilter` and `sourceFilter` [Using `entryFilter` and `sourceFilter` to filter the results for V8 report](#using-entryfilter-and-sourcefilter-to-filter-the-results-for-v8-report)
-    - `sourcePath` [Resolve `sourcePath` for the Source Files](#resolve-sourcepath-for-the-source-files)
-    - `all` [Adding Empty Coverage for Untested Files](#adding-empty-coverage-for-untested-files)
-    - `inputDir` [Merge Coverage Reports](#merge-coverage-reports)
-    - `logging` [Debug for Coverage and Sourcemap](#debug-for-coverage-and-sourcemap)
-    - `onEnd` [onEnd Hook](#onend-hook)
-
-- Declaration: [lib/index.d.ts](./lib/index.d.ts)
+- Default options: [lib/default/options.js](./lib/default/options.js)
+- Options declaration see `CoverageReportOptions` [lib/index.d.ts](./lib/index.d.ts)
 - [Config file](#config-file)
 
 ## Available Reports
@@ -222,19 +222,24 @@ const mcr = MCR(coverageOptions);
     - vite: [vite-plugin-istanbul](https://github.com/ifaxity/vite-plugin-istanbul)
     - rollup: [rollup-plugin-istanbul](https://github.com/artberri/rollup-plugin-istanbul)
     - swc: [swc-plugin-coverage-instrument](https://github.com/kwonoj/swc-plugin-coverage-instrument)
+
 - Browser
     - Collecting coverage data from `window.__coverage__`, example: [test-istanbul.js](./test/test-istanbul.js)
+
 - Node.js
     - Collecting coverage data from `global.__coverage__`
 
+- CDP
+    - `getIstanbulCoverage()` see [`CDPClient` API](#collecting-v8-coverage-data-with-cdpclient-api)
+
 ## Collecting V8 Coverage Data
 - Before coverage collection: Enabling `sourcemap` for source code
     - [webpack](https://webpack.js.org/configuration/): `devtool: source-map` and `mode: development`, example [webpack.config-v8.js](./test/build/webpack.config-v8.js)
-    - [rollup](https://rollupjs.org/configuration-options/): `sourcemap: true`
+    - [rollup](https://rollupjs.org/configuration-options/): `sourcemap: true` and `treeshake: false`
+    - [esbuild](https://esbuild.github.io/api/): `sourcemap: true`, `treeShaking: false` and `minify: false`
     - [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)
+- Browser (Chromium-based Only)
     - [Collecting V8 Coverage Data with Playwright](#collecting-v8-coverage-data-with-playwright)
     - [Collecting Raw V8 Coverage Data with Puppeteer](#collecting-raw-v8-coverage-data-with-puppeteer)
 
@@ -248,9 +253,11 @@ const mcr = MCR(coverageOptions);
 ```js
 await Promise.all([
     page.coverage.startJSCoverage({
+        // reportAnonymousScripts: true,
         resetOnNavigation: false
     }),
     page.coverage.startCSSCoverage({
+        // Note, anonymous styles (without sourceURLs) are not supported, alternatively, you can use CDPClient
         resetOnNavigation: false
     })
 ]);
@@ -267,10 +274,12 @@ const coverageData = [... jsCoverage, ... cssCoverage];
 ```
 For more examples, see [./test/test-v8.js](./test/test-v8.js), and [anonymous](./test/test-anonymous.js), [css](./test/test-css.js)
 
+
 ### Collecting Raw V8 Coverage Data with Puppeteer
 ```js
 await Promise.all([
     page.coverage.startJSCoverage({
+        // reportAnonymousScripts: true,
         resetOnNavigation: false,
         // provide raw v8 coverage data
         includeRawScriptCoverage: true
@@ -331,7 +340,27 @@ Possible solutions:
     - see [Command Line](#command-line)
 
 ### Collecting V8 Coverage Data with `CDPClient` API
-- Work with node debugger port `--inspect=9229`
+- `CDPClient` available APIs
+```js
+startJSCoverage: () => Promise<void>;
+stopJSCoverage: () => Promise<V8CoverageEntry[]>;
+
+startCSSCoverage: () => Promise<void>;
+stopCSSCoverage: () => Promise<V8CoverageEntry[]>;
+
+/** start both js and css coverage */
+startCoverage: () => Promise<void>;
+/** stop and return both js and css coverage */
+stopCoverage: () => Promise<V8CoverageEntry[]>;
+
+/** write the coverage started by NODE_V8_COVERAGE to disk on demand, returns v8 coverage dir */
+writeCoverage: () => Promise<string>;
+
+/** get istanbul coverage data */
+getIstanbulCoverage: (coverageKey?: string) => Promise<any>;
+```
+
+- Work with node debugger port `--inspect=9229` or browser debugging port `--remote-debugging-port=9229`
 ```js
 const MCR = require('monocart-coverage-reports');
 const client = await MCR.CDPClient({
@@ -341,6 +370,7 @@ await client.startJSCoverage();
 // run your test here
 const coverageData = await client.stopJSCoverage();
 ```
+
 - Work with [Playwright CDPSession](https://playwright.dev/docs/api/class-cdpsession)
 ```js
 const { chromium } = require('playwright');
@@ -357,6 +387,7 @@ await client.startCoverage();
 await page.goto("your page url");
 const coverageData = await client.stopCoverage();
 ```
+
 - Work with [Puppeteer CDPSession](https://pptr.dev/api/puppeteer.cdpsession)
 ```js
 const puppeteer = require('puppeteer');
@@ -373,6 +404,7 @@ await client.startCoverage();
 await page.goto("your page url");
 const coverageData = await client.stopCoverage();
 ```
+
 - Work with [Selenium Webdriver](https://www.selenium.dev/documentation/webdriver/) WebSocket (Chrome/Edge Browser)
 ```js
 const { Builder, Browser } = require('selenium-webdriver');
@@ -384,29 +416,6 @@ const client = await MCR.CDPClient({
     session
 })
 ```
- - `CDPClient` available APIs
- ```js
-/** start js coverage */
-startJSCoverage: () => Promise<void>;
-/** stop and return js coverage */
-stopJSCoverage: () => Promise<V8CoverageEntry[]>;
-
-/** start css coverage */
-startCSSCoverage: () => Promise<void>;
-/** stop and return css coverage */
-stopCSSCoverage: () => Promise<V8CoverageEntry[]>;
-
-/** start both js and css coverage */
-startCoverage: () => Promise<void>;
-/** stop and return both js and css coverage */
-stopCoverage: () => Promise<V8CoverageEntry[]>;
-
-/** write the coverage started by NODE_V8_COVERAGE to disk on demand, returns v8 coverage dir */
-writeCoverage: () => Promise<string>;
-
-/** get istanbul coverage data */
-getIstanbulCoverage: (coverageKey?: string) => Promise<any>;
- ```
 
 ### V8 Coverage Data API
 - [JavaScript code coverage in V8](https://v8.dev/blog/javascript-code-coverage)
@@ -480,23 +489,42 @@ const coverageOptions = {
     sourceFilter: (sourcePath) => sourcePath.search(/src\//) !== -1
 };
 ```
-Or using `minimatch` pattern:
+Or using [`minimatch`](https://github.com/isaacs/minimatch) pattern:
 ```js
 const coverageOptions = {
     entryFilter: "**/main.js",
     sourceFilter: "**/src/**"
 };
-// supports multiple patterns:
+```
+Supports multiple patterns:
+```js
 const coverageOptions = {
     entryFilter: {
+        '**/node_modules/**': false,
         '**/vendor.js': false,
-        '**/main.js': true
+        '**/src/**': true
     },
     sourceFilter: {
-        '**/src/**': true
+        '**/node_modules/**': false,
+        '**/**': true
     }
 };
 ```
+In fact, the `minimatch` patterns will be transformed to a function like:
+```js
+const coverageOptions = {
+    // '**/node_modules/**': false,
+    // '**/vendor.js': false,
+    // '**/src/**': true
+    entryFilter: (entry) => {
+        if (minimatch(entry.url, '**/node_modules/**')) { return false; }
+        if (minimatch(entry.url, '**/vendor.js')) { return false; }
+        if (minimatch(entry.url, '**/src/**')) { return true; }
+        return false; // else unmatched
+    }
+    // Note, the order of the patterns will impact the results
+};
+```
 
 ## Resolve `sourcePath` for the Source Files
 If the source file comes from the sourcemap, then its path is a virtual path. Using the `sourcePath` option to resolve a custom path.
@@ -537,7 +565,7 @@ const coverageOptions = {
     }
 };
 ```
-The filter also supports `minimatch` pattern:
+The filter also supports [`minimatch`](https://github.com/isaacs/minimatch) pattern:
 ```js
 const coverageOptions = {
     all: {
@@ -677,7 +705,7 @@ Arguments:
   command                      command to execute
 
 Options:
-  -V, --version                output the version number
+  -v, --version                output the current version
   -c, --config <path>          custom config file path
   -l, --logging <logging>      off, error, info, debug
   -n, --name <name>            report name for title
@@ -700,6 +728,12 @@ Options:
 mcr -c mcr.config.js -- sub-cli -c sub-cli.config.js
 ```
 
+- Examples
+    - [Mocha](#mocha)
+    - [tsx](#tsx)
+    - [ts-node](#ts-node)
+    - [AVA](#ava)
+
 ## Config File
 Loading config file by priority:
 - Custom config file:
@@ -715,13 +749,19 @@ Loading config file by priority:
 
 ## Merge Coverage Reports
 The following usage scenarios may require merging coverage reports:
-- When the code is executed in different environments, like Node.js Server Side and browser Client Side (Next.js for instance). Each environment may generate its own coverage report. Merging them can give a more comprehensive view of the test coverage. see example [nextjs-with-playwright](https://github.com/cenfun/nextjs-with-playwright) for automatic report merging.
+- When the code is executed in different environments, like Node.js server side and browser client side (Next.js for instance). Each environment may generate its own coverage report. Merging them can give a more comprehensive view of the test coverage.
 - When the code is subjected to different kinds of testing. For example, unit tests with Jest might cover certain parts of the code, while end-to-end tests with Playwright might cover other parts. Merging these different coverage reports can provide a holistic view of what code has been tested.
-- When tests are run on different machines or different shards, each might produce its own coverage report. Merging these can give a complete picture of the test coverage across all machines or shards.
+- When tests are run on different machines or containers, each might produce its own coverage report. Merging these can give a complete picture of the test coverage across all machines or shards.
+
+### Automatic Merging
+- `MCR` will automatically merge all the added coverage data when executing `generate()`. And it supports adding coverage data asynchronously across processes, see [Multiprocessing Support](#multiprocessing-support)
+- For Next.js, it can actually add coverage data including both server side and client side before executing `generate()`, see example [nextjs-with-playwright](https://github.com/cenfun/nextjs-with-playwright)
+- Use Codecov, a popular online code coverage service, which supports automatic merging of reports. Please use report `codecov`, it will generate report file `codecov.json`. If multiple `codecov.json` files are generated, upload all these files, they will be automatically merged. see [Codecov](#codecov) and [merging reports](https://docs.codecov.com/docs/merging-reports)
 
+### Manual Merging
 If the reports cannot be merged automatically, then here is how to manually merge the reports.
 First, using the `raw` report to export the original coverage data to the specified directory.
-For example, we have `raw` coverage data from unit tests:
+- For example, we have `raw` coverage data from unit tests, which is output to `./coverage-reports/unit/raw`
 ```js
 const coverageOptions = {
     name: 'My Unit Test Coverage Report',
@@ -737,8 +777,8 @@ const coverageOptions = {
     ]
 };
 ```
-We also have `raw` coverage data from e2e tests, which is output to `./coverage-reports/e2e/raw`.
-After all the tests are completed, generate a merged report with option `inputDir`:
+- We also have `raw` coverage data from e2e tests, which is output to `./coverage-reports/e2e/raw`
+- Create a script `merge-coverage.js` to generate a merged report with option `inputDir`. After all the tests are completed, running script `node path/to/merge-coverage.js`
 ```js
 // merge-coverage.js
 const fs = require('fs');
@@ -788,20 +828,32 @@ const coverageOptions = {
 };
 await new CoverageReport(coverageOptions).generate();
 ```
+- All the command scripts are probably like following:
+```json
+{
+    "scripts": {
+        "test:unit": "jest",
+        "test:e2e": "playwright test",
+        "merge-coverage": "node path/to/merge-coverage.js",
+        "test": "npm run test:unit && npm run test:e2e && npm run merge-coverage"
+    }
+}
+```
 
 ## Common issues
 ### Unexpected coverage
-In most cases, it happens when the coverage of the generated code is converted to the coverage of the original code through a sourcemap. In other words, it's an issue with the sourcemap. Most of the time, we can solve this by setting `minify` to `false` in the build tools configuration. Let's take a look at an example:
+In most cases, it happens when the coverage of the generated code is converted to the coverage of the original code through a sourcemap. In other words, it's an issue with the sourcemap. Most of the time, we can solve this by setting `minify` to `false` in the configuration of build tools. Let's take a look at an 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. You can try [Debug for Coverage and Sourcemap](#debug-for-coverage-and-sourcemap)
+In the generated code, there is a position `p`, and we need to find out its corresponding position in the original code. Unfortunately, there is no matched mapping for the position `p`. Instead, it has two adjacent upstream and downstream mappings `m1` and `m2`, so, the original position of `p` that we are looking for, might not be able to be precisely located. 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 original position without matched mapping. 
+- Further understanding of sourcemap, try [Debug for Coverage and Sourcemap](#debug-for-coverage-and-sourcemap)
 
 How `MCR` Works:
-- 1, Trying to fix the middle original position with string comparison and [`diff-sequences`](https://github.com/jestjs/jest/tree/main/packages/diff-sequences). However, for non-JS code, such as Vue template, JSX, etc., it might be hard to find a perfect solution.
-- 2, Finding all functions, statements and branches by parsing the source code [AST](https://github.com/acornjs/acorn). However, there's a small issue, which is the V8 cannot provide effective branch coverage information for `AssignmentPattern`.
+- 1, Trying to fix the original position with string comparison and [`diff-sequences`](https://github.com/jestjs/jest/tree/main/packages/diff-sequences). However, for non-JS code, such as Vue template, JSX, etc., it might be hard to find a perfect solution.
+- 2, Finding all functions, statements and branches by parsing the source code [AST](https://github.com/acornjs/acorn). (There is a small issue is the V8 cannot provide effective branch coverage information for `AssignmentPattern`)
 
 
 ### Unparsable source
@@ -969,6 +1021,18 @@ const coverageOptions = {
         -Dsonar.exclusions=dist/*,packages/*
 ```
 
+## Contributing
+```sh
+# Node.js 20+
+npm install starfall-cli -g
+npm install
+
+npm run build
+npm run test
+
+npm run dev
+```
+
 ### VSCode Extension
 - [Coverage Gutters](https://github.com/ryanluker/vscode-coverage-gutters) - Display test coverage generated by lcov or xml in VSCode editor.
 

package/lib/cli.js

@@ -21,53 +21,78 @@ const getRegisterPath = (filename) => {
     return `./${rel}`;
 };
 
-const initNodeOptions = async (cliOptions) => {
-
-    // module register added in Node.js: v20.6.0
-    const nv = process.versions.node;
-    if (Util.cmpVersion(nv, '20.6.0') < 0) {
-        Util.logInfo(`The current Node.js version "${nv}" does NOT support "module.register", it requires "20.6.0" or higher.`);
-        return;
-    }
-
+const getInitNodeOptions = async (cliOptions) => {
     const nodeOptions = [];
     if (process.env.NODE_OPTIONS) {
         nodeOptions.push(process.env.NODE_OPTIONS);
     }
 
     if (cliOptions.import) {
-        nodeOptions.push('--import');
-        nodeOptions.push(cliOptions.import);
+        nodeOptions.push(`--import ${cliOptions.import}`);
+        // for load mcr.config.ts
         await import(cliOptions.import);
     } else if (cliOptions.require) {
-        nodeOptions.push('--require');
-        nodeOptions.push(cliOptions.require);
+        nodeOptions.push(`--require ${cliOptions.require}`);
+        // for load mcr.config.ts
         await import(cliOptions.require);
     }
 
+    return nodeOptions;
+};
+
+const getPreloadType = (nodeOptions) => {
+    const hasImport = nodeOptions.find((it) => it.includes('--import'));
+    if (hasImport) {
+        return '--import';
+    }
+    return '--require';
+};
+
+const checkRegisterFeature = () => {
+    const nv = process.versions.node;
+
+    // "module.register" added in Node.js: v20.6.0
+    // if (Util.cmpVersion(nv, '20.6.0') >= 0) {
+    //     return true;
+    // }
+    // but also added in: v18.19.0
+    const requiredNV = '18.19.0';
+    if (Util.cmpVersion(nv, requiredNV) < 0) {
+        Util.logInfo(`The current Node.js version "${nv}" does NOT support "module.register", it requires "${requiredNV}" or higher.`);
+        return false;
+    }
+
+    // could be < 20.6.0 but just ignore it, please using latest minor version
+
+    return true;
+};
+
+const initNodeOptions = async (cliOptions) => {
+
+    const supportRegister = checkRegisterFeature();
+    if (!supportRegister) {
+        return;
+    }
+
+    const nodeOptions = await getInitNodeOptions(cliOptions);
     // console.log(nodeOptions);
 
+    const preloadType = getPreloadType(nodeOptions);
+
     // export source after
-    const hasImport = nodeOptions.find((it) => typeof it === 'string' && it.includes('--import'));
-    if (hasImport) {
+    if (preloadType === '--import') {
         const importPath = getRegisterPath('register.mjs');
-        const hasImportPath = nodeOptions.find((it) => typeof it === 'string' && it.includes(importPath));
-        if (!hasImportPath) {
-            nodeOptions.push('--import');
-            nodeOptions.push(importPath);
-        }
+        nodeOptions.push(`--import ${importPath}`);
     } else {
         const requirePath = getRegisterPath('register.js');
-        const hasRequirePath = nodeOptions.find((it) => typeof it === 'string' && it.includes(requirePath));
-        if (!hasRequirePath) {
-            nodeOptions.push('--require');
-            nodeOptions.push(requirePath);
-        }
+        nodeOptions.push(`--require ${requirePath}`);
     }
 
     // console.log(nodeOptions);
+    const nodeOptionsStr = nodeOptions.join(' ');
+    Util.logDebug(`node options: ${EC.cyan(nodeOptionsStr)}`);
 
-    process.env.NODE_OPTIONS = nodeOptions.join(' ');
+    process.env.NODE_OPTIONS = nodeOptionsStr;
 
 };
 
@@ -86,6 +111,7 @@ const executeCommand = async (command, cliOptions) => {
 
     Util.logInfo(`Execute: ${EC.cyan(command)}`);
 
+    // before load config
     await initNodeOptions(cliOptions);
 
     // console.log(options);
@@ -133,7 +159,8 @@ const executeCommand = async (command, cliOptions) => {
 };
 
 process.on('uncaughtException', function(err) {
-    Util.logError(`Process uncaughtException: ${err.message || err}`);
+    Util.logError(`Process uncaughtException: ${err.message}`);
+    console.log(err.stack);
 });
 
 // the -- separator
@@ -154,7 +181,7 @@ process.argv.forEach((it) => {
 program
     .name('mcr')
     .description('CLI to generate coverage reports')
-    .version(version)
+    .version(version, '-v, --version', 'output the current version')
     .argument('[command]', 'command to execute')
     .allowUnknownOption()
     .option('-c, --config <path>', 'custom config file path')

package/lib/client/cdp-client.js

@@ -12,10 +12,7 @@ const getDebuggerUrl = async (options) => {
     const protocol = options.secure ? 'https' : 'http';
 
     const url = `${protocol}://${options.host}:${options.port}/json/list`;
-    const [err, res] = await Util.request({
-        url,
-        timeout: options.timeout
-    });
+    const [err, res] = await Util.request(url);
     if (err) {
         return [err];
     }

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

@@ -19,9 +19,7 @@ const loadSourceMap = async (url = '') => {
         return JSON.parse(content);
     }
 
-    const [err, res] = await Util.request({
-        url
-    });
+    const [err, res] = await Util.request(url);
 
     if (err) {
         Util.logDebug(EC.red(`${err.message} ${url}`));

package/lib/converter/converter.js

@@ -5,8 +5,8 @@
  */
 
 const EC = require('eight-colors');
-const { Locator } = require('monocart-formatter');
 
+const { Locator } = require('monocart-locator');
 const Util = require('../utils/util.js');
 
 const findOriginalRange = require('./find-original-range.js');
@@ -984,9 +984,13 @@ const initOriginalList = (state, originalDecodedMap, options) => {
 
     const { sources, sourcesContent } = state.sourceMap;
 
+    const lengthBefore = sources.length;
+    let lengthAfter = 0;
+
     sources.forEach((sourcePath, sourceIndex) => {
 
         // filter
+        // do not change for sourceIndex
         if (!sourceFilter(sourcePath)) {
             // console.log('-', sourcePath);
             return;
@@ -1034,8 +1038,11 @@ const initOriginalList = (state, originalDecodedMap, options) => {
         };
 
         originalStateMap.set(sourceIndex, originalState);
+        lengthAfter += 1;
     });
 
+    Util.logFilter(`source filter (${state.sourcePath}):`, lengthBefore, lengthAfter);
+
     return originalStateMap;
 };
 
@@ -1044,6 +1051,8 @@ const collectOriginalList = (state, originalStateMap) => {
     const { fileUrls } = state;
     const distFile = state.sourcePath;
 
+    let added = 0;
+
     // collect original files
     originalStateMap.forEach((originalState) => {
 
@@ -1070,8 +1079,11 @@ const collectOriginalList = (state, originalStateMap) => {
         // save v8 data and add to originalList
         originalState.v8Data = sourceItem;
         state.originalList.push(originalState);
+        added += 1;
     });
 
+    Util.logDebug(`added source files: ${EC.yellow(added)}`);
+
 };
 
 // ========================================================================================================

package/lib/generate.js

@@ -686,6 +686,7 @@ const getInputData = async (inputList, all, cacheDir, addHandler) => {
     // dataList for data type, before `add` we don't which one is tested, because using hash id
     const emptyData = getEmptyData(all, dataList);
     if (emptyData) {
+        Util.logDebug(`added empty files for all: ${EC.yellow(emptyData.length)}`);
         const coverageResults = await addHandler(emptyData);
         // after `add`
         if (coverageResults) {
@@ -782,7 +783,11 @@ const readCoverageData = (filePath, entryFilter, sourceCache) => {
 
     // filter node internal files, should no anonymous for nodejs
     coverageData = coverageData.filter((entry) => entry.url && entry.url.startsWith('file:'));
+
+    const lengthBefore = coverageData.length;
     coverageData = coverageData.filter(entryFilter);
+    const lengthAfter = coverageData.length;
+    Util.logFilter('entry filter (addFromDir):', lengthBefore, lengthAfter);
 
     if (!Util.isList(coverageData)) {
         // Util.logDebug('No coverage data after filter');

package/lib/index.js

@@ -61,6 +61,9 @@ class CoverageReport {
             return;
         }
 
+        // before clean cache, do no call initOptions again in hasCache
+        this.fixedOptions = true;
+
         // init logging for clean after generated
         this.logging = Util.initLoggingLevel(this.options.logging);
 
@@ -79,7 +82,6 @@ class CoverageReport {
             this.cleanCache();
         }
 
-        this.fixedOptions = true;
     }
 
     // add coverage data: {array} V8 format, {object} Istanbul format