monocart-coverage-reports 2.7.5 → 2.7.7

package/lib/cli.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
 const path = require('path');
 const EC = require('eight-colors');
 
@@ -22,25 +21,12 @@ const getRegisterPath = (filename) => {
     return `./${rel}`;
 };
 
-const isFeatureSupported = (nv) => {
-    // module register added in Node.js: v20.6.0
-    const [major, minor] = nv.split('.').map((s) => parseInt(s));
-    if (major < 20) {
-        return false;
-    }
-    if (major > 20) {
-        return true;
-    }
-    if (minor < 6) {
-        return false;
-    }
-    return true;
-};
-
 const initNodeOptions = async (cliOptions) => {
+
+    // module register added in Node.js: v20.6.0
     const nv = process.versions.node;
-    if (!isFeatureSupported(nv)) {
-        Util.logInfo(EC.yellow(`The current Node.js version "${nv}" does NOT support "module.register", it requires "20.6.0" or higher.`));
+    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;
     }
 
@@ -133,11 +119,6 @@ const executeCommand = async (command, cliOptions) => {
         }
         // =========================================
 
-        if (!fs.existsSync(nodeV8CoverageDir)) {
-            EC.logRed(`Invalid V8 coverage dir: ${Util.relativePath(nodeV8CoverageDir)}`);
-            return 1;
-        }
-
         await coverageReport.addFromDir(nodeV8CoverageDir);
         await coverageReport.generate();
 
@@ -155,14 +136,29 @@ process.on('uncaughtException', function(err) {
     Util.logError(`Process uncaughtException: ${err.message || err}`);
 });
 
+// the -- separator
+const argv = [];
+const subArgv = [];
+let separator = false;
+process.argv.forEach((it) => {
+    if (!separator && it === '--') {
+        separator = true;
+    }
+    if (separator) {
+        subArgv.push(it);
+    } else {
+        argv.push(it);
+    }
+});
+
 program
     .name('mcr')
     .description('CLI to generate coverage reports')
     .version(version)
-    .argument('<command>', 'command to execute')
+    .argument('[command]', 'command to execute')
     .allowUnknownOption()
     .option('-c, --config <path>', 'custom config file path')
-    .option('--logging <logging>', 'off, error, info, debug')
+    .option('-l, --logging <logging>', 'off, error, info, debug')
 
     .option('-n, --name <name>', 'report name for title')
     .option('-r, --reports <name[,name]>', 'coverage reports to use')
@@ -183,8 +179,17 @@ program
     .option('--require <module>', 'preload module at startup')
 
     .action((_command, cliOptions) => {
-        const command = program.args.join(' ');
+        const args = [].concat(program.args).concat(subArgv);
+        if (args[0] === '--') {
+            args.shift();
+        }
+        const command = args.join(' ').trim();
+        if (!command) {
+            program.outputHelp();
+            return;
+        }
+
         executeCommand(command, cliOptions);
     });
 
-program.parse();
+program.parse(argv);

package/lib/client/cdp-client.js

@@ -4,7 +4,7 @@ const EC = require('eight-colors');
 const { WebSocket } = require('../packages/monocart-coverage-vendor.js');
 const Util = require('../utils/util.js');
 
-const CDPSession = require('./cdp-session.js');
+const WSSession = require('./ws-session.js');
 const CoverageClient = require('./coverage-client.js');
 
 const getDebuggerUrl = async (options) => {
@@ -85,7 +85,7 @@ const getCDPSession = async (options) => {
         ws.once('open', () => {
             clearTimeout(timeoutId);
             Util.logDebug(`${EC.green('Connected')} ${url}`);
-            const session = new CDPSession(ws);
+            const session = new WSSession(ws);
             resolve([null, session]);
         });
 

package/lib/client/coverage-client.js

@@ -131,19 +131,22 @@ class CoverageClient {
         unbindEvents(this.session, this.jsEvents);
         this.jsEvents = null;
 
-        const jsCoverage = profileResponse.result;
-        // console.log('coverageList', coverageList);
+        const jsCoverage = [];
 
-        jsCoverage.forEach((entry) => {
-            // anonymous url
-            entry.url = entry.url || '';
-            // add source
-            const source = this.scriptSources.get(entry.scriptId);
-            if (!source) {
-                Util.logDebug(`Not found js source: ${entry.url}`);
-            }
-            entry.source = source || '';
-        });
+        // console.log('coverageList', coverageList);
+        if (profileResponse && profileResponse.result) {
+            profileResponse.result.forEach((entry) => {
+                // anonymous url
+                entry.url = entry.url || '';
+                // add source
+                const source = this.scriptSources.get(entry.scriptId);
+                if (!source) {
+                    Util.logDebug(`Not found js source: ${entry.url}`);
+                }
+                entry.source = source || '';
+                jsCoverage.push(entry);
+            });
+        }
 
         this.scriptSources.clear();
         this.enabledJS = false;
@@ -239,22 +242,39 @@ class CoverageClient {
     }
 
     async stopCoverage() {
+        if (!this.session) {
+            return;
+        }
         const [jsCoverage, cssCoverage] = await Promise.all([
             this.stopJSCoverage(),
             this.stopCSSCoverage()
         ]);
-        return [... jsCoverage, ... cssCoverage];
+        // could be undefined
+        let coverageList = [];
+        if (jsCoverage) {
+            coverageList = coverageList.concat(jsCoverage);
+        }
+        if (cssCoverage) {
+            coverageList = coverageList.concat(cssCoverage);
+        }
+        return coverageList;
     }
 
     // =================================================================================================
     // write the coverage started by NODE_V8_COVERAGE to disk on demand
     async writeCoverage() {
-        // // enable and start v8 coverage
+        if (!this.session) {
+            return;
+        }
+
         await this.session.send('Runtime.enable');
 
-        //  write the coverage started by NODE_V8_COVERAGE to disk on demand
+        // write the coverage started by NODE_V8_COVERAGE to disk on demand
         const res = await this.session.send('Runtime.evaluate', {
-            expression: 'new Promise(resolve=>{ require("v8").takeCoverage(); resolve(process.env.NODE_V8_COVERAGE); })',
+            expression: `new Promise((resolve) => { 
+                require("v8").takeCoverage();
+                resolve(process.env.NODE_V8_COVERAGE);
+            })`,
             includeCommandLineAPI: true,
             returnByValue: true,
             awaitPromise: true
@@ -262,7 +282,31 @@ class CoverageClient {
 
         await this.session.send('Runtime.disable');
 
-        return res.result.value;
+        return res && res.result && res.result.value;
+    }
+
+    // get istanbul coverage data
+    async getIstanbulCoverage(coverageKey = '__coverage__') {
+        if (!this.session) {
+            return;
+        }
+
+        await this.session.send('Runtime.enable');
+
+        // both browser and Node.js
+        const res = await this.session.send('Runtime.evaluate', {
+            expression: `new Promise((resolve) => { 
+                const globalTarget = typeof window !== 'undefined' ? window : global;
+                resolve(globalTarget['${coverageKey}']);
+            })`,
+            includeCommandLineAPI: true,
+            returnByValue: true,
+            awaitPromise: true
+        });
+
+        await this.session.send('Runtime.disable');
+
+        return res && res.result && res.result.value;
     }
 
     // =================================================================================================
@@ -270,10 +314,8 @@ class CoverageClient {
         if (!this.session) {
             return;
         }
-
         await this.session.detach();
         this.session = null;
-
     }
 }
 

package/lib/client/{cdp-session.js → ws-session.js}

@@ -1,6 +1,6 @@
 const { EventEmitter } = require('events');
 
-class CDPSession extends EventEmitter {
+class WSSession extends EventEmitter {
     constructor(ws) {
         super();
         this.ws = ws;
@@ -60,4 +60,4 @@ class CDPSession extends EventEmitter {
     }
 }
 
-module.exports = CDPSession;
+module.exports = WSSession;

package/lib/converter/converter.js

@@ -3,10 +3,12 @@
  * @copyright https://github.com/cenfun/monocart-coverage-reports
  * @author cenfun@gmail.com
  */
-const Util = require('../utils/util.js');
 
-// position mapping for conversion between offset and line/column
+const EC = require('eight-colors');
 const { Locator } = require('monocart-formatter');
+
+const Util = require('../utils/util.js');
+
 const findOriginalRange = require('./find-original-range.js');
 const { getJsAstInfo, getCssAstInfo } = require('./ast.js');
 const { getIgnoredRanges } = require('./ignore.js');
@@ -1459,7 +1461,7 @@ const convertV8List = (v8list, options) => {
                 delete item.ranges;
             }
         }
-        Util.logTime(`- parsed ast: ${sourcePath}`, time_start_ast);
+        Util.logTime(`- parsed ast: ${sourcePath} (${EC.cyan(Util.BSF(maxContentLength))})`, time_start_ast);
 
         // console.log(sourcePath, astInfo.statements.length);
         // ============================
@@ -1476,6 +1478,7 @@ const convertV8List = (v8list, options) => {
             locator,
             maxContentLength,
             decodedMappings: [],
+            cacheMap: new Map(),
             // coverage info
             bytes: [],
             functions: [],
@@ -1491,7 +1494,8 @@ const convertV8List = (v8list, options) => {
 
         const time_start_unpack = Date.now();
         unpackDistFile(item, state, options);
-        Util.logTime(`- unpacked dist: ${sourcePath}`, time_start_unpack);
+        const unpackedFiles = EC.cyan(`${state.originalList.length} files`);
+        Util.logTime(`- unpacked dist: ${sourcePath} (${unpackedFiles})`, time_start_unpack);
 
         stateList.push(state);
 
@@ -1499,7 +1503,8 @@ const convertV8List = (v8list, options) => {
 
     const time_start_convert = Date.now();
     const dataList = generateV8DataList(stateList, options);
-    Util.logTime('- generated v8 data list', time_start_convert);
+    const dataFiles = EC.cyan(`${dataList.v8DataList.length} files`);
+    Util.logTime(`- generated data list (${dataFiles})`, time_start_convert);
 
     return dataList;
 };

package/lib/converter/find-original-range.js

@@ -820,16 +820,26 @@ const getMappingInfo = (start, end, state) => {
 
 const findOriginalRange = (start, end, state, originalMap) => {
 
-    const { sourcePath } = state;
+    const { sourcePath, cacheMap } = state;
+
+    const key = `${start}_${end}`;
+    if (cacheMap.has(key)) {
+        return cacheMap.get(key);
+    }
 
     const createMappingError = (errors) => {
-        return {
+        const res = {
             error: true,
             start,
             end,
             sourcePath,
             errors
         };
+
+        // cache error response
+        cacheMap.set(key, res);
+
+        return res;
     };
 
     const cache = getOriginalState(start, end, state, originalMap);
@@ -852,12 +862,23 @@ const findOriginalRange = (start, end, state, originalMap) => {
 
     const { originalState } = cache;
 
-    return {
+    const inComment = originalState.locator.lineParser.commentParser.isComment(originalStart, originalEnd);
+    if (inComment) {
+        return createMappingError(['the range in a original comment']);
+    }
+
+
+    const res = {
         start: originalStart,
         end: originalEnd,
         originalState
     };
 
+    // cache response
+    cacheMap.set(key, res);
+
+    return res;
+
 };
 
 module.exports = findOriginalRange;

package/lib/generate.js

@@ -21,7 +21,7 @@ const { getGroupedRows } = require('./utils/snapshot.js');
 
 // maybe v8 or to istanbul reports
 const generateV8ListReports = async (v8list, coverageData, fileSources, options) => {
-
+    const time_start = Date.now();
     let istanbulReportPath;
     // v8 to istanbul reports
     if (options.reportGroup.istanbul) {
@@ -32,7 +32,7 @@ const generateV8ListReports = async (v8list, coverageData, fileSources, options)
     // v8 reports and v8 coverage results
     // could be no v8 or v8-json, but requires v8 coverage results
     const v8CoverageResults = await saveV8Report(v8list, options, istanbulReportPath);
-
+    Util.logTime('- saved coverage reports', time_start);
     return v8CoverageResults;
 };
 
@@ -436,15 +436,10 @@ const getCoverageResults = async (dataList, sourceCache, options) => {
         // merge v8list first
         const v8list = await mergeV8Coverage(dataList, sourceCache, options);
         // console.log('after merge', v8list.map((it) => it.url));
-
-        // only debug level
-        const time_start = Date.now();
         const results = convertV8List(v8list, options);
         const {
             v8DataList, coverageData, fileSources
         } = results;
-        Util.logTime(`converted v8 list: ${v8DataList.length}`, time_start);
-
         return generateV8ListReports(v8DataList, coverageData, fileSources, options);
     }
 
@@ -806,7 +801,7 @@ const readCoverageData = (filePath, entryFilter, sourceCache) => {
 const readFromDir = async (dir, entryFilter, addHandler) => {
 
     if (!dir || !fs.existsSync(dir)) {
-        Util.logError(`Invalid V8 coverage dir: ${dir}`);
+        Util.logInfo(`Not found V8 coverage dir: ${dir}`);
         return;
     }
 

package/lib/index.d.ts

@@ -119,7 +119,7 @@ declare namespace MCR {
             outputDir?: string;
         }] |
         [string] | [string, {
-            type?: "v8" | "istanbul" | "both";
+            type?: "v8" | "istanbul" | "both" | string;
             [key: string]: any;
         }];
 
@@ -192,7 +192,7 @@ declare namespace MCR {
             ignores?: IgnoredRange[];
             /** codecov json format */
             lines: {
-                [key: string]: number | string
+                [key: string]: number | string;
             };
         }
     }
@@ -287,7 +287,7 @@ declare namespace MCR {
             */
             filter?: string | {
                 [pattern: string]: "js" | "css" | boolean;
-            } | ((filePath: string) => "js" | "css" | boolean)
+            } | ((filePath: string) => "js" | "css" | boolean);
         };
 
         /** (V8 only) {boolean} Enable/Disable ignoring uncovered codes with the special comments: v8 ignore next/next N/start/stop */
@@ -320,6 +320,7 @@ declare namespace MCR {
         /** {function} onEnd hook */
         onEnd?: (coverageResults: CoverageResults) => Promise<void>;
 
+        [key: string]: any;
     }
 
     export interface McrCliOptions extends CoverageReportOptions {
@@ -441,15 +442,27 @@ declare namespace MCR {
         stopCoverage: () => Promise<V8CoverageEntry[]>;
 
         /** write the coverage started by NODE_V8_COVERAGE to disk on demand, returns v8 coverage dir */
-        writeCoverage: () => Promise<string>
+        writeCoverage: () => Promise<string>;
 
+        /** get istanbul coverage data
+         * @param coverageKey defaults to `__coverage__`
+         */
+        getIstanbulCoverage: (coverageKey?: string) => Promise<any>;
     }
 
     /** Adapt to the CDPSession of Playwright or Puppeteer */
     export interface CDPSession {
         send: (method: string, params?: any) => Promise<any>;
         on: (type: string, handler: (e: any) => void) => void;
-        detach: () => Promise<void>
+        detach: () => Promise<void>;
+    }
+
+    /** custom websocket CDPSession */
+    export class WSSession implements CDPSession {
+        constructor(ws: any);
+        send: (method: string, params?: any) => Promise<any>;
+        on: (type: string, handler: (e: any) => void) => void;
+        detach: () => Promise<void>;
     }
 
     export interface CDPOptions {
@@ -464,7 +477,7 @@ declare namespace MCR {
         /** enable https, defaults to false (http) */
         secure?: boolean;
         /** target filter, defaults to first page */
-        target?: (targets) => any;
+        target?: (targets: any) => any;
         /** websocket options */
         ws?: any;
         /** timeout, defaults to 10 * 1000 */

package/lib/index.js

@@ -11,6 +11,8 @@ const {
     getInputData, readFromDir, generateCoverageReports
 } = require('./generate.js');
 const { getSnapshot, diffSnapshot } = require('./utils/snapshot.js');
+
+const WSSession = require('./client/ws-session.js');
 const CDPClient = require('./client/cdp-client.js');
 
 const resolveConfigOptions = async (configPath) => {
@@ -181,7 +183,7 @@ class CoverageReport {
             Util.rmSync(cacheDir);
         }
 
-        Util.logTime(`generated coverage reports: ${coverageResults.reportPath}`, time_start);
+        Util.logTime(`generated coverage reports: ${EC.cyan(coverageResults.reportPath)}`, time_start);
 
         const onEnd = this.options.onEnd;
         if (typeof onEnd === 'function') {
@@ -286,6 +288,7 @@ const MCR = function(options) {
 MCR.CoverageReport = CoverageReport;
 MCR.getSnapshot = getSnapshot;
 MCR.diffSnapshot = diffSnapshot;
+MCR.WSSession = WSSession;
 MCR.CDPClient = CDPClient;
 
 module.exports = MCR;

package/lib/index.mjs

@@ -3,4 +3,6 @@ export default MCR;
 export const CoverageReport = MCR.CoverageReport;
 export const getSnapshot = MCR.getSnapshot;
 export const diffSnapshot = MCR.diffSnapshot;
+
+export const WSSession = MCR.WSSession;
 export const CDPClient = MCR.CDPClient;