escover 6.1.2 → 6.2.1

package/ChangeLog

@@ -1,3 +1,21 @@
+2026.05.08, v6.2.1
+
+feature:
+- 53bbcfe escover: formatters: responsive: columns: push
+
+2026.05.08, v6.2.0
+
+fix:
+- fd9af89 escover: cli: no NODE_OPTIONS
+
+feature:
+- 424a044 escover: --help: add
+- 94d2b1c responsive: skipFull
+- 8b031eb responsive: indent
+- a9fee50 escover: formatters: responsive: add
+- 69a41a2 escover: formatters: improve colors
+- 9685940 formatters: files: colors
+
 2026.05.07, v6.1.2
 
 feature:

package/README.md

@@ -20,10 +20,6 @@ you have a couple problems to solve.
 
 ☝️ that's easy! 📼 [**Supertape**](https://github.com/coderaiser/supertape) supports `ESM` from the box;
 
-### 🤷‍  How to mock modules without [mock-require](https://github.com/boblauer/mock-require) (we in `ESM`!);
-
-☝️ that's solved! [`mock-import`](https://github.com/coderaiser/mock-import) does the thing using `loaders`;
-
 ### 🤷‍ How to get coverage when `nyc` doesn't supported?
 
 ☝️ `c8` could help, but [no](https://github.com/coderaiser/c8-reproduce) it supports no `query parameters`
@@ -88,28 +84,6 @@ There is two types of formatters:
 
 You can choose formatter with `ESCOVER_FORMAT` env variable.
 
-## What if I want to use 🎩`ESCover` with `mock-import`?
-
-[`mock-import`](https://github.com/coderaiser/mock-import) is used by default in 🎩`ESCover`.
-
-Install it with:
-
-```sh
-npm i escover
-```
-
-Then run:
-
-```sh
-escover npm test
-```
-
-This is the same as:
-
-```sh
-NODE_OPTIONS="'--loader zenlend'" ZENLOAD='escover,mock-import' escover npm test
-```
-
 ## Env
 
 If you want to disable coverage on status code without erroring, use `ESCOVER_SUCCESS_EXIT_CODE`:

package/help.json

@@ -0,0 +1,5 @@
+{
+    "--skip-full            ": "show only uncovered",
+    "-h, --help             ": "display this help and exit",
+    "-v, --version          ": "output version information and exit"
+}

package/lib/cli/cli.js

@@ -5,6 +5,9 @@ import yargsParser from 'yargs-parser';
 import {version} from './version.js';
 import reportLines from '../formatters/lines.js';
 import reportFiles from '../formatters/files.js';
+import reportResponsive from '../formatters/responsive.js';
+import {readConfig} from '../config.js';
+import {help} from './help.js';
 
 const {env} = process;
 
@@ -12,7 +15,7 @@ const noop = () => {};
 
 const {NODE_OPTIONS, ESCOVER_FORMAT} = env;
 
-export const createNodeOptions = (options = NODE_OPTIONS) => {
+export const createNodeOptions = (options = NODE_OPTIONS || '') => {
     if (!options.includes('escover/register'))
         return `--import escover/register ${options}`;
     
@@ -20,15 +23,18 @@ export const createNodeOptions = (options = NODE_OPTIONS) => {
 };
 
 export const cli = ({argv, exit, readCoverage}) => {
+    const {skipFull} = readConfig();
     const args = yargsParser(argv.slice(2), {
         string: ['format'],
-        boolean: ['version'],
+        boolean: ['version', 'skip-full', 'help'],
         alias: {
             v: 'version',
             f: 'format',
+            h: 'help',
         },
         default: {
-            format: ESCOVER_FORMAT || 'files',
+            'format': ESCOVER_FORMAT || 'responsive',
+            'skip-full': skipFull,
         },
     });
     
@@ -37,6 +43,16 @@ export const cli = ({argv, exit, readCoverage}) => {
         return exit();
     }
     
+    if (args.help) {
+        console.log(help());
+        return exit();
+    }
+    
+    if (args.help) {
+        console.log(help());
+        return exit();
+    }
+    
     const cmd = argv.slice(2);
     
     if (cmd.length)
@@ -48,6 +64,10 @@ export const cli = ({argv, exit, readCoverage}) => {
     
     if (args.format === 'lines')
         output = reportLines(coverage);
+    else if (args.format === 'responsive')
+        output = reportResponsive(coverage, {
+            skipFull: args.skipFull,
+        });
     else
         output = reportFiles(coverage);
     
@@ -57,7 +77,6 @@ export const cli = ({argv, exit, readCoverage}) => {
 export const isSuccess = (error) => !error || error?.status === Number(process.env.ESCOVER_SUCCESS_EXIT_CODE);
 
 function execute(cmd, exit) {
-    console.log(createNodeOptions());
     const [error] = tryCatch(execSync, cmd, {
         stdio: [0, 1, 2],
         env: {

package/lib/cli/help.js

@@ -0,0 +1,18 @@
+import helpJson from '../../help.json' with {
+    type: 'json',
+};
+
+const {entries} = Object;
+
+export const help = () => {
+    const result = [
+        'Usage: escover [options] [script]',
+        'Options:',
+    ];
+    
+    for (const [name, description] of entries(helpJson)) {
+        result.push(`  ${name} ${description}`);
+    }
+    
+    return result.join('\n');
+};

package/lib/config.js

@@ -34,6 +34,7 @@ export const readConfig = (overrides = {}) => {
         find = findUpSync,
         read = readFileSync,
     } = overrides;
+    
     const name = find('.nycrc.json');
     
     if (!name)

package/lib/coverage-file/coverage-file.js

@@ -36,6 +36,7 @@ export const readCoverage = (overrides = {}) => {
     const {
         read = readFileSync,
     } = overrides;
+    
     const dir = getCoverageDirectory();
     const [error, data] = tryCatch(read, join(dir, LCOV), 'utf8');
     

package/lib/formatters/files.js

@@ -9,6 +9,9 @@ const CWD = process.cwd();
 
 const {entries, keys} = Object;
 
+const makeGreen = chalk.hex('#4caf50');
+const makeRed = chalk.hex('#f44336');
+
 export default (coverageFile) => {
     const files = parseCoverageFile(coverageFile);
     
@@ -21,17 +24,17 @@ export default (coverageFile) => {
         
         if (covered) {
             tableData.push([
-                chalk.green(filename),
-                chalk.green(percentLines),
+                makeGreen(filename),
+                makeGreen(percentLines),
                 '',
             ]);
             continue;
         }
         
         tableData.push([
-            chalk.red(filename),
-            chalk.red(percentLines),
-            chalk.red(uncoveredLines),
+            makeRed(filename),
+            makeRed(percentLines),
+            makeRed(uncoveredLines),
         ]);
     }
     

package/lib/formatters/responsive.js

@@ -0,0 +1,276 @@
+import process from 'node:process';
+import {
+    table,
+    getBorderCharacters,
+} from 'table';
+import chalk from 'chalk';
+
+const CWD = process.cwd();
+const {entries, keys} = Object;
+
+const makeGreen = chalk.hex('#4caf50');
+const makeRed = chalk.hex('#f44336');
+
+export default (coverageFile, {skipFull = false} = {}) => {
+    const files = parseCoverageFile(coverageFile, skipFull);
+    
+    if (skipFull && !files.length)
+        return '💪 coverage 100% Good Job!\n';
+    
+    const totalWidth = process.stdout.columns || 80;
+    
+    let showPercent = false;
+    
+    if (totalWidth >= 70)
+        showPercent = true;
+    
+    let percentColWidth = 0;
+    
+    if (showPercent)
+        percentColWidth = 8;
+    
+    const fileColWidth = Math.floor(totalWidth * 0.45);
+    const linesColWidth = totalWidth - fileColWidth - percentColWidth - 6;
+    
+    const tableData = buildGroupedTable(files, showPercent);
+    
+    const columns = [{
+        paddingLeft: 1,
+        paddingRight: 1,
+        width: fileColWidth,
+        wrapWord: false,
+    }];
+    
+    if (showPercent)
+        columns.push({
+            alignment: 'center',
+            paddingLeft: 1,
+            paddingRight: 0,
+            width: percentColWidth,
+        });
+    
+    columns.push({
+        paddingLeft: 1,
+        paddingRight: 0,
+        width: linesColWidth,
+    });
+    
+    const options = {
+        drawHorizontalLine: (raw) => {
+            if (!raw)
+                return true;
+            
+            if (raw === 1)
+                return true;
+            
+            return raw === tableData.length;
+        },
+        
+        columns,
+        
+        border: {
+            ...getBorderCharacters('void'),
+            topBody: '-',
+            bottomBody: '-',
+            joinBody: '-',
+            topJoin: '|',
+            bottomJoin: '|',
+            joinJoin: '|',
+            bodyJoin: '|',
+        },
+    };
+    
+    return table(tableData, options);
+};
+
+function groupByFolder(files) {
+    const groups = new Map();
+    
+    for (const f of files) {
+        const parts = f.filename.split('/');
+        
+        let folder = '';
+        
+        if (parts.length > 1)
+            folder = parts
+                .slice(0, -1)
+                .join('/');
+        
+        const fileName = parts.at(-1);
+        
+        let group = groups.get(folder);
+        
+        if (!group) {
+            group = {
+                files: [],
+            };
+            groups.set(folder, group);
+        }
+        
+        group.files.push({
+            ...f,
+            shortName: fileName,
+        });
+    }
+    
+    return groups;
+}
+
+function buildGroupedTable(files, showPercent) {
+    const tableData = [];
+    
+    if (showPercent)
+        tableData.push([
+            'File',
+            '% Lines',
+            'Uncovered Lines #s',
+        ]);
+    else
+        tableData.push([
+            'File',
+            'Uncovered Lines #s',
+        ]);
+    
+    const groups = groupByFolder(files);
+    
+    for (const [folder, group] of groups) {
+        let sum = 0;
+        
+        for (const f of group.files)
+            sum += f.percentLines;
+        
+        let coverage = 100;
+        
+        if (group.files.length > 0)
+            coverage = Math.round(sum / group.files.length);
+        
+        let folderLabel = folder;
+        
+        if (!folderLabel)
+            folderLabel = '.';
+        
+        const trimmedFolder = trim(folderLabel, 25) + '/';
+        const folderName = makeRed(trimmedFolder);
+        
+        const headerRow = [folderName];
+        
+        if (showPercent) {
+            let color = makeRed;
+            
+            if (coverage === 100)
+                color = makeGreen;
+            
+            headerRow.push(color(`${coverage}%`));
+        }
+        
+        headerRow.push('');
+        tableData.push(headerRow);
+        
+        for (const f of group.files) {
+            const fileCell = ' ' + trim(f.shortName, 30);
+            
+            let fileColor = makeRed;
+            
+            if (f.covered)
+                fileColor = makeGreen;
+            
+            const row = [fileColor(fileCell)];
+            
+            if (showPercent) {
+                let percentColor = makeRed;
+                
+                if (f.percentLines === 100)
+                    percentColor = makeGreen;
+                
+                row.push(percentColor(`${f.percentLines}%`));
+            }
+            
+            let uncovered = '';
+            
+            if (!f.covered)
+                uncovered = makeRed(formatLines(f.lines));
+            
+            row.push(uncovered);
+            
+            tableData.push(row);
+        }
+    }
+    
+    return tableData;
+}
+
+function parseCoverageFile(coverageFile, skipFull) {
+    const files = [];
+    
+    for (const {name, lines} of coverageFile) {
+        const uncovered = parseUncoveredLines(lines);
+        
+        const linesCount = keys(lines).length;
+        const uncoveredCount = uncovered.length;
+        
+        const percentLines = getLinesPercent(linesCount, uncoveredCount);
+        
+        let covered = true;
+        
+        if (uncoveredCount > 0)
+            covered = false;
+        
+        if (skipFull && covered)
+            continue;
+        
+        files.push({
+            filename: name.replace(`${CWD}/`, ''),
+            covered,
+            lines: uncovered,
+            percentLines,
+        });
+    }
+    
+    return files;
+}
+
+function trim(str, max) {
+    if (str.length <= max)
+        return str;
+    
+    return '...' + str.slice(-(max - 3));
+}
+
+export function formatLines(array) {
+    if (array.length <= 10) {
+        const joined = array.join(', ');
+        
+        if (joined.length <= 30)
+            return joined;
+    }
+    
+    const [first] = array;
+    const last = array.at(-1);
+    
+    const base = first + '..' + last;
+    
+    if (base.length <= 30)
+        return base;
+    
+    return last;
+}
+
+function parseUncoveredLines(lines) {
+    const out = [];
+    
+    for (const [line, covered] of entries(lines)) {
+        if (!covered)
+            out.push(line);
+    }
+    
+    return out;
+}
+
+export function getLinesPercent(linesCount, uncoveredLinesCount) {
+    if (!linesCount)
+        return 100;
+    
+    const ratio = 100 / linesCount * uncoveredLinesCount;
+    
+    return 100 - Math.round(ratio);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "escover",
-  "version": "6.1.2",
+  "version": "6.2.1",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Coverage for EcmaScript Modules",
   "main": "lib/escover.js",