monocart-coverage-reports 2.10.4 → 2.10.6

package/lib/generate.js

@@ -1,9 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { pathToFileURL, fileURLToPath } = require('url');
-
-const EC = require('eight-colors');
-const { minimatch } = require('./packages/monocart-coverage-vendor.js');
+const { fileURLToPath } = require('url');
 
 const Util = require('./utils/util.js');
 const { convertV8List } = require('./converter/converter.js');
@@ -178,7 +175,7 @@ const getCoverageResults = async (dataList, sourceCache, options) => {
         // console.log('after merge', v8list.map((it) => it.url));
 
         const t2 = Date.now();
-        const results = convertV8List(v8list, options);
+        const results = await convertV8List(v8list, options);
         Util.logTime('┌ [generate] converted coverage data', t2);
 
         const {
@@ -189,7 +186,7 @@ const getCoverageResults = async (dataList, sourceCache, options) => {
 
     // istanbul data
     const t3 = Date.now();
-    const istanbulData = mergeIstanbulCoverage(dataList);
+    const istanbulData = await mergeIstanbulCoverage(dataList, options);
     const { coverageData, fileSources } = initIstanbulData(istanbulData, options);
     Util.logTime('┌ [generate] prepared istanbul coverage data', t3);
     const results = await saveIstanbulReports(coverageData, fileSources, options);
@@ -219,187 +216,6 @@ const generateCoverageReports = async (dataList, sourceCache, options) => {
     return coverageResults;
 };
 
-// ========================================================================================================
-
-const resolveAllDirList = (input) => {
-    const dirs = Util.toList(input, ',');
-    if (!dirs.length) {
-        return;
-    }
-    const dirList = dirs.filter((it) => fs.existsSync(it));
-    if (!dirList.length) {
-        return;
-    }
-    return dirList;
-};
-
-const resolveAllFilter = (input) => {
-    // for function handler
-    if (typeof input === 'function') {
-        return input;
-    }
-
-    // for single minimatch pattern
-    if (input && typeof input === 'string') {
-        // string to multiple patterns "{...}"
-        const obj = Util.strToObj(input);
-        if (obj) {
-            input = obj;
-        } else {
-            return (filePath) => {
-                return minimatch(filePath, input);
-            };
-        }
-    }
-
-    // for patterns
-    if (input && typeof input === 'object') {
-        const patterns = Object.keys(input);
-        return (filePath) => {
-            for (const pattern of patterns) {
-                if (minimatch(filePath, pattern)) {
-                    return input[pattern];
-                }
-            }
-            // false if not matched
-        };
-    }
-
-    // default
-    return () => true;
-};
-
-const resolveAllDataType = (type, dataList) => {
-    if (!type && dataList.length) {
-        const firstData = dataList[0];
-        type = firstData.type;
-    }
-    const types = {
-        v8: 'v8',
-        istanbul: 'istanbul'
-    };
-    return types[type] || types.v8;
-};
-
-const resolveAllOptions = (input, dataList) => {
-    if (!input) {
-        return;
-    }
-
-    let type;
-    let dir;
-    let filter;
-
-    if (typeof input === 'string') {
-        const obj = Util.strToObj(input);
-        if (obj) {
-            type = obj.type;
-            dir = obj.dir;
-            filter = obj.filter;
-        } else {
-            dir = input;
-        }
-    } else if (Array.isArray(input)) {
-        dir = input;
-    } else {
-        type = input.type;
-        dir = input.dir;
-        filter = input.filter;
-    }
-
-    const dirList = resolveAllDirList(dir);
-    if (!dirList) {
-        return;
-    }
-
-    const dataType = resolveAllDataType(type, dataList);
-    const fileFilter = resolveAllFilter(filter);
-
-    return {
-        dirList,
-        dataType,
-        fileFilter
-    };
-};
-
-const resolveFileType = (fileType, filePath) => {
-    if (fileType === 'js' || fileType === 'css') {
-        return fileType;
-    }
-    const extname = path.extname(filePath);
-    if (['.css', '.scss', '.sass', '.less'].includes(extname)) {
-        return 'css';
-    }
-    return 'js';
-};
-
-const getV8EmptyData = (fileList) => {
-    const v8DataList = [];
-    fileList.forEach((item) => {
-        const { filePath, fileType } = item;
-        const type = resolveFileType(fileType, filePath);
-        const url = pathToFileURL(filePath).toString();
-        const source = Util.readFileSync(filePath);
-        const entryFile = {
-            empty: true,
-            type,
-            url,
-            // for empty, css supports both source and text
-            source
-        };
-        v8DataList.push(entryFile);
-    });
-    return v8DataList;
-};
-
-const getIstanbulEmptyData = (fileList) => {
-    const istanbulData = {};
-    fileList.forEach((item) => {
-        const { filePath } = item;
-        istanbulData[filePath] = {
-            path: filePath,
-            statementMap: {},
-            fnMap: {},
-            branchMap: {},
-            s: {},
-            f: {},
-            b: {}
-        };
-    });
-    return istanbulData;
-};
-
-const getEmptyData = (all, dataList) => {
-    const allOptions = resolveAllOptions(all, dataList);
-    // console.log('allOptions', all, allOptions);
-    if (!allOptions) {
-        return;
-    }
-    const {
-        dirList, dataType, fileFilter
-    } = allOptions;
-    const fileList = [];
-    dirList.forEach((dir) => {
-        Util.forEachFile(dir, [], (fileName, fileDir) => {
-            const filePath = path.resolve(fileDir, fileName);
-            const fileType = fileFilter(filePath);
-            if (fileType) {
-                fileList.push({
-                    filePath,
-                    fileType
-                });
-            }
-        });
-    });
-    // console.log('fileList', fileList);
-    if (!fileList.length) {
-        return;
-    }
-    if (dataType === 'v8') {
-        return getV8EmptyData(fileList);
-    }
-    return getIstanbulEmptyData(fileList);
-};
 
 // ========================================================================================================
 
@@ -448,55 +264,6 @@ const addJsonData = async (mcr, dataList, sourceCache, dir, filename) => {
     }
 };
 
-const addEmptyData = async (mcr, dataList, sourceCache) => {
-
-    const { all, cacheDir } = mcr.options;
-    // add empty coverage for all files
-    // dataList for data type, before `add` we don't which one is tested, because using hash id
-    const emptyData = getEmptyData(all, dataList);
-    if (!emptyData) {
-        return;
-    }
-
-    let files = 0;
-    if (Util.isList(emptyData)) {
-        files = emptyData.length;
-    } else {
-        files = Object.keys(emptyData).length;
-    }
-
-    Util.logDebug(`added all files with empty coverage: ${EC.yellow(files)}`);
-    const coverageResults = await mcr.add(emptyData);
-    // after `add`
-    if (!coverageResults) {
-        return;
-    }
-
-    dataList.push(coverageResults);
-
-    if (coverageResults.type === 'v8') {
-        // sourceCache
-        coverageResults.data.forEach((entry) => {
-            const { id } = entry;
-            if (sourceCache.has(id)) {
-                // console.log('+', entry.sourcePath);
-                return;
-            }
-            // console.log('-', entry.sourcePath);
-            const { cacheName, cachePath } = Util.getCacheFileInfo('source', id, cacheDir);
-            if (mcr.fileCache.has(cacheName)) {
-                const json = mcr.fileCache.get(cacheName);
-                sourceCache.set(json.id, json);
-            } else {
-                const content = Util.readFileSync(cachePath);
-                if (content) {
-                    const json = JSON.parse(content);
-                    sourceCache.set(json.id, json);
-                }
-            }
-        });
-    }
-};
 
 const getInputData = async (mcr) => {
 
@@ -520,8 +287,6 @@ const getInputData = async (mcr) => {
         }
     }
 
-    await addEmptyData(mcr, dataList, sourceCache);
-
     if (!dataList.length) {
         const dirs = inputList.map((dir) => Util.relativePath(dir));
         Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);

package/lib/index.d.ts

@@ -359,8 +359,7 @@ declare namespace MCR {
         all?: string | string[] | {
             /** the dir(s) of all files */
             dir: string | string[];
-            /** the coverage data type, v8 or istanbul */
-            type?: "v8" | "istanbul";
+
             /** 
              * the file filter, return the file type, if true, defaults to css if ".css" otherwise is js 
              * 
@@ -369,6 +368,14 @@ declare namespace MCR {
             filter?: string | {
                 [pattern: string]: "js" | "css" | boolean;
             } | ((filePath: string) => "js" | "css" | boolean);
+
+            /**
+             * the file transformer for source and sourceMap
+             * some of untested files like .ts/.jsx/.vue can not be parsed to AST directly by acorn
+             * so this is the function which can transform the original source to generated source and sourceMap
+             */
+            transformer?: (entry: any) => Promise<void>;
+
         };
 
         /** (V8 only) {boolean} Enable/Disable ignoring uncovered codes with the special comments: v8 ignore next/next N/start/stop */

package/lib/istanbul/istanbul.js

@@ -8,6 +8,7 @@ const Util = require('../utils/util.js');
 const IstanbulSummary = require('./istanbul-summary.js');
 
 const { initIstanbulSourcePath } = require('../utils/source-path.js');
+const { getUntestedList } = require('../converter/untested.js');
 
 const findHtmlPath = (outputDir) => {
     const defaultHtml = path.resolve(outputDir, 'index.html');
@@ -121,18 +122,42 @@ const saveIstanbulReports = (coverageData, fileSources, options) => {
     return coverageResults;
 };
 
-const mergeIstanbulCoverage = (dataList) => {
+const addUntestedFiles = async (istanbulData, options) => {
+    const testedMap = new Map();
+    Object.keys(istanbulData).forEach((filePath) => {
+        const sourcePath = Util.relativePath(filePath);
+        testedMap.set(sourcePath, true);
+    });
+
+    // untested files
+    const untestedList = await getUntestedList(testedMap, options, 'istanbul');
+    if (!untestedList) {
+        return;
+    }
+
+    // console.log('istanbul untestedList', untestedList);
+    untestedList.forEach((item) => {
+        if (!istanbulData[item.path]) {
+            istanbulData[item.path] = item;
+        }
+    });
+
+};
+
+const mergeIstanbulCoverage = async (dataList, options) => {
     const istanbulCoverageList = dataList.map((it) => it.data);
     const coverageMap = istanbulLibCoverage.createCoverageMap();
     istanbulCoverageList.forEach((coverage) => {
         coverageMap.merge(coverage);
     });
     const istanbulData = coverageMap.toJSON();
+
+    await addUntestedFiles(istanbulData, options);
+
     return istanbulData;
 };
 
 const initIstanbulData = (istanbulData, options) => {
-
     const fileSources = options.fileSources || {};
     const coverageData = initIstanbulSourcePath(istanbulData, fileSources, options);