monocart-coverage-reports 2.7.4 → 2.7.6

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');
 
@@ -133,11 +132,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 +149,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 +192,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/{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/ast-visitor.js

@@ -8,6 +8,12 @@ const BranchTypes = {
     AssignmentPattern: 'AssignmentPattern'
 };
 
+const setGeneratedOnly = (block, generatedOnly) => {
+    if (block && generatedOnly) {
+        block.generatedOnly = true;
+    }
+};
+
 const getParentFunctionState = (reverseParents) => {
     const parentFunction = reverseParents.find((it) => it._state && it._state.isFunction);
     if (!parentFunction) {
@@ -266,6 +272,7 @@ const updateBranchCount = (group) => {
     const groupBlock = getFunctionBlock(group.start, group.end, functionState);
     if (groupBlock) {
         parentCount = groupBlock.count;
+        setGeneratedOnly(groupBlock, group.generatedOnly);
     }
 
     // calculate branches count
@@ -277,6 +284,7 @@ const updateBranchCount = (group) => {
             return;
         }
         item.block = getFunctionBlock(start, end, functionState);
+        setGeneratedOnly(item.block, group.generatedOnly);
     });
 
 
@@ -314,12 +322,16 @@ const generateBranches = (branchMap) => {
             }
         });
 
-        branches.push({
+        const branch = {
             type: group.type,
             start: group.start,
             end: group.end,
             locations: group.locations
-        });
+        };
+
+        setGeneratedOnly(branch, group.generatedOnly);
+
+        branches.push(branch);
     });
 
     // sort branches
@@ -395,6 +407,34 @@ const generateStatements = (statementNodes) => {
     return statements;
 };
 
+// =======================================================================================
+// handle special generated codes for original coverage
+
+const webpackWrapHandler = (node) => {
+    // ignore webpack wrap for original function
+    // id: { type: 'Identifier', name: '__webpack_modules__' },
+    const name = node.id && node.id.name;
+    if (name === '__webpack_modules__' && node.init && node.init.properties) {
+        // mark all as wrap function
+        node.init.properties.forEach((it) => {
+            it.value._webpackWrapKey = it.key && it.key.value;
+        });
+        // console.log('==========================', node.type);
+        // console.log(name, parents.length);
+    }
+};
+
+const viteImportDefaultHandler = (node, group) => {
+    // ignore vite conditional expression for __esModule default
+    const testObj = node.test.object;
+    const testName = testObj && testObj.name;
+    if (testName && testName.startsWith('__vite__cjsImport')) {
+        setGeneratedOnly(group, true);
+    }
+
+};
+
+
 // =======================================================================================
 
 const collectNodes = (ast) => {
@@ -409,18 +449,7 @@ const collectNodes = (ast) => {
 
         VariableDeclarator(node, parents) {
 
-            // =============================================================
-            // id: { type: 'Identifier', name: '__webpack_modules__' },
-            const name = node.id && node.id.name;
-            if (name === '__webpack_modules__' && node.init && node.init.properties) {
-                // mark all as wrap function
-                node.init.properties.forEach((it) => {
-                    it.value._wrapKey = it.key && it.key.value;
-                });
-                // console.log('==========================', node.type);
-                // console.log(name, parents.length);
-            }
-            // =============================================================
+            webpackWrapHandler(node);
 
         },
 
@@ -473,10 +502,14 @@ const collectNodes = (ast) => {
         // Ternary
         // var b = a ? 'consequent' : 'alternate';
         ConditionalExpression: (node, parents) => {
+
             const { consequent, alternate } = node;
             const group = createBranchGroup(BranchTypes.ConditionalExpression, node, parents, branchMap);
             addBranch(group, consequent, locationMap);
             addBranch(group, alternate, locationMap);
+
+            viteImportDefaultHandler(node, group);
+
         },
 
         // if an if statement; can also be else if.
@@ -619,7 +652,7 @@ const collectAstInfo = (ast, coverageInfo) => {
         const bodyStart = node.body.start;
         const bodyEnd = node.body.end;
         const functionName = id && id.name;
-        const isWrap = Boolean(node._wrapKey);
+        const _webpackWrapKey = node._webpackWrapKey;
 
         const functionItem = {
             start,
@@ -629,9 +662,9 @@ const collectAstInfo = (ast, coverageInfo) => {
             functionName,
             count: rootState.count
         };
-        if (isWrap) {
-            functionItem.wrap = true;
-        }
+
+        setGeneratedOnly(functionItem, _webpackWrapKey);
+
         functions.push(functionItem);
 
         const functionState = {
@@ -641,9 +674,9 @@ const collectAstInfo = (ast, coverageInfo) => {
 
         const functionRange = findFunctionRange(item, coverageInfo);
         if (functionRange) {
-            if (isWrap) {
-                functionRange.wrap = true;
-            }
+
+            setGeneratedOnly(functionRange, _webpackWrapKey);
+
             functionState.range = functionRange;
             functionState.count = functionRange.count;
             functionItem.count = functionRange.count;

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

@@ -28,7 +28,14 @@ const loadSourceMap = async (url = '') => {
         return;
     }
 
-    return res.data;
+    const content = res.data;
+
+    // could be string not json, if Content-Type is application/octet-stream
+    if (typeof content === 'string') {
+        return JSON.parse(content);
+    }
+
+    return content;
 };
 
 const getSourceMapUrl = (content, url) => {

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');
@@ -510,6 +512,11 @@ const handleOriginalBytesCoverage = (state) => {
 
 const handleGeneratedBytesCoverage = (state) => {
 
+    // it could be a dist file, do not handle twice
+    if (state.addedGeneratedBytes) {
+        return;
+    }
+
     const { js, coverageList } = state;
 
     if (js) {
@@ -524,6 +531,8 @@ const handleGeneratedBytesCoverage = (state) => {
         });
     }
 
+    state.addedGeneratedBytes = true;
+
 };
 
 // ========================================================================================================
@@ -551,15 +560,16 @@ const handleOriginalFunctionsCoverage = (state, originalStateMap) => {
 
     // function count
     state.astInfo.functions.forEach((it) => {
-        const {
-            start, end, bodyStart, bodyEnd, wrap
-        } = it;
 
         // remove webpack wrap functions for functions count, not for ranges here
-        if (wrap) {
+        if (it.generatedOnly) {
             return;
         }
 
+        const {
+            start, end, bodyStart, bodyEnd
+        } = it;
+
         const result = findOriginalRange(start, end, state, originalStateMap);
         if (result.error) {
             logMappingErrors('function', result);
@@ -598,6 +608,10 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
     // function count
     state.astInfo.branches.forEach((group) => {
 
+        if (group.generatedOnly) {
+            return;
+        }
+
         const { type, locations } = group;
 
         // start
@@ -668,6 +682,11 @@ const handleOriginalStatementsCoverage = (state, originalStateMap) => {
 
     // statement count
     state.astInfo.statements.forEach((it) => {
+
+        if (it.generatedOnly) {
+            return;
+        }
+
         const { start, end } = it;
 
         const result = findOriginalRange(start, end, state, originalStateMap);
@@ -799,11 +818,10 @@ const handleAllOriginalBytesCoverage = (state, originalStateMap) => {
 
     // v8 coverage
     coverageList.forEach((block) => {
-        block.ranges.forEach((range, index) => {
+        block.ranges.forEach((range) => {
 
             // remove wrap functions for original files
-            if (range.wrap) {
-                // console.log(range);
+            if (range.generatedOnly) {
                 return;
             }
 
@@ -1443,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);
         // ============================
@@ -1460,6 +1478,7 @@ const convertV8List = (v8list, options) => {
             locator,
             maxContentLength,
             decodedMappings: [],
+            cacheMap: new Map(),
             // coverage info
             bytes: [],
             functions: [],
@@ -1475,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);
 
@@ -1483,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

@@ -119,8 +119,32 @@ const alignText = (gt, ot) => {
     return gl;
 };
 
+const getWordEndPosition = (list, gp, direction) => {
+    // for end only
+    if (direction !== 'end') {
+        return;
+    }
+
+    const prev = list[gp - 1];
+    if (prev && prev.original && prev.wordEnd) {
+        const op = prev.original.index + 1;
+        // console.log(gp, JSON.stringify(gt));
+        // console.log(op, JSON.stringify(ot));
+        return {
+            pos: op
+        };
+    }
+};
+
 const getAlignPosition = (gt, gp, ot, direction) => {
 
+    // there is no need to align for long text
+    const maxLength = 500;
+    if (gt.length > maxLength || ot.length > maxLength) {
+        // console.log(gt.length, ot.length, gp);
+        return;
+    }
+
     // generatedText: '"false";\n',
     // originalText: "'false';\r\n    ",
     // generatedPos: 7
@@ -147,20 +171,7 @@ const getAlignPosition = (gt, gp, ot, direction) => {
     }
 
     // inclusive, for end only
-    if (gp && direction === 'end') {
-        const prev = list[gp - 1];
-        if (prev && prev.original && prev.wordEnd) {
-            // console.log(direction, '=====================================================================');
-            const op = prev.original.index + 1;
-            // console.log(gp, JSON.stringify(gt));
-            // console.log(op, JSON.stringify(ot));
-
-            return {
-                pos: op
-            };
-
-        }
-    }
+    return getWordEndPosition(list, gp, direction);
 
 };
 
@@ -252,13 +263,19 @@ const getComparedPosition = (info, direction) => {
     const gt = info.generatedText;
     const gp = info.generatedPos;
     const ot = info.originalText;
+    const olt = info.originalLineText;
+
+    // seems direction is start only
+    if (gp === 0) {
+        return;
+    }
 
     // whole generated text
     if (gp >= gt.length) {
         // console.log(JSON.stringify(gt), gt.length, gp);
         // console.log(JSON.stringify(ot));
         return {
-            pos: info.originalLineText.length
+            pos: olt.length
         };
     }
 
@@ -803,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);
@@ -835,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

@@ -452,6 +452,14 @@ declare namespace MCR {
         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 {
         /** Adapt to the CDPSession of Playwright or Puppeteer */
         session?: CDPSession;

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;