escover 6.2.0 → 6.2.2

package/ChangeLog

@@ -1,3 +1,13 @@
+2026.05.08, v6.2.2
+
+fix:
+- 3b5e98e formatters: responsive: directory green when 100%
+
+2026.05.08, v6.2.1
+
+feature:
+- 53bbcfe escover: formatters: responsive: columns: push
+
 2026.05.08, v6.2.0
 
 fix:

package/lib/cli/cli.js

@@ -42,7 +42,7 @@ export const cli = ({argv, exit, readCoverage}) => {
         console.log(`v${version()}`);
         return exit();
     }
-
+    
     if (args.help) {
         console.log(help());
         return exit();

package/lib/formatters/responsive.js

@@ -6,7 +6,6 @@ import {
 import chalk from 'chalk';
 
 const CWD = process.cwd();
-
 const {entries, keys} = Object;
 
 const makeGreen = chalk.hex('#4caf50');
@@ -19,33 +18,55 @@ export default (coverageFile, {skipFull = false} = {}) => {
         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);
+    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);
     
-    return table(tableData, {
-        drawHorizontalLine: (raw) => !raw || raw === 1 || raw === tableData.length,
-        
-        columns: [{
-            paddingLeft: 1,
-            paddingRight: 1,
-            width: fileColWidth,
-            wrapWord: false, // 🔥 ключевой фикс — без переносов
-        }, ...showPercent ? [{
+    const columns = [{
+        paddingLeft: 1,
+        paddingRight: 1,
+        width: fileColWidth,
+        wrapWord: false,
+    }];
+    
+    if (showPercent)
+        columns.push({
             alignment: 'center',
             paddingLeft: 1,
             paddingRight: 0,
             width: percentColWidth,
-        }] : [], {
-            paddingLeft: 1,
-            paddingRight: 0,
-            width: linesColWidth,
-        }],
+        });
+    
+    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'),
@@ -57,29 +78,34 @@ export default (coverageFile, {skipFull = false} = {}) => {
             joinJoin: '|',
             bodyJoin: '|',
         },
-    });
+    };
+    
+    return table(tableData, options);
 };
 
-/* =========================
-   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('/') : '';
+        
+        let folder = '';
+        
+        if (parts.length > 1)
+            folder = parts
+                .slice(0, -1)
+                .join('/');
         
         const fileName = parts.at(-1);
         
-        if (!groups.has(folder))
-            groups.set(folder, {
-                files: [],
-            });
+        let group = groups.get(folder);
         
-        const group = groups.get(folder);
+        if (!group) {
+            group = {
+                files: [],
+            };
+            groups.set(folder, group);
+        }
         
         group.files.push({
             ...f,
@@ -90,55 +116,87 @@ function groupByFolder(files) {
     return groups;
 }
 
-/* =========================
-   TABLE BUILDER
-========================= */
 function buildGroupedTable(files, showPercent) {
-    const tableData = [
-        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) {
-        const coverage = group.files.length ? Math.round(group.files.reduce((sum, f) => sum + f.percentLines, 0) / group.files.length) : 100;
+        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);
         
-        const folderLabel = formatFolder(folder || '.');
+        let folderLabel = folder;
         
-        const folderName = makeRed(`${folderLabel}/`);
+        if (!folderLabel)
+            folderLabel = '.';
         
-        const folderPercentColor = coverage === 100 ? makeGreen : makeRed;
+        const trimmedFolder = trim(folderLabel, 25) + '/';
+        
+        let folderColor = makeRed;
+        
+        if (coverage === 100)
+            folderColor = makeGreen;
+        
+        const folderName = folderColor(trimmedFolder);
         
         const headerRow = [folderName];
         
-        if (showPercent)
-            headerRow.push(folderPercentColor(`${coverage}%`));
+        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 = ` ${formatPath(f.shortName)}`;
-            const uncoveredLines = formatLines(f.lines);
+            const fileCell = ' ' + trim(f.shortName, 30);
+            
+            let fileColor = makeRed;
+            
+            if (f.covered)
+                fileColor = makeGreen;
             
-            const filePercentColor = f.percentLines === 100 ? makeGreen : makeRed;
+            const row = [fileColor(fileCell)];
             
-            const row = [
-                f.covered ? makeGreen(fileCell) : makeRed(fileCell),
-            ];
+            if (showPercent) {
+                let percentColor = makeRed;
+                
+                if (f.percentLines === 100)
+                    percentColor = makeGreen;
+                
+                row.push(percentColor(`${f.percentLines}%`));
+            }
             
-            if (showPercent)
-                row.push(filePercentColor(`${f.percentLines}%`));
+            let uncovered = '';
             
-            row.push(f.covered ? '' : makeRed(uncoveredLines));
+            if (!f.covered)
+                uncovered = makeRed(formatLines(f.lines));
+            
+            row.push(uncovered);
             
             tableData.push(row);
         }
@@ -147,30 +205,29 @@ function buildGroupedTable(files, showPercent) {
     return tableData;
 }
 
-/* =========================
-   PARSE
-========================= */
-function parseCoverageFile(coverageFile, skipFull = false) {
+function parseCoverageFile(coverageFile, skipFull) {
     const files = [];
     
     for (const {name, lines} of coverageFile) {
-        const filename = name.replace(`${CWD}/`, '');
-        const uncoveredLines = parseUncoveredLines(lines);
+        const uncovered = parseUncoveredLines(lines);
         
         const linesCount = keys(lines).length;
-        const uncoveredLinesCount = uncoveredLines.length;
+        const uncoveredCount = uncovered.length;
+        
+        const percentLines = getLinesPercent(linesCount, uncoveredCount);
         
-        const percentLines = getLinesPercent(linesCount, uncoveredLinesCount);
+        let covered = true;
         
-        const isCovered = !uncoveredLinesCount;
+        if (uncoveredCount > 0)
+            covered = false;
         
-        if (skipFull && isCovered)
+        if (skipFull && covered)
             continue;
         
         files.push({
-            filename,
-            covered: isCovered,
-            lines: uncoveredLines,
+            filename: name.replace(`${CWD}/`, ''),
+            covered,
+            lines: uncovered,
             percentLines,
         });
     }
@@ -178,51 +235,32 @@ function parseCoverageFile(coverageFile, skipFull = false) {
     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;
+function trim(str, max) {
+    if (str.length <= max)
+        return str;
     
-    if (path.length <= max)
-        return path;
-    
-    return `...${path.slice(-(max - 3))}`;
+    return '...' + str.slice(-(max - 3));
 }
 
 export function formatLines(array) {
-    const max = 30;
-    
     if (array.length <= 10) {
         const joined = array.join(', ');
         
-        if (joined.length <= max)
+        if (joined.length <= 30)
             return joined;
     }
     
     const [first] = array;
     const last = array.at(-1);
     
-    const base = `${first}..${last}`;
+    const base = first + '..' + last;
     
-    if (base.length <= max)
+    if (base.length <= 30)
         return base;
     
-    return String(last);
+    return last;
 }
 
-/* =========================
-   HELPERS
-========================= */
 function parseUncoveredLines(lines) {
     const out = [];
     
@@ -238,5 +276,7 @@ export function getLinesPercent(linesCount, uncoveredLinesCount) {
     if (!linesCount)
         return 100;
     
-    return 100 - Math.round(100 / linesCount * uncoveredLinesCount);
+    const ratio = 100 / linesCount * uncoveredLinesCount;
+    
+    return 100 - Math.round(ratio);
 }

package/package.json

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