escover 6.1.1 → 6.2.0

package/ChangeLog

@@ -1,3 +1,21 @@
+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:
+- efe5be9 escover: add support of json
+
 2026.05.07, v6.1.1
 
 fix:

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,
         },
     });
     
@@ -36,6 +42,16 @@ export const cli = ({argv, exit, readCoverage}) => {
         console.log(`v${version()}`);
         return exit();
     }
+
+    if (args.help) {
+        console.log(help());
+        return exit();
+    }
+    
+    if (args.help) {
+        console.log(help());
+        return exit();
+    }
     
     const cmd = argv.slice(2);
     
@@ -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: {
@@ -74,4 +93,3 @@ function execute(cmd, exit) {
         return exit(1);
     }
 }
-

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

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

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

@@ -15,4 +15,3 @@ export function createCoverageDirectory() {
     
     return name;
 }
-

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

@@ -1,7 +1,6 @@
 import {writeFileSync, readFileSync} from 'node:fs';
 import {join} from 'node:path';
 import {tryCatch} from 'try-catch';
-import {operator} from 'putout';
 import {getFileEntries} from '../c4.js';
 import {transform} from '../transform.js';
 import {merge} from '../merge.js';
@@ -11,8 +10,6 @@ import {
 } from './coverage-directory.js';
 import {generateLcov, parseLcov} from './lcov.js';
 
-const {getFile} = operator;
-
 const LCOV = 'lcov.info';
 
 export const writeCoverage = (overrides = {}) => {
@@ -36,7 +33,10 @@ export const writeCoverage = (overrides = {}) => {
 };
 
 export const readCoverage = (overrides = {}) => {
-    const {read = readFileSync} = overrides;
+    const {
+        read = readFileSync,
+    } = overrides;
+    
     const dir = getCoverageDirectory();
     const [error, data] = tryCatch(read, join(dir, LCOV), 'utf8');
     
@@ -45,4 +45,3 @@ export const readCoverage = (overrides = {}) => {
     
     return parseLcov(data);
 };
-

package/lib/escover.js

@@ -25,7 +25,7 @@ export function load(url, context, defaultLoad) {
     if (!url.includes(CWD))
         return result;
     
-    if (/commonjs|builtin/.test(format))
+    if (/json|commonjs|builtin/.test(format))
         return result;
     
     if (isExclude(url, EXCLUDE))

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,242 @@
+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;
+    const showPercent = totalWidth >= 70;
+    
+    const percentColWidth = showPercent ? 8 : 0;
+    const fileColWidth = Math.floor(totalWidth * 0.45);
+    
+    const linesColWidth = totalWidth - fileColWidth - percentColWidth - 6;
+    
+    const tableData = buildGroupedTable(files, showPercent);
+    
+    return table(tableData, {
+        drawHorizontalLine: (raw) => !raw || raw === 1 || raw === tableData.length,
+        
+        columns: [{
+            paddingLeft: 1,
+            paddingRight: 1,
+            width: fileColWidth,
+            wrapWord: false, // 🔥 ключевой фикс — без переносов
+        }, ...showPercent ? [{
+            alignment: 'center',
+            paddingLeft: 1,
+            paddingRight: 0,
+            width: percentColWidth,
+        }] : [], {
+            paddingLeft: 1,
+            paddingRight: 0,
+            width: linesColWidth,
+        }],
+        
+        border: {
+            ...getBorderCharacters('void'),
+            topBody: '-',
+            bottomBody: '-',
+            joinBody: '-',
+            topJoin: '|',
+            bottomJoin: '|',
+            joinJoin: '|',
+            bodyJoin: '|',
+        },
+    });
+};
+
+/* =========================
+   GROUPING + COVERAGE
+========================= */
+function groupByFolder(files) {
+    const groups = new Map();
+    
+    for (const f of files) {
+        const parts = f.filename.split('/');
+        const folder = parts.length > 1 ? parts
+            .slice(0, -1)
+            .join('/') : '';
+        
+        const fileName = parts.at(-1);
+        
+        if (!groups.has(folder))
+            groups.set(folder, {
+                files: [],
+            });
+        
+        const group = groups.get(folder);
+        
+        group.files.push({
+            ...f,
+            shortName: fileName,
+        });
+    }
+    
+    return groups;
+}
+
+/* =========================
+   TABLE BUILDER
+========================= */
+function buildGroupedTable(files, showPercent) {
+    const tableData = [
+        showPercent ? [
+            'File',
+            '% Lines',
+            'Uncovered Lines #s',
+        ] : [
+            'File',
+            'Uncovered Lines #s',
+        ],
+    ];
+    
+    const groups = groupByFolder(files);
+    
+    for (const [folder, group] of groups) {
+        const coverage = group.files.length ? Math.round(group.files.reduce((sum, f) => sum + f.percentLines, 0) / group.files.length) : 100;
+        
+        const folderLabel = formatFolder(folder || '.');
+        
+        const folderName = makeRed(`${folderLabel}/`);
+        
+        const folderPercentColor = coverage === 100 ? makeGreen : makeRed;
+        
+        const headerRow = [folderName];
+        
+        if (showPercent)
+            headerRow.push(folderPercentColor(`${coverage}%`));
+        
+        headerRow.push('');
+        
+        tableData.push(headerRow);
+        
+        for (const f of group.files) {
+            const fileCell = ` ${formatPath(f.shortName)}`;
+            const uncoveredLines = formatLines(f.lines);
+            
+            const filePercentColor = f.percentLines === 100 ? makeGreen : makeRed;
+            
+            const row = [
+                f.covered ? makeGreen(fileCell) : makeRed(fileCell),
+            ];
+            
+            if (showPercent)
+                row.push(filePercentColor(`${f.percentLines}%`));
+            
+            row.push(f.covered ? '' : makeRed(uncoveredLines));
+            
+            tableData.push(row);
+        }
+    }
+    
+    return tableData;
+}
+
+/* =========================
+   PARSE
+========================= */
+function parseCoverageFile(coverageFile, skipFull = false) {
+    const files = [];
+    
+    for (const {name, lines} of coverageFile) {
+        const filename = name.replace(`${CWD}/`, '');
+        const uncoveredLines = parseUncoveredLines(lines);
+        
+        const linesCount = keys(lines).length;
+        const uncoveredLinesCount = uncoveredLines.length;
+        
+        const percentLines = getLinesPercent(linesCount, uncoveredLinesCount);
+        
+        const isCovered = !uncoveredLinesCount;
+        
+        if (skipFull && isCovered)
+            continue;
+        
+        files.push({
+            filename,
+            covered: isCovered,
+            lines: uncoveredLines,
+            percentLines,
+        });
+    }
+    
+    return files;
+}
+
+/* =========================
+   FORMATTERS
+========================= */
+function formatPath(path) {
+    const max = 30;
+    
+    if (path.length <= max)
+        return path;
+    
+    return `...${path.slice(-(max - 3))}`;
+}
+
+function formatFolder(path) {
+    const max = 25;
+    
+    if (path.length <= max)
+        return path;
+    
+    return `...${path.slice(-(max - 3))}`;
+}
+
+export function formatLines(array) {
+    const max = 30;
+    
+    if (array.length <= 10) {
+        const joined = array.join(', ');
+        
+        if (joined.length <= max)
+            return joined;
+    }
+    
+    const [first] = array;
+    const last = array.at(-1);
+    
+    const base = `${first}..${last}`;
+    
+    if (base.length <= max)
+        return base;
+    
+    return String(last);
+}
+
+/* =========================
+   HELPERS
+========================= */
+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;
+    
+    return 100 - Math.round(100 / linesCount * uncoveredLinesCount);
+}

package/lib/instrument/index.js

@@ -1,11 +1,14 @@
 import putout from 'putout';
 import * as convertOptionalToLogical from '@putout/plugin-convert-optional-to-logical';
+import {tryCatch} from 'try-catch';
 import * as mark from './plugin-mark/index.js';
 
+const {assign} = Object;
+
 export const instrument = (url, source) => {
     const c4 = globalThis.__createC4(url);
     
-    const {code} = putout(source, {
+    const [error, result] = tryCatch(putout, source, {
         printer: 'putout',
         fixCount: 1,
         rules: {
@@ -19,5 +22,14 @@ export const instrument = (url, source) => {
         ],
     });
     
+    if (error) {
+        assign(error, {
+            message: `${url}: ${error.message}`,
+        });
+        throw error;
+    }
+    
+    const {code} = result;
+    
     return code;
 };

package/lib/register.js

@@ -8,4 +8,3 @@ registerHooks(escoverLoader);
 process.on('exit', () => {
     writeCoverage();
 });
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "escover",
-  "version": "6.1.1",
+  "version": "6.2.0",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Coverage for EcmaScript Modules",
   "main": "lib/escover.js",
@@ -59,6 +59,7 @@
   },
   "license": "MIT",
   "devDependencies": {
+    "@putout/eslint-flat": "^4.0.0",
     "@putout/test": "^15.1.1",
     "c8": "^11.0.0",
     "escover": "file:.",

package/lib/fresh.js

@@ -1,27 +0,0 @@
-import {fileURLToPath, pathToFileURL} from 'node:url';
-import assert from 'node:assert';
-import {register} from 'node:module';
-import {MessageChannel} from 'node:worker_threads';
-
-// This example showcases how a message channel can be used to communicate
-// between the main (application) thread and the hooks running on the hooks
-// thread, by sending `port2` to the `initialize` hook.
-const __filename = fileURLToPath(import.meta.url);
-
-// This example showcases how a message channel can be used to communicate
-// between the main (application) thread and the hooks running on the hooks
-// thread, by sending `port2` to the `initialize` hook.
-const {port1, port2} = new MessageChannel();
-
-port1.on('message', (msg) => {
-    assert.strictEqual(msg, 'increment: 2');
-});
-
-register('./escover.js', {
-    parentURL: pathToFileURL(__filename),
-    data: {
-        number: 1,
-        port: port2,
-    },
-    transferList: [port2],
-});