lcov-badge2 1.1.0 → 1.1.2

package/README.md

@@ -4,12 +4,15 @@ A tool for generating SVG badges from LCOV reports, based on [lcov-badge](https:
 
 [![Build](https://github.com/stevenhair/lcov-badge2/actions/workflows/test.yml/badge.svg)](https://github.com/stevenhair/lcov-badge2/actions/workflows/test.yml)
 [![codecov](https://codecov.io/gh/stevenhair/lcov-badge2/branch/master/graph/badge.svg?token=nb0yy1Y6zc)](https://codecov.io/gh/stevenhair/lcov-badge2)
-
-[![NPM](https://nodei.co/npm/lcov-badge2.png)](https://nodei.co/npm/lcov-badge2/)
+[![npm](https://img.shields.io/npm/v/lcov-badge2.svg?maxAge=2592000)](https://www.npmjs.com/package/lcov-badge2)
+[![downloads](https://img.shields.io/npm/dt/lcov-badge2.svg?maxAge=2592000)](https://www.npmjs.com/package/lcov-badge2)
 
 ## Usage
 
-lcov-badge2 can be used as either a command line utility or a library:
+lcov-badge2 can be used as either a command line utility or a library.
+It produces your basic build badge:
+
+![example](https://raw.githubusercontent.com/stevenhair/lcov-badge2/master/example.svg)
 
 ### Command line usage
 

package/badge.d.ts

@@ -0,0 +1 @@
+export declare function createBadge(label: string, coverage: number): string;

package/badge.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBadge = void 0;
+var badge_up2_1 = require("badge-up2");
+function getColor(coverage) {
+    if (coverage > 97) {
+        return badge_up2_1.basicColors.brightgreen;
+    }
+    else if (coverage > 93) {
+        return badge_up2_1.basicColors.green;
+    }
+    else if (coverage > 90) {
+        return badge_up2_1.basicColors.yellowgreen;
+    }
+    else if (coverage > 85) {
+        return badge_up2_1.basicColors.yellow;
+    }
+    else if (coverage > 75) {
+        return badge_up2_1.basicColors.orange;
+    }
+    else {
+        return badge_up2_1.basicColors.red;
+    }
+}
+function createBadge(label, coverage) {
+    var color = getColor(coverage);
+    return (0, badge_up2_1.basic)(label, "".concat(coverage, "%"), color);
+}
+exports.createBadge = createBadge;

package/cli.d.ts

@@ -0,0 +1,6 @@
+export interface Arguments {
+    input: string;
+    label: string;
+    output: string;
+}
+export declare function processArguments(): Arguments;

package/cli.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processArguments = void 0;
+var minimist_1 = __importDefault(require("minimist"));
+var minimist_options_1 = __importDefault(require("minimist-options"));
+var path_1 = require("path");
+var defaultOutputPath = 'badge.svg';
+var defaultLabel = 'coverage';
+function exitWithError(message) {
+    console.error(message);
+    process.exit(1);
+}
+function printHelp() {
+    var message = "Usage: ".concat((0, path_1.basename)(process.argv[1]), " [-h] [-o OUTPUT] [-l LABEL] input\n\nPositional Arguments:\n  input                 Path to LCOV file to parse\n\nOptional Arguments:\n  -h, --help            Show this help message and exit\n  -o OUTPUT, --output OUTPUT\n                        Output file path (default: ").concat(defaultOutputPath, ")\n  -l LABEL, --label LABEL\n                        Badge label (default: ").concat(defaultLabel, ")\n    ");
+    console.log(message);
+    process.exit(0);
+}
+function validateArguments(args) {
+    if (!args._.length) {
+        exitWithError('Input must be provided');
+    }
+    if (args._.length !== 1) {
+        exitWithError('Only one input can be provided');
+    }
+}
+function processArguments() {
+    var options = (0, minimist_options_1.default)({
+        help: {
+            type: 'boolean',
+            alias: 'h',
+            default: false,
+        },
+        label: {
+            type: 'string',
+            alias: 'l',
+            default: defaultLabel,
+        },
+        output: {
+            type: 'string',
+            alias: 'o',
+            default: defaultOutputPath,
+        },
+        arguments: 'string',
+    });
+    var args = (0, minimist_1.default)(process.argv.slice(2), options);
+    if (args.help) {
+        printHelp();
+    }
+    validateArguments(args);
+    return {
+        input: args._[0],
+        label: args.label,
+        output: args.output,
+    };
+}
+exports.processArguments = processArguments;

package/coverage.d.ts

@@ -0,0 +1 @@
+export declare function getCoverageLevel(lcov: string): number;

package/coverage.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCoverageLevel = void 0;
+var parse_lcov_1 = __importDefault(require("parse-lcov"));
+function getCoverageLevel(lcov) {
+    var coverage = (0, parse_lcov_1.default)(lcov);
+    var summary = {
+        lines: { found: 0, hit: 0 },
+        branches: { found: 0, hit: 0 },
+        functions: { found: 0, hit: 0 },
+    };
+    var keys = Object.keys(summary);
+    coverage.forEach(function (arg) {
+        keys.forEach(function (key) {
+            summary[key].found += arg[key].found;
+            summary[key].hit += arg[key].hit;
+        });
+    });
+    return Math.round(keys.reduce(function (avg, key) {
+        var found = summary[key].found;
+        return avg + (found > 0 ? summary[key].hit / found * 100 : 100);
+    }, 0) / keys.length * 100) / 100;
+}
+exports.getCoverageLevel = getCoverageLevel;

package/main.d.ts

@@ -0,0 +1 @@
+export declare function generateBadge(filename: string, label?: string): Promise<string>;

package/main.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBadge = void 0;
+var fs = __importStar(require("fs/promises"));
+var badge_1 = require("./badge");
+var cli_1 = require("./cli");
+var coverage_1 = require("./coverage");
+function generateBadge(filename, label) {
+    if (label === void 0) { label = 'coverage'; }
+    return __awaiter(this, void 0, void 0, function () {
+        var input, coverage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, fs.readFile(filename)];
+                case 1:
+                    input = (_a.sent()).toString();
+                    coverage = (0, coverage_1.getCoverageLevel)(input);
+                    return [2, (0, badge_1.createBadge)(label, coverage)];
+            }
+        });
+    });
+}
+exports.generateBadge = generateBadge;
+if (require.main === module) {
+    var args_1 = (0, cli_1.processArguments)();
+    generateBadge(args_1.input, args_1.label)
+        .then(function (badge) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2, fs.writeFile(args_1.output, badge)];
+    }); }); })
+        .catch(function (e) {
+        console.error(e);
+        process.exit(1);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lcov-badge2",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Generate a badge from a LCOV report",
   "keywords": [
     "lcov",
@@ -29,10 +29,10 @@
     "start:prod": "dist/main.js",
     "test": "jest",
     "test:watch": "jest --watch",
-    "lint": "eslint src/**/*.ts"
+    "lint": "eslint src"
   },
   "dependencies": {
-    "badge-up2": "^1.0.0",
+    "badge-up2": "^2.0.1",
     "minimist": "^1.2.5",
     "minimist-options": "^4.1.0",
     "parse-lcov": "^1.0.4"

package/.editorconfig

@@ -1,16 +0,0 @@
-# Editor configuration, see https://editorconfig.org
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 4
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.{json,yml}]
-indent_size = 2
-max_line_length = off
-
-[*.md]
-max_line_length = off

package/.eslintrc.yml

@@ -1,343 +0,0 @@
-root: true
-parser: '@typescript-eslint/parser'
-parserOptions:
-  project: tsconfig.json
-  sourceType: module
-env:
-  node: true
-  jest: true
-  jest/globals: true
-plugins:
-  - '@typescript-eslint'
-  - 'import'
-  - 'jest'
-  - 'unicorn'
-extends:
-  - 'eslint:recommended'
-  - 'plugin:@typescript-eslint/eslint-recommended'
-  - 'plugin:@typescript-eslint/recommended'
-settings:
-  import/internal-regex: '^(config|core|http-server|logging|operation-log|persistence|test|utils)/'
-rules:
-  array-bracket-spacing:
-    - error
-    - never
-  arrow-parens: error
-  arrow-spacing: error
-  block-spacing:
-    - error
-    - always
-  brace-style:
-    - error
-    - 1tbs
-  camelcase: off
-  class-methods-use-this:
-    - warn
-    - exceptMethods:
-        - 'intercept'
-        - 'configure'
-        - 'getSession'
-  complexity: error
-  comma-dangle:
-    - warn
-    - always-multiline
-  computed-property-spacing:
-    - error
-    - never
-  constructor-super: error
-  curly: error
-  dot-notation: error
-  eol-last: error
-  eqeqeq:
-    - error
-    - always
-    - null: never
-  func-call-spacing:
-    - error
-    - never
-  func-style:
-    - error
-    - declaration
-  generator-star-spacing: error
-  guard-for-in: error
-  key-spacing: error
-  keyword-spacing: error
-  linebreak-style: error
-  max-len:
-    - error
-    - code: 120
-      ignoreTemplateLiterals: true
-      ignoreComments: true
-  new-parens: error
-  no-bitwise: error
-  no-caller: error
-  no-console: error
-  no-constant-condition: error
-  no-debugger: error
-  no-delete-var: error
-  no-eval: error
-  no-extra-bind: error
-  no-extra-semi: error
-  no-invalid-this: error
-  no-invalid-regexp: error
-  no-irregular-whitespace: error
-  no-multi-spaces:
-    - error
-    - ignoreEOLComments: true
-  no-multi-str: error
-  no-multiple-empty-lines:
-    - error
-    - max: 1
-      maxBOF: 0
-      maxEOF: 1
-  no-new-func: error
-  no-new-wrappers: error
-  no-octal-escape: error
-  no-param-reassign: error
-  no-plusplus:
-    - error
-    - allowForLoopAfterthoughts: true
-  no-regex-spaces: error
-  no-restricted-imports:
-    # this is a workaround for this bug: https://github.com/benmosher/eslint-plugin-import/issues/1610
-    - error
-    - patterns:
-        - '../*'
-  no-return-await: error
-  no-sequences: error
-  no-shadow: off # replaced by typescript-eslint/no-shadow rule below because of: https://github.com/typescript-eslint/typescript-eslint/issues/2471
-  no-sparse-arrays: error
-  no-template-curly-in-string: error
-  no-trailing-spaces: error
-  no-undef-init: error
-  no-unsafe-finally: error
-  no-unused-expressions: off
-  no-unused-labels: error
-  no-useless-rename: error
-  no-var: error
-  no-void: error
-  no-warning-comments: warn
-  no-whitespace-before-property: error
-  no-with: error
-  object-curly-spacing:
-    - error
-    - always
-  object-shorthand:
-    - error
-    - always
-    - avoidQuotes: true
-  one-var:
-    - error
-    - never
-  padded-blocks:
-    - error
-    - never
-  prefer-const: error
-  prefer-object-spread: error
-  prefer-template: error
-  quotes:
-    - error
-    - single
-    - avoidEscape: true
-  quote-props:
-    - error
-    - as-needed
-  radix: error
-  rest-spread-spacing: error
-  semi-spacing: error
-  space-before-function-paren:
-    - error
-    - asyncArrow: always
-      anonymous: always
-      named: never
-  space-in-parens:
-    - error
-    - never
-  space-infix-ops: error
-  space-unary-ops: error
-  spaced-comment: error
-  switch-colon-spacing: error
-  template-curly-spacing: error
-  template-tag-spacing: error
-  use-isnan: error
-  valid-typeof: error
-  yield-star-spacing: error
-
-  import/export: error
-  import/first: error
-  import/no-cycle: error
-  import/order:
-    - error
-    - groups:
-        - [builtin, external]
-        - [internal]
-        - [sibling, parent, index]
-      newlines-between: always
-      alphabetize:
-        order: asc
-  import/no-deprecated: warn
-  import/no-duplicates: error
-  import/no-extraneous-dependencies: error
-  import/no-mutable-exports: error
-  import/no-relative-parent-imports: error
-  import/no-unused-modules: error
-  jest/consistent-test-it:
-    - error
-    - fn: test
-  jest/expect-expect:
-    - error
-    - assertFunctionNames:
-        - expect
-        - assert*
-  jest/no-alias-methods: error
-  jest/no-commented-out-tests: warn
-  jest/no-deprecated-functions: warn
-  jest/no-disabled-tests: warn
-  #  https://github.com/jest-community/eslint-plugin-jest/issues/642
-  #  jest/no-duplicate-hooks: error
-  jest/no-export: error
-  jest/no-focused-tests: error
-  jest/no-identical-title: error
-  jest/no-if: warn
-  jest/no-jasmine-globals: error
-  jest/no-mocks-import: error
-  jest/no-standalone-expect:
-    - error
-    - additionalTestBlockFunctions:
-        - beforeEach
-  jest/no-test-prefixes: warn
-  jest/no-test-return-statement: error
-  jest/prefer-lowercase-title:
-    - error
-    - ignore:
-        - describe
-  jest/prefer-spy-on: error
-  jest/prefer-to-be: error
-  jest/prefer-to-contain: error
-  jest/prefer-to-have-length: warn
-  jest/prefer-todo: error
-  jest/require-to-throw-message: error
-  jest/valid-describe-callback: error
-  jest/valid-expect: error
-  jest/valid-expect-in-promise: error
-  unicorn/filename-case: error
-
-  # typescript-specific
-  '@typescript-eslint/array-type':
-    - error
-    - default: array
-  '@typescript-eslint/await-thenable': error
-  '@typescript-eslint/adjacent-overload-signatures': error
-  '@typescript-eslint/consistent-type-assertions':
-    - error
-    - assertionStyle: as
-  '@typescript-eslint/explicit-function-return-type':
-    - error
-    - allowExpressions: true
-  '@typescript-eslint/explicit-module-boundary-types':
-    - error
-    - allowHigherOrderFunctions: true
-      allowTypedFunctionExpressions: true
-  '@typescript-eslint/member-delimiter-style':
-    - error
-    - singleline:
-        delimiter: comma
-        requireLast: false
-  '@typescript-eslint/member-ordering':
-    - error
-    - default:
-        - static-field
-        - instance-field
-        - static-method
-        - instance-method
-  '@typescript-eslint/naming-convention':
-    - error
-    - selector: default
-      format:
-        - camelCase
-      leadingUnderscore: allow
-      trailingUnderscore: forbid
-    - selector: variable
-      format:
-        - camelCase
-        - PascalCase
-        - UPPER_CASE
-      leadingUnderscore: allow
-    - selector: function
-      format:
-        - camelCase
-        - PascalCase
-    - selector: property
-      format:
-        - camelCase
-        - PascalCase
-        - snake_case
-        - UPPER_CASE
-      leadingUnderscore: allow
-    - selector: enumMember
-      format:
-        - PascalCase
-    - selector: typeLike
-      format:
-        - PascalCase
-  '@typescript-eslint/no-array-constructor': error
-  '@typescript-eslint/no-dynamic-delete': error
-  '@typescript-eslint/no-explicit-any': error
-  '@typescript-eslint/no-empty-function':
-    - error
-    - allow:
-        - 'arrowFunctions'
-  '@typescript-eslint/no-empty-interface':
-    - error
-    - allowSingleExtends: true
-  '@typescript-eslint/no-extraneous-class': error
-  '@typescript-eslint/no-floating-promises': error
-  '@typescript-eslint/no-for-in-array': error
-  '@typescript-eslint/no-misused-new': error
-  '@typescript-eslint/no-require-imports': error
-  "@typescript-eslint/no-shadow": error
-  '@typescript-eslint/no-this-alias': error
-  '@typescript-eslint/no-throw-literal': error
-  '@typescript-eslint/no-unnecessary-qualifier': error
-  '@typescript-eslint/no-unnecessary-type-arguments': error
-  '@typescript-eslint/no-unnecessary-type-assertion': error
-  '@typescript-eslint/no-unused-vars':
-    - error
-    - ignoreRestSiblings: true
-      argsIgnorePattern: 'error|_.*'
-      varsIgnorePattern: '^_.*'
-  '@typescript-eslint/no-use-before-define':
-    - error
-    - functions: false
-      classes: false
-  '@typescript-eslint/no-useless-constructor': error
-  '@typescript-eslint/no-var-requires': error
-  '@typescript-eslint/prefer-for-of': error
-  '@typescript-eslint/prefer-function-type': error
-  '@typescript-eslint/prefer-nullish-coalescing': warn
-  '@typescript-eslint/prefer-optional-chain': error
-  '@typescript-eslint/prefer-readonly': error
-  '@typescript-eslint/promise-function-async': error
-  '@typescript-eslint/require-await': error
-  '@typescript-eslint/restrict-plus-operands': error
-  '@typescript-eslint/semi': error
-  '@typescript-eslint/type-annotation-spacing': error
-  '@typescript-eslint/unbound-method':
-    - error
-    - ignoreStatic: true
-  '@typescript-eslint/unified-signatures': error
-overrides:
-  - files:
-      - 'cli*.ts'
-      - 'main*.ts'
-    rules:
-      no-console: off
-  - files:
-      - '*.spec.ts'
-    rules:
-      class-methods-use-this: off
-      no-unused-expressions: off
-      '@typescript-eslint/no-empty-function': off
-      '@typescript-eslint/no-explicit-any': off
-      '@typescript-eslint/unbound-method': off
-      '@typescript-eslint/ban-types': off

package/.github/dependabot.yml

@@ -1,10 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: npm
-    directory: '/'
-    schedule:
-      interval: weekly
-  - package-ecosystem: github-actions
-    directory: '/'
-    schedule:
-      interval: weekly

package/.github/workflows/codeql-analysis.yml

@@ -1,37 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master ]
-  schedule:
-    - cron: '19 4 * * 5'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'typescript' ]
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2

package/.github/workflows/test.yml

@@ -1,31 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches:
-      - '*'
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [16.x, 18.x, 20.x]
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm ci
-      - run: npm run build --if-present
-      - run: npm run coverage
-      - run: npm run lint
-      - name: Codecov
-        uses: codecov/codecov-action@v3.1.4
-        with:
-          directory: ./coverage

package/SECURITY.md

@@ -1,14 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Currently, there's only one major and minor version, so of course it's supported!
-
-| Version | Supported           |
-| ------- | ------------------- |
-| 1.0.x   | :heavy_check_mark:  |
-
-## Reporting a Vulnerability
-
-If you notice a vulnerability, please open an issue or, if you'd like to fix it yourself, a pull request.
-You can expect a response within a couple of days at the latest.

package/gulpfile.mjs

@@ -1,20 +0,0 @@
-import { deleteAsync } from 'del';
-import gulp from 'gulp';
-import header from 'gulp-header';
-
-export async function clean() {
-    await deleteAsync(['dist']);
-}
-
-function addShebang() {
-    return gulp.src('dist/main.js')
-        .pipe(header('#!/usr/bin/env node\n'))
-        .pipe(gulp.dest('dist'));
-}
-
-function copyPackageFiles() {
-    return gulp.src(['package.json', 'README.md', 'LICENSE'])
-        .pipe(gulp.dest('dist'));
-}
-
-export const postbuild = gulp.series(addShebang, copyPackageFiles);

package/src/badge.spec.ts

@@ -1,36 +0,0 @@
-import badge, { colors } from 'badge-up2';
-
-import { createBadge } from './badge';
-
-jest.mock('badge-up2');
-
-describe('Badge', () => {
-    beforeEach(() => {
-        (badge as jest.MockedFunction<typeof badge>).mockResolvedValue('this is a badge');
-    });
-
-    describe('Creating badge', () => {
-        test('it returns the badge contents', async () => {
-            const contents = await createBadge('coverage', 12.34);
-            expect(contents).toBe('this is a badge');
-        });
-
-        test.each([
-            [colors.red, 0],
-            [colors.red, 75],
-            [colors.orange, 75.01],
-            [colors.orange, 85],
-            [colors.yellow, 85.01],
-            [colors.yellow, 90],
-            [colors.yellowgreen, 90.01],
-            [colors.yellowgreen, 93],
-            [colors.green, 93.01],
-            [colors.green, 97],
-            [colors.brightgreen, 97.01],
-            [colors.brightgreen, 100],
-        ])('the color is %s when the coverage is %s', async (color, coverage) => {
-            await createBadge('abc123', coverage);
-            expect(badge).toHaveBeenCalledWith('abc123', `${coverage}%`, color);
-        });
-    });
-});

package/src/badge.ts

@@ -1,22 +0,0 @@
-import badge, { colors } from 'badge-up2';
-
-function getColor(coverage: number): colors {
-    if (coverage > 97) {
-        return colors.brightgreen;
-    } else if (coverage > 93) {
-        return colors.green;
-    } else if (coverage > 90) {
-        return colors.yellowgreen;
-    } else if (coverage > 85) {
-        return colors.yellow;
-    } else if (coverage > 75) {
-        return colors.orange;
-    } else {
-        return colors.red;
-    }
-}
-
-export async function createBadge(label: string, coverage: number): Promise<string> {
-    const color = getColor(coverage);
-    return badge(label, `${coverage}%`, color);
-}

package/src/cli.spec.ts

@@ -1,111 +0,0 @@
-import path from 'path';
-
-import { Arguments, processArguments } from './cli';
-
-describe('CLI', () => {
-    beforeEach(() => {
-        jest.spyOn(console, 'log').mockImplementation();
-        jest.spyOn(console, 'error').mockImplementation();
-        jest.spyOn(process, 'exit').mockImplementation();
-    });
-
-    afterEach(() => {
-        (console.log as jest.Mock).mockReset();
-    });
-
-    describe('When the help argument is passed', () => {
-        describe.each(['-h', '--help'])('When %s is passed', (arg) => {
-            beforeEach(() => {
-                process.argv = ['node', path.join('some', 'path', 'whatever', 'foo.ts'), arg];
-                processArguments();
-            });
-
-            test('it prints the help message', () => {
-                expect(console.log).toHaveBeenCalledTimes(1);
-                expect((console.log as jest.MockedFunction<typeof console.log>).mock.calls[0][0])
-                    .toContain('Usage: foo.ts [-h] [-o OUTPUT] [-l LABEL] input');
-            });
-
-            test('it exits without an error', () => {
-                expect(process.exit).toHaveBeenCalledWith(0);
-            });
-        });
-    });
-
-    describe('When no positional arguments are passed', () => {
-        beforeEach(() => {
-            process.argv = ['node', 'foo.ts', '-l', 'foo'];
-            processArguments();
-        });
-
-        test('it prints an error message', () => {
-            expect(console.error).toHaveBeenCalledWith('Input must be provided');
-        });
-
-        test('it exits with an error', () => {
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-    });
-
-    describe('When multiple positional arguments are passed', () => {
-        beforeEach(() => {
-            process.argv = ['node', 'foo.ts', '-l', 'foo', 'bar', 'baz'];
-            processArguments();
-        });
-
-        test('it prints an error message', () => {
-            expect(console.error).toHaveBeenCalledWith('Only one input can be provided');
-        });
-
-        test('it exits with an error', () => {
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-    });
-
-    describe('When only an input is provided', () => {
-        let args: Arguments;
-
-        beforeEach(() => {
-            process.argv = ['node', 'foo.ts', 'foo'];
-            args = processArguments();
-        });
-
-        test('it sets the input', () => {
-            expect(args.input).toBe('foo');
-        });
-
-        test('it uses the default label value', () => {
-            expect(args.label).toBe('coverage');
-        });
-
-        test('it uses the default output value', () => {
-            expect(args.output).toBe('badge.svg');
-        });
-    });
-
-    describe('When providing a value for label', () => {
-        let args: Arguments;
-
-        beforeEach(() => {
-            process.argv = ['node', 'foo.ts', '-l', 'my-coverage', 'foo'];
-            args = processArguments();
-        });
-
-        test('it sets the value for label', () => {
-            expect(args.label).toBe('my-coverage');
-        });
-    });
-
-    describe('When providing a value for output', () => {
-        let args: Arguments;
-
-        beforeEach(() => {
-            process.argv = ['node', 'foo.ts', '-o', 'my-badge.svg', 'foo'];
-            args = processArguments();
-        });
-
-        test('it sets the value for label', () => {
-            expect(args.output).toBe('my-badge.svg');
-        });
-    });
-});

package/src/cli.ts

@@ -1,80 +0,0 @@
-import minimist, { ParsedArgs } from 'minimist';
-import buildOptions from 'minimist-options';
-import { basename } from 'path';
-
-export interface Arguments {
-    input: string;
-    label: string;
-    output: string;
-}
-
-const defaultOutputPath = 'badge.svg';
-const defaultLabel = 'coverage';
-
-function exitWithError(message: string): never {
-    console.error(message);
-    process.exit(1);
-}
-
-function printHelp(): never {
-    const message = `Usage: ${basename(process.argv[1])} [-h] [-o OUTPUT] [-l LABEL] input
-
-Positional Arguments:
-  input                 Path to LCOV file to parse
-
-Optional Arguments:
-  -h, --help            Show this help message and exit
-  -o OUTPUT, --output OUTPUT
-                        Output file path (default: ${defaultOutputPath})
-  -l LABEL, --label LABEL
-                        Badge label (default: ${defaultLabel})
-    `;
-    console.log(message);
-    process.exit(0);
-}
-
-function validateArguments(args: ParsedArgs): void {
-    if (!args._.length) {
-        exitWithError('Input must be provided');
-    }
-
-    if (args._.length !== 1) {
-        exitWithError('Only one input can be provided');
-    }
-}
-
-export function processArguments(): Arguments {
-    const options = buildOptions({
-        help: {
-            type: 'boolean',
-            alias: 'h',
-            default: false,
-        },
-        label: {
-            type: 'string',
-            alias: 'l',
-            default: defaultLabel,
-        },
-        output: {
-            type: 'string',
-            alias: 'o',
-            default: defaultOutputPath,
-        },
-        // Special option for positional arguments (`_` in minimist)
-        arguments: 'string',
-    });
-
-    const args = minimist(process.argv.slice(2), options);
-
-    if (args.help) {
-        printHelp();
-    }
-
-    validateArguments(args);
-
-    return {
-        input: args._[0],
-        label: args.label,
-        output: args.output,
-    };
-}

package/src/coverage.spec.ts

@@ -1,88 +0,0 @@
-import parse from 'parse-lcov';
-
-import { getCoverageLevel } from './coverage';
-
-jest.mock('parse-lcov');
-
-describe('Coverage', () => {
-    beforeEach(() => {
-        (parse as jest.MockedFunction<typeof parse>).mockReturnValue([]);
-    });
-
-    test('it reads the file', () => {
-        getCoverageLevel('foo.lcov');
-        expect(parse).toHaveBeenCalledWith('foo.lcov');
-    });
-
-    describe('When there are no lines of code', () => {
-        beforeEach(() => {
-            (parse as jest.MockedFunction<typeof parse>).mockReturnValue([
-                {
-                    title: '',
-                    file: '',
-                    functions: { found: 0, hit: 0, details: [] },
-                    branches: { found: 0, hit: 0, details: [] },
-                    lines: { found: 0, hit: 0, details: [] },
-                },
-            ]);
-        });
-
-        test('it returns 100', () => {
-            expect(getCoverageLevel('foo')).toBe(100);
-        });
-    });
-
-    describe('When there are lines of code and none are hit', () => {
-        beforeEach(() => {
-            (parse as jest.MockedFunction<typeof parse>).mockReturnValue([
-                {
-                    title: '',
-                    file: '',
-                    functions: { found: 1, hit: 0, details: [] },
-                    branches: { found: 2, hit: 0, details: [] },
-                    lines: { found: 3, hit: 0, details: [] },
-                },
-            ]);
-        });
-
-        test('it returns 0', () => {
-            expect(getCoverageLevel('foo')).toBe(0);
-        });
-    });
-
-    describe('When there are lines of code and all are hit', () => {
-        beforeEach(() => {
-            (parse as jest.MockedFunction<typeof parse>).mockReturnValue([
-                {
-                    title: '',
-                    file: '',
-                    functions: { found: 1, hit: 1, details: [] },
-                    branches: { found: 2, hit: 2, details: [] },
-                    lines: { found: 3, hit: 3, details: [] },
-                },
-            ]);
-        });
-
-        test('it returns 0', () => {
-            expect(getCoverageLevel('foo')).toBe(100);
-        });
-    });
-
-    describe('When there are lines of code and some are hit', () => {
-        beforeEach(() => {
-            (parse as jest.MockedFunction<typeof parse>).mockReturnValue([
-                {
-                    title: '',
-                    file: '',
-                    functions: { found: 100, hit: 66, details: [] },
-                    branches: { found: 200, hit: 157, details: [] },
-                    lines: { found: 1234, hit: 963, details: [] },
-                },
-            ]);
-        });
-
-        test('it calculates the coverage', () => {
-            expect(getCoverageLevel('foo')).toBe(74.18);
-        });
-    });
-});

package/src/coverage.ts

@@ -1,24 +0,0 @@
-import parse from 'parse-lcov';
-
-export function getCoverageLevel(lcov: string): number {
-    const coverage = parse(lcov);
-
-    const summary = {
-        lines: { found: 0, hit: 0 },
-        branches: { found: 0, hit: 0 },
-        functions: { found: 0, hit: 0 },
-    };
-    const keys = Object.keys(summary) as (keyof typeof summary)[];
-
-    coverage.forEach((arg) => {
-        keys.forEach((key) => {
-            summary[key].found += arg[key].found;
-            summary[key].hit += arg[key].hit;
-        });
-    });
-
-    return Math.round(keys.reduce((avg, key) => {
-        const found = summary[key].found;
-        return avg + (found > 0 ? summary[key].hit / found * 100 : 100);
-    }, 0) / keys.length * 100) / 100;
-}

package/src/main.spec.ts

@@ -1,78 +0,0 @@
-import { spawnSync, SpawnSyncReturns } from 'child_process';
-import fs from 'fs/promises';
-import os from 'os';
-import path from 'path';
-
-import { createBadge } from './badge';
-import { getCoverageLevel } from './coverage';
-import { generateBadge } from './main';
-
-jest.mock('./badge');
-jest.mock('./coverage');
-
-describe('Main', () => {
-    let badgeContents: string;
-
-    beforeEach(async () => {
-        jest.spyOn(fs, 'readFile').mockResolvedValue('some lcov content');
-        (getCoverageLevel as jest.MockedFunction<typeof getCoverageLevel>).mockReturnValue(99.5);
-        (createBadge as jest.MockedFunction<typeof createBadge>).mockResolvedValue('totally an svg');
-
-        badgeContents = await generateBadge('foo.lcov', 'something');
-    });
-
-    test('the main function generates the badge from the input', () => {
-        expect(fs.readFile).toHaveBeenCalledWith('foo.lcov');
-        expect(getCoverageLevel).toHaveBeenCalledWith('some lcov content');
-        expect(createBadge).toHaveBeenCalledWith('something', 99.5);
-    });
-
-    test('it returns the SVG as a string', () => {
-        expect(badgeContents).toBe('totally an svg');
-    });
-
-    describe('Running as a script', () => {
-        const report = `
-            TN:
-            SF:src/badge.ts
-            FN:3,getColor
-            FN:19,createBadge
-            FNF:2
-            FNH:2
-            FNDA:13,getColor
-            FNDA:13,createBadge
-            DA:1,2
-            LF:15
-            LH:15
-            BRDA:4,0,0,2
-            BRF:10
-            BRH:10
-            end_of_record`;
-        let inputFilePath: string;
-        let filePath: string;
-        let result: SpawnSyncReturns<string | Buffer>;
-
-        beforeEach(async () => {
-            const dir = os.tmpdir();
-            filePath = path.join(dir, `badge-${new Date().valueOf()}.svg`);
-            inputFilePath = path.join(dir, `lcov-${new Date().valueOf()}.info`);
-
-            await fs.writeFile(inputFilePath, report);
-
-            result = spawnSync('ts-node', [path.join(__dirname, 'main.ts'), '-o', filePath, inputFilePath]);
-        });
-
-        afterEach(async () => {
-            await fs.rm(filePath);
-            await fs.rm(inputFilePath);
-        });
-
-        test('it exited successfully', () => {
-            expect(result.status).toBe(0);
-        });
-
-        test('it writes the badge file', async () => {
-            await expect(fs.stat(filePath)).resolves.not.toThrow();
-        });
-    });
-});

package/src/main.ts

@@ -1,21 +0,0 @@
-import * as fs from 'fs/promises';
-
-import { createBadge } from './badge';
-import { processArguments } from './cli';
-import { getCoverageLevel } from './coverage';
-
-export async function generateBadge(filename: string, label = 'coverage'): Promise<string> {
-    const input = (await fs.readFile(filename)).toString();
-    const coverage = getCoverageLevel(input);
-    return createBadge(label, coverage);
-}
-
-if (require.main === module) {
-    const args = processArguments();
-    generateBadge(args.input, args.label)
-        .then(async (badge) => fs.writeFile(args.output, badge))
-        .catch((e) => {
-            console.error(e);
-            process.exit(1);
-        });
-}

package/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "sourceMap": false
-  },
-  "exclude": [
-    "src/**/*.spec.ts"
-  ]
-}

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "target": "ES5",
-    "lib": [
-      "es2020"
-    ],
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": "./src",
-    "resolveJsonModule": true,
-    "strict": true,
-    "typeRoots": [
-      "node_modules/@types",
-      "types"
-    ]
-  },
-  "include": [
-    "src/**/*.ts"
-  ]
-}

package/types/badge-up2/index.d.ts

@@ -1,19 +0,0 @@
-declare module 'badge-up2' {
-    export enum colors {
-        brightgreen = '#4C1',
-        green = '#97CA00',
-        yellow = '#DFB317',
-        yellowgreen = '#A4A61D',
-        orange = '#FE7D37',
-        red = '#E05D44',
-        blue = '#007EC6',
-        grey = '#555',
-        gray = '#555',
-        lightgrey = '#9F9F9F',
-        lightgray = '#9F9F9F',
-        purple = '#400090'
-    }
-
-    function badge(field1: string, field2: string, color: colors): Promise<string>;
-    export default badge;
-}