@escover/formatter-responsive 1.0.0

package/README.md

@@ -0,0 +1,26 @@
+# @escover/formatter-responsive [![License][LicenseIMGURL]][LicenseURL] [![NPM version][NPMIMGURL]][NPMURL] [![Build Status][BuildStatusIMGURL]][BuildStatusURL] [![Coverage Status][CoverageIMGURL]][CoverageURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/@escover/formatter-responsive.svg?style=flat
+[BuildStatusURL]: https://github.com/coderaiser/@escover/formatter-responsive/actions?query=workflow%3A%22Node+CI%22 "Build Status"
+[BuildStatusIMGURL]: https://github.com/coderaiser/@escover/formatter-responsive/workflows/Node%20CI/badge.svg
+[LicenseIMGURL]: https://img.shields.io/badge/license-MIT-317BF9.svg?style=flat
+[NPMURL]: https://npmjs.org/package/@escover/formatter-responsive "npm"
+[LicenseURL]: https://tldrlegal.com/license/mit-license "MIT License"
+[CoverageURL]: https://coveralls.io/github/coderaiser/@escover/formatter-responsive?branch=master
+[CoverageIMGURL]: https://coveralls.io/repos/coderaiser/@escover/formatter-responsive/badge.svg?branch=master&service=github
+
+## Install
+
+```
+npm i @formatter-responsive -D
+```
+
+## Usage Example
+
+```
+ESCOVER_FORMAT='responsive' escover npm test
+```
+
+## License
+MIT
+

package/lib/build-grouped-table.js

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import {formatLines} from './format-lines.js';
+import {groupByFolder} from './group-by-folder.js';
+
+const makeGreen = chalk.hex('#4caf50');
+const makeRed = chalk.hex('#f44336');
+
+export const getColor = (value) => value === 100 ? makeGreen : makeRed;
+
+function truncateLeft(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    
+    return `...${str.slice(str.length - maxLength + 5)}`;
+}
+
+export function buildGroupedTable({files, showPercent, linesColWidth, fileColWidth}) {
+    const tableData = [];
+    
+    if (showPercent)
+        tableData.push([
+            'File',
+            '% Lines',
+            'Uncovered Lines #s',
+        ]);
+    else
+        tableData.push([
+            'File',
+            'Uncovered Lines #s',
+        ]);
+    
+    const groups = groupByFolder(files);
+    const hideFolders = groups.size === 1;
+    
+    for (const [folder, group] of groups) {
+        let sum = 0;
+        
+        for (const f of group.files)
+            sum += f.percentLines;
+        
+        const coverage = Math.round(sum / group.files.length);
+        
+        if (!hideFolders) {
+            const row = [];
+            
+            const shortFolder = truncateLeft(folder, fileColWidth);
+            row.push(getColor(coverage)(shortFolder));
+            
+            if (showPercent)
+                row.push(getColor(coverage)(`${coverage}%`));
+            
+            row.push('');
+            tableData.push(row);
+        }
+        
+        for (const {covered, lines, fileName, percentLines} of group.files) {
+            const row = [];
+            const shortName = truncateLeft(fileName, fileColWidth);
+            const coloredShortName = covered ? makeGreen(shortName) : makeRed(shortName);
+            
+            row.push(` ${coloredShortName}`);
+            
+            if (showPercent) {
+                const percent = percentLines === 100 ? makeGreen(`${percentLines}%`) : makeRed(`${percentLines}%`);
+                row.push(percent);
+            }
+            
+            row.push(covered ? '' : makeRed(formatLines(
+                lines,
+                linesColWidth,
+            )));
+            
+            tableData.push(row);
+        }
+    }
+    
+    return tableData;
+}

package/lib/format-lines.js

@@ -0,0 +1,60 @@
+export function formatLines(nums, maxLen = 20) {
+    const ranges = [];
+    
+    for (let i = 0; i < nums.length; i++) {
+        const [j, range] = maybeRange(nums, i);
+        ranges.push(range);
+        i = j - 1;
+    }
+    
+    const joined = ranges.join(', ');
+    
+    if (joined.length <= maxLen)
+        return joined;
+    
+    return getShortenedRange(ranges, maxLen);
+}
+
+export function getShortenedRange(ranges, maxLen) {
+    const last = ranges
+        .at(-1)
+        .toString();
+    
+    for (let i = 1; i < ranges.length - 1; i++) {
+        const joined = `${ranges
+            .slice(0, -i)
+            .join(', ')} ... ${last}`;
+        
+        if (joined.length <= maxLen)
+            return joined;
+    }
+    
+    const first = ranges.at(0);
+    const firstLast = `${first} ... ${last}`;
+    
+    if (firstLast.length <= maxLen)
+        return firstLast;
+    
+    return `${ranges.at(0)} ...`;
+}
+
+function maybeRange(nums, i) {
+    const start = nums.at(i);
+    let prev = nums.at(i);
+    
+    for (++i; i < nums.length; i++) {
+        const n = nums[i];
+        
+        if (n === prev + 1) {
+            prev = n;
+            continue;
+        }
+        
+        break;
+    }
+    
+    if (start === prev)
+        return [i, start];
+    
+    return [i, `${start}..${prev}`];
+}

package/lib/group-by-folder.js

@@ -0,0 +1,28 @@
+export 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);
+        
+        let group = groups.get(folder);
+        
+        if (!group) {
+            group = {
+                files: [],
+            };
+            groups.set(folder, group);
+        }
+        
+        group.files.push({
+            ...f,
+            fileName,
+        });
+    }
+    
+    return groups;
+}

package/lib/responsive.js

@@ -0,0 +1,122 @@
+import process from 'node:process';
+import {
+    table,
+    getBorderCharacters,
+} from 'table';
+import {buildGroupedTable} from './build-grouped-table.js';
+
+const CWD = process.cwd();
+const {entries, keys} = Object;
+
+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 linesColWidth = Math.floor(totalWidth / 2);
+    const percentColWidth = showPercent ? 7 : 0;
+    
+    const fileColWidth = Math.max(10, totalWidth - linesColWidth - percentColWidth - 6 - 4);
+    const tableData = buildGroupedTable({
+        files,
+        showPercent,
+        linesColWidth,
+        fileColWidth,
+    });
+    
+    const options = createTableOptions({
+        showPercent,
+        tableData,
+        fileColWidth,
+        percentColWidth,
+        linesColWidth,
+    });
+    
+    return table(tableData, options);
+};
+
+export function createTableOptions({showPercent, tableData, fileColWidth, percentColWidth, linesColWidth}) {
+    const columns = [{
+        paddingLeft: 1,
+        paddingRight: 1,
+        width: fileColWidth,
+        wrapWord: false,
+    }];
+    
+    if (showPercent)
+        columns.push({
+            alignment: 'center',
+            paddingLeft: 1,
+            paddingRight: 1,
+            width: percentColWidth,
+        });
+    
+    columns.push({
+        paddingLeft: 1,
+        paddingRight: 1,
+        width: linesColWidth,
+        wrapWord: false,
+    });
+    
+    return {
+        drawHorizontalLine: (i) => !i || i === 1 || i === tableData.length,
+        columns,
+        border: {
+            ...getBorderCharacters('void'),
+            topBody: '-',
+            bottomBody: '-',
+            joinBody: '-',
+            topJoin: '|',
+            bottomJoin: '|',
+            joinJoin: '|',
+            bodyJoin: '|',
+        },
+    };
+}
+
+export function parseCoverageFile(coverageFile, skipFull) {
+    const files = [];
+    
+    for (const {name, lines} of coverageFile) {
+        const uncovered = parseUncoveredLines(lines);
+        const linesCount = keys(lines).length;
+        const uncoveredLinesCount = uncovered.length;
+        const percentLines = getLinesPercent(linesCount, uncoveredLinesCount);
+        const covered = uncoveredLinesCount === 0;
+        
+        if (skipFull && covered)
+            continue;
+        
+        files.push({
+            filename: name.replace(`${CWD}/`, ''),
+            covered,
+            lines: uncovered,
+            percentLines,
+        });
+    }
+    
+    return files;
+}
+
+export function parseUncoveredLines(lines) {
+    const out = [];
+    
+    for (const [line, covered] of entries(lines))
+        if (!covered)
+            out.push(Number(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

@@ -0,0 +1,61 @@
+{
+  "name": "@escover/formatter-responsive",
+  "version": "1.0.0",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "Istanbul converter",
+  "exports": "./lib/responsive.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coderaiser/escover.git"
+  },
+  "keywords": [
+    "coverage",
+    "putout",
+    "loader"
+  ],
+  "scripts": {
+    "test": "madrun test",
+    "coverage": "madrun coverage",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "report": "madrun report",
+    "watcher": "madrun watcher",
+    "watch:test": "madrun watch:test",
+    "watch:lint": "madrun watch:lint",
+    "watch:tape": "madrun watch:tape",
+    "prewisdom": "madrun prewisdom"
+  },
+  "dependencies": {
+    "chalk": "^5.0.0",
+    "find-cache-dir": "^5.0.0",
+    "find-up": "^8.0.0",
+    "montag": "^2.0.1",
+    "once": "^1.4.0",
+    "picomatch": "^4.0.2",
+    "putout": "^42.0.1",
+    "strip-ansi": "^7.0.1",
+    "table": "^6.8.0",
+    "try-catch": "^4.0.9",
+    "yargs-parser": "^22.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@putout/eslint-flat": "^4.0.0",
+    "@putout/test": "^15.1.1",
+    "c8": "^11.0.0",
+    "escover": "^6.2.9",
+    "eslint": "^10.0.0",
+    "eslint-plugin-putout": "^31.0.0",
+    "madrun": "^13.0.0",
+    "supertape": "^13.1.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}