@zohodesk/unit-testing-framework 0.0.14-experimental → 0.0.15-experimental

package/build/index.js

@@ -3,6 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "CoverageReporter", {
+  enumerable: true,
+  get: function () {
+    return _coverageReporter.default;
+  }
+});
+Object.defineProperty(exports, "applyCoverageOverrides", {
+  enumerable: true,
+  get: function () {
+    return _coverageConfig.applyCoverageOverrides;
+  }
+});
+Object.defineProperty(exports, "createCoverageRunner", {
+  enumerable: true,
+  get: function () {
+    return _coverageRunner.default;
+  }
+});
 Object.defineProperty(exports, "createJestRunner", {
   enumerable: true,
   get: function () {
@@ -15,5 +33,20 @@ Object.defineProperty(exports, "default", {
     return _jestRunner.default;
   }
 });
+Object.defineProperty(exports, "getCoverageDefaults", {
+  enumerable: true,
+  get: function () {
+    return _coverageConfig.getCoverageDefaults;
+  }
+});
+Object.defineProperty(exports, "isCoverageEnabled", {
+  enumerable: true,
+  get: function () {
+    return _coverageConfig.isCoverageEnabled;
+  }
+});
 var _jestRunner = _interopRequireDefault(require("./src/runner/jest-runner.js"));
+var _coverageRunner = _interopRequireDefault(require("./src/coverage/coverage-runner.js"));
+var _coverageReporter = _interopRequireDefault(require("./src/reporters/coverage-reporter.js"));
+var _coverageConfig = require("./src/coverage/coverage-config.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/build/src/config/default-config.js

@@ -35,7 +35,7 @@ function getDefaultConfig(projectRoot) {
     testMatch: ['**/__tests__/**/*.test.js'],
     testPathIgnorePatterns: ['/node_modules/', '/build/'],
     // --------------- Environment ---------------
-    testEnvironment: 'node',
+    testEnvironment: 'jsdom',
     // --------------- Transform ---------------
     // Use babel-jest to transform ESM (import/export) and JSX in
     // consumer source & test files. Consumer's own babel config
@@ -52,12 +52,16 @@ function getDefaultConfig(projectRoot) {
     },
     transformIgnorePatterns: ['/node_modules/'],
     // --------------- Coverage ---------------
-    collectCoverage: false,
-    coverageDirectory: _path.default.resolve(projectRoot, 'coverage'),
-    coverageReporters: ['text', 'lcov', 'clover'],
-    coveragePathIgnorePatterns: ['/node_modules/', '/tests/'],
+    // Coverage defaults are managed by CoverageManager
+    // (src/coverage/coverage-config.js). The runner merges
+    // them in automatically; consumers override via the
+    // `coverage` option passed to createJestRunner().
+
     // --------------- Reporters ---------------
-    reporters: ['default', 'html-report'],
+    reporters: ['default', 'html-report'
+    // 'coverage-report' is injected automatically by
+    // CoverageManager when coverage is enabled.
+    ],
     // --------------- Parallelism & Performance ---------------
     maxWorkers: '50%',
     // Use half of available CPUs

package/build/src/constants/configConstants.js

@@ -5,5 +5,26 @@ class configConstants {
   static UNIT_CONFIG_FILE = 'unit.config.js';
   static STAGE_CONFIG_MAP_FILE = 'test-slices/conf_path_map.properties';
   static TEST_SLICE_FOLDER = 'test-slices';
+
+  // Coverage
+  static COVERAGE_DIR = 'coverage';
+  static COVERAGE_SUMMARY_FILE = 'coverage-summary.json';
+  static COVERAGE_REPORT_DIR = 'unit_reports';
+  static COVERAGE_HTML_FILE = 'coverage-report.html';
+
+  // Coverage thresholds (default enforcement levels)
+  static COVERAGE_THRESHOLD_DEFAULT = {
+    branches: 0,
+    functions: 0,
+    lines: 0,
+    statements: 0
+  };
+
+  // Coverage reporter formats
+  static COVERAGE_REPORTERS = ['text', 'text-summary', 'lcov', 'clover', 'json-summary'];
+
+  // Coverage provider options: 'babel' or 'v8'
+  static COVERAGE_PROVIDER_BABEL = 'babel';
+  static COVERAGE_PROVIDER_V8 = 'v8';
 }
 module.exports = configConstants;

package/build/src/coverage/coverage-config.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyCoverageOverrides = applyCoverageOverrides;
+exports.getCoverageDefaults = getCoverageDefaults;
+exports.isCoverageEnabled = isCoverageEnabled;
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * coverage-config.js
+ *
+ * Isolated coverage configuration module.
+ * Keeps all coverage-related defaults and overrides separate
+ * from the core test runner, so the runner stays single-responsibility.
+ *
+ * Usage:
+ *   import { getCoverageDefaults, applyCoverageOverrides } from './coverage-config.js';
+ */
+
+/**
+ * @typedef {object} CoverageOptions
+ * @property {boolean}  [enabled]        - Whether to collect coverage.
+ * @property {string}   [directory]      - Output directory for coverage data.
+ * @property {string[]} [reporters]      - Jest coverage reporter formats (e.g. ['text', 'lcov']).
+ * @property {string[]} [collectFrom]    - Glob patterns for files to instrument.
+ * @property {object}   [threshold]      - Minimum coverage percentages to enforce.
+ * @property {string}   [provider]       - Instrumentation provider: 'babel' | 'v8'.
+ * @property {string[]} [ignorePatterns] - Patterns to exclude from coverage.
+ */
+
+/**
+ * Returns the default coverage-specific Jest config keys.
+ *
+ * @param {string} projectRoot - Absolute path to the consumer project root.
+ * @returns {import('@jest/types').Config.InitialOptions} Coverage-only config slice.
+ */
+function getCoverageDefaults(projectRoot) {
+  return {
+    collectCoverage: false,
+    coverageDirectory: _path.default.resolve(projectRoot, 'coverage'),
+    coverageReporters: ['text', 'text-summary', 'lcov', 'clover', 'json-summary'],
+    coveragePathIgnorePatterns: ['/node_modules/', '/__tests__/', '/tests/', '/test/', '\\.test\\.[jt]sx?$', '\\.spec\\.[jt]sx?$', '/build/', '/dist/'],
+    collectCoverageFrom: ['src/**/*.{js,jsx,ts,tsx}', '!src/**/*.d.ts', '!src/**/__tests__/**', '!src/**/*.test.{js,jsx,ts,tsx}', '!src/**/*.spec.{js,jsx,ts,tsx}'],
+    coverageProvider: 'babel',
+    coverageThreshold: null
+  };
+}
+
+/**
+ * Apply consumer-supplied coverage overrides onto a config object.
+ * Only sets values that were explicitly provided (not undefined).
+ *
+ * @param {object} config           - Mutable Jest config to patch.
+ * @param {CoverageOptions} opts    - Consumer coverage overrides.
+ * @param {string} projectRoot      - Consumer project root (for path resolution).
+ */
+function applyCoverageOverrides(config, opts = {}, projectRoot = process.cwd()) {
+  if (opts.enabled !== undefined) config.collectCoverage = opts.enabled;
+  if (opts.directory !== undefined) config.coverageDirectory = _path.default.resolve(projectRoot, opts.directory);
+  if (opts.reporters !== undefined) config.coverageReporters = opts.reporters;
+  if (opts.collectFrom !== undefined) config.collectCoverageFrom = opts.collectFrom;
+  if (opts.threshold !== undefined) config.coverageThreshold = opts.threshold;
+  if (opts.provider !== undefined) config.coverageProvider = opts.provider;
+  if (opts.ignorePatterns !== undefined) config.coveragePathIgnorePatterns = opts.ignorePatterns;
+}
+
+/**
+ * Check whether a given config object has coverage enabled.
+ *
+ * @param {object} config - Jest config.
+ * @returns {boolean}
+ */
+function isCoverageEnabled(config) {
+  return config.collectCoverage === true;
+}

package/build/src/coverage/coverage-manager.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CoverageManager = void 0;
+var _coverageConfig = require("./coverage-config.js");
+/**
+ * coverage-manager.js
+ *
+ * Orchestrates all coverage concerns:
+ *   1. Merging coverage defaults into the Jest config
+ *   2. Applying consumer overrides
+ *   3. Conditionally injecting the coverage reporter
+ *
+ * The runner delegates to this module instead of handling
+ * coverage logic inline, keeping the runner single-responsibility.
+ *
+ * Usage (inside jest-runner.js):
+ *   import { CoverageManager } from '../coverage/coverage-manager.js';
+ *   const cm = new CoverageManager(projectRoot, coverageOpts);
+ *   cm.apply(mergedConfig);
+ */
+
+const COVERAGE_REPORTER_ALIAS = 'coverage-report';
+class CoverageManager {
+  /**
+   * @param {string} projectRoot - Consumer project root.
+   * @param {import('./coverage-config.js').CoverageOptions} [overrides={}]
+   */
+  constructor(projectRoot, overrides = {}) {
+    this.projectRoot = projectRoot;
+    this.overrides = overrides;
+  }
+
+  /**
+   * Merge coverage defaults into the config, then apply
+   * any consumer-supplied overrides.
+   *
+   * @param {object} config - Mutable Jest config object.
+   * @returns {object} The same config reference (mutated).
+   */
+  apply(config) {
+    // ── 1. Merge coverage defaults ──────────────────────────
+    const defaults = (0, _coverageConfig.getCoverageDefaults)(this.projectRoot);
+    for (const [key, value] of Object.entries(defaults)) {
+      // Only set defaults that aren't already present in config
+      if (config[key] === undefined) {
+        config[key] = value;
+      }
+    }
+
+    // ── 2. Apply consumer overrides ─────────────────────────
+    (0, _coverageConfig.applyCoverageOverrides)(config, this.overrides, this.projectRoot);
+
+    // ── 3. Conditionally add / remove coverage reporter ─────
+    this._syncCoverageReporter(config);
+    return config;
+  }
+
+  /**
+   * Ensure the coverage reporter is present only when
+   * coverage is enabled, and removed when it isn't.
+   *
+   * @param {object} config
+   * @private
+   */
+  _syncCoverageReporter(config) {
+    if (!Array.isArray(config.reporters)) return;
+    const hasAlias = config.reporters.some(r => {
+      const name = Array.isArray(r) ? r[0] : r;
+      return name === COVERAGE_REPORTER_ALIAS;
+    });
+    if ((0, _coverageConfig.isCoverageEnabled)(config)) {
+      // Inject the coverage reporter if not already present
+      if (!hasAlias) {
+        config.reporters.push(COVERAGE_REPORTER_ALIAS);
+      }
+    } else {
+      // Strip the coverage reporter when coverage is off
+      config.reporters = config.reporters.filter(r => {
+        const name = Array.isArray(r) ? r[0] : r;
+        return name !== COVERAGE_REPORTER_ALIAS;
+      });
+    }
+  }
+}
+exports.CoverageManager = CoverageManager;

package/build/src/coverage/coverage-runner.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createCoverageRunner;
+var _runnerBase = require("../runner/runner-base.js");
+var _coverageConfig = require("./coverage-config.js");
+/**
+ * coverage-runner.js
+ *
+ * Standalone module for running Jest with code coverage.
+ * Completely independent of jest-runner.js — consumers call
+ * this directly when they want coverage:
+ *
+ *   import { createCoverageRunner } from 'unit-testing-framework';
+ *   await createCoverageRunner({ projectRoot: process.cwd() });
+ *
+ * Or with overrides:
+ *   await createCoverageRunner({
+ *     projectRoot: process.cwd(),
+ *     directory: 'reports/coverage',
+ *     threshold: { global: { lines: 80 } },
+ *   });
+ */
+
+const COVERAGE_REPORTER_ALIAS = 'coverage-report';
+
+/**
+ * @typedef {object} CoverageRunnerOptions
+ * @property {string}        [projectRoot]    - Absolute path to the consumer project (default: cwd).
+ * @property {string[]}      [testFiles]      - Specific test file patterns to run.
+ * @property {string}        [testPathPattern]- Regex to match test file paths.
+ * @property {boolean}       [verbose]        - Verbose output.
+ * @property {number|string} [maxWorkers]     - Worker concurrency (e.g. '50%' or 4).
+ * @property {boolean}       [silent]         - Suppress console output from tests.
+ * @property {string}        [directory]      - Coverage output directory.
+ * @property {string[]}      [reporters]      - Jest coverage reporter formats (e.g. ['text', 'lcov']).
+ * @property {string[]}      [collectFrom]    - Glob patterns for files to instrument.
+ * @property {object}        [threshold]      - Minimum coverage % per metric.
+ * @property {string}        [provider]       - Instrumentation provider: 'babel' | 'v8'.
+ * @property {string[]}      [ignorePatterns] - Patterns to exclude from coverage.
+ */
+
+/**
+ * Run Jest with code coverage enabled.
+ *
+ * @param {CoverageRunnerOptions} [options={}]
+ * @returns {Promise<import('@jest/core').AggregatedResult>} Jest aggregated results.
+ */
+async function createCoverageRunner(options = {}) {
+  const {
+    projectRoot = process.cwd(),
+    testFiles,
+    testPathPattern,
+    verbose,
+    maxWorkers,
+    silent,
+    // Coverage-specific options
+    directory,
+    reporters,
+    collectFrom,
+    threshold,
+    provider,
+    ignorePatterns
+  } = options;
+
+  // ── 1. Build base config with overrides ────────────────────
+  const config = (0, _runnerBase.createBaseConfig)(projectRoot, {
+    verbose,
+    maxWorkers,
+    silent
+  });
+
+  // ── 2. Merge coverage defaults ─────────────────────────────
+  const coverageDefaults = (0, _coverageConfig.getCoverageDefaults)(projectRoot);
+  for (const [key, value] of Object.entries(coverageDefaults)) {
+    if (config[key] === undefined) {
+      config[key] = value;
+    }
+  }
+
+  // Always enable coverage — that's the purpose of this runner.
+  config.collectCoverage = true;
+
+  // ── 3. Apply consumer coverage overrides ───────────────────
+  (0, _coverageConfig.applyCoverageOverrides)(config, {
+    enabled: true,
+    directory,
+    reporters,
+    collectFrom,
+    threshold,
+    provider,
+    ignorePatterns
+  }, projectRoot);
+
+  // ── 4. Inject coverage reporter if not present ─────────────
+  if (Array.isArray(config.reporters)) {
+    const hasCoverageReporter = config.reporters.some(r => {
+      const name = Array.isArray(r) ? r[0] : r;
+      return name === COVERAGE_REPORTER_ALIAS;
+    });
+    if (!hasCoverageReporter) {
+      config.reporters.push(COVERAGE_REPORTER_ALIAS);
+    }
+  }
+
+  // ── 5. Resolve reporters ───────────────────────────────────
+  (0, _runnerBase.resolveConfigReporters)(config, projectRoot);
+
+  // ── 6. Build argv & run Jest ───────────────────────────────
+  const argv = (0, _runnerBase.buildArgv)(config, {
+    testFiles,
+    testPathPattern,
+    watch: false,
+    // No watch mode in coverage runs
+    projectRoot,
+    argvOverrides: {
+      collectCoverage: true
+    }
+  });
+  return (0, _runnerBase.executeJest)(argv, projectRoot);
+}

package/build/src/reporters/coverage-reporter.js

@@ -0,0 +1,407 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../utils/logger.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * coverage-reporter.js
+ *
+ * A custom Jest reporter that produces a self-contained HTML coverage report
+ * and enforces configurable coverage thresholds. Generates a detailed
+ * per-file breakdown showing line, branch, function, and statement coverage.
+ *
+ * Usage in reporters config:
+ *   ['coverage-report']                                → defaults
+ *   ['coverage-report', { outputDir: '...', thresholds: { lines: 80 } }]
+ *
+ * Reporter options:
+ *   - outputDir  {string}  Directory for the HTML file (default: <rootDir>/test-slices/unit-test/unit_reports)
+ *   - fileName   {string}  HTML file name (default: coverage-report.html)
+ *   - title      {string}  Page title (default: Code Coverage Report)
+ *   - thresholds {object}  Minimum coverage % per metric (branches, functions, lines, statements)
+ *   - failOnThreshold {boolean} Exit with error if thresholds not met (default: false)
+ */
+
+class CoverageReporter {
+  constructor(globalConfig, reporterOptions = {}) {
+    this.globalConfig = globalConfig;
+    this.options = reporterOptions;
+  }
+  onRunComplete(_contexts, aggregatedResults) {
+    const coverageMap = aggregatedResults.coverageMap;
+    if (!coverageMap) {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, '\n  ⚠  Coverage data not available. Run with --coverage to collect coverage.\n');
+      return;
+    }
+    const rootDir = this.globalConfig.rootDir || process.cwd();
+    const outputDir = this.options.outputDir ? _path.default.resolve(rootDir, this.options.outputDir) : _path.default.resolve(rootDir, 'test-slices', 'unit-test', 'unit_reports');
+    const fileName = this.options.fileName || 'coverage-report.html';
+    const title = this.options.title || 'Code Coverage Report';
+    const outputPath = _path.default.join(outputDir, fileName);
+
+    // ── 1. Extract per-file coverage data ──────────────────────
+    const files = coverageMap.files();
+    const fileSummaries = files.map(filePath => {
+      const fileCoverage = coverageMap.fileCoverageFor(filePath);
+      const summary = fileCoverage.toSummary();
+      return {
+        file: _path.default.relative(rootDir, filePath),
+        lines: summary.lines,
+        statements: summary.statements,
+        branches: summary.branches,
+        functions: summary.functions
+      };
+    });
+
+    // ── 2. Compute totals ──────────────────────────────────────
+    const totals = this._computeTotals(fileSummaries);
+
+    // ── 3. Print console summary ───────────────────────────────
+    this._printConsoleSummary(totals, fileSummaries);
+
+    // ── 4. Generate HTML report ────────────────────────────────
+    _fs.default.mkdirSync(outputDir, {
+      recursive: true
+    });
+    const html = this._generateHtml(totals, fileSummaries, title);
+    _fs.default.writeFileSync(outputPath, html, 'utf-8');
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, `\n  📊 Coverage report written to: ${outputPath}\n`);
+
+    // ── 5. Write JSON summary alongside HTML ───────────────────
+    const jsonPath = _path.default.join(outputDir, 'coverage-summary.json');
+    _fs.default.writeFileSync(jsonPath, JSON.stringify({
+      totals,
+      files: fileSummaries
+    }, null, 2), 'utf-8');
+
+    // ── 6. Enforce thresholds ──────────────────────────────────
+    if (this.options.thresholds) {
+      this._enforceThresholds(totals, this.options.thresholds);
+    }
+  }
+
+  // ── Totals computation ───────────────────────────────────────
+
+  _computeTotals(fileSummaries) {
+    const sum = {
+      lines: {
+        total: 0,
+        covered: 0
+      },
+      statements: {
+        total: 0,
+        covered: 0
+      },
+      branches: {
+        total: 0,
+        covered: 0
+      },
+      functions: {
+        total: 0,
+        covered: 0
+      }
+    };
+    for (const f of fileSummaries) {
+      for (const metric of ['lines', 'statements', 'branches', 'functions']) {
+        sum[metric].total += f[metric].total;
+        sum[metric].covered += f[metric].covered;
+      }
+    }
+    const pct = (covered, total) => total === 0 ? 100 : parseFloat((covered / total * 100).toFixed(2));
+    return {
+      lines: {
+        ...sum.lines,
+        pct: pct(sum.lines.covered, sum.lines.total)
+      },
+      statements: {
+        ...sum.statements,
+        pct: pct(sum.statements.covered, sum.statements.total)
+      },
+      branches: {
+        ...sum.branches,
+        pct: pct(sum.branches.covered, sum.branches.total)
+      },
+      functions: {
+        ...sum.functions,
+        pct: pct(sum.functions.covered, sum.functions.total)
+      }
+    };
+  }
+
+  // ── Console summary ─────────────────────────────────────────
+
+  _printConsoleSummary(totals, fileSummaries) {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, '\n╔══════════════════════════════════════════════════════════════╗');
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, '║              Code Coverage Summary                           ║');
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, '╚══════════════════════════════════════════════════════════════╝');
+    const header = '  ' + 'Metric'.padEnd(14) + 'Covered'.padStart(10) + 'Total'.padStart(10) + 'Pct (%)'.padStart(12);
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, header);
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, '  ' + '─'.repeat(46));
+    for (const metric of ['lines', 'statements', 'branches', 'functions']) {
+      const m = totals[metric];
+      const icon = m.pct >= 80 ? '✔' : m.pct >= 50 ? '⚠' : '✖';
+      const line = `  ${icon} ${metric.padEnd(13)}${String(m.covered).padStart(9)}${String(m.total).padStart(10)}${(m.pct + '%').padStart(11)}`;
+      const type = m.pct >= 80 ? _logger.Logger.SUCCESS_TYPE : _logger.Logger.FAILURE_TYPE;
+      _logger.Logger.log(type, line);
+    }
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, '  ' + '─'.repeat(46));
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `  Files analyzed: ${fileSummaries.length}`);
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, '');
+  }
+
+  // ── Threshold enforcement ────────────────────────────────────
+
+  _enforceThresholds(totals, thresholds) {
+    const failures = [];
+    for (const metric of ['lines', 'statements', 'branches', 'functions']) {
+      const threshold = thresholds[metric];
+      if (threshold != null && totals[metric].pct < threshold) {
+        failures.push(`  ✖ ${metric}: ${totals[metric].pct}% < ${threshold}% threshold`);
+      }
+    }
+    if (failures.length > 0) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, '\n  Coverage thresholds not met:');
+      for (const f of failures) {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, f);
+      }
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, '');
+      if (this.options.failOnThreshold !== false) {
+        throw new Error(`Coverage thresholds not met:\n${failures.join('\n')}`);
+      }
+    } else {
+      _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, '  ✔ All coverage thresholds met.\n');
+    }
+  }
+
+  // ── HTML Generation ──────────────────────────────────────────
+
+  _generateHtml(totals, fileSummaries, title) {
+    const timestamp = new Date().toLocaleString();
+    const summaryCards = ['lines', 'statements', 'branches', 'functions'].map(metric => {
+      const m = totals[metric];
+      const cls = m.pct >= 80 ? 'high' : m.pct >= 50 ? 'medium' : 'low';
+      return `
+        <div class="card ${cls}">
+          <div class="value">${m.pct}%</div>
+          <div class="label">${metric}</div>
+          <div class="detail">${m.covered} / ${m.total}</div>
+        </div>`;
+    }).join('');
+    const fileRows = fileSummaries.sort((a, b) => a.lines.pct - b.lines.pct) // worst coverage first
+    .map(f => {
+      const linesCls = this._pctClass(f.lines.pct);
+      const branchesCls = this._pctClass(f.branches.pct);
+      const funcsCls = this._pctClass(f.functions.pct);
+      const stmtsCls = this._pctClass(f.statements.pct);
+      return `
+        <tr>
+          <td class="file-name">${this._escapeHtml(f.file)}</td>
+          <td class="${stmtsCls}">${f.statements.pct}%</td>
+          <td class="${branchesCls}">${f.branches.pct}%</td>
+          <td class="${funcsCls}">${f.functions.pct}%</td>
+          <td class="${linesCls}">${f.lines.pct}%</td>
+          <td>${f.lines.covered}/${f.lines.total}</td>
+        </tr>`;
+    }).join('');
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${title}</title>
+  <style>
+    :root {
+      --high: #2ecc71;
+      --medium: #f39c12;
+      --low: #e74c3c;
+      --bg: #1a1a2e;
+      --card: #16213e;
+      --text: #eaeaea;
+      --muted: #8892a4;
+      --border: #2a2a4a;
+      --table-hover: rgba(255,255,255,0.03);
+    }
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      padding: 24px;
+      line-height: 1.5;
+    }
+    .header { text-align: center; margin-bottom: 32px; }
+    .header h1 { font-size: 1.8rem; margin-bottom: 4px; }
+    .header .meta { color: var(--muted); font-size: 0.85rem; }
+
+    /* Summary cards */
+    .summary {
+      display: flex; gap: 16px; justify-content: center;
+      flex-wrap: wrap; margin-bottom: 32px;
+    }
+    .card {
+      background: var(--card); border: 1px solid var(--border);
+      border-radius: 10px; padding: 18px 28px; min-width: 160px;
+      text-align: center;
+    }
+    .card .value { font-size: 2.2rem; font-weight: 700; }
+    .card .label {
+      font-size: 0.8rem; color: var(--muted);
+      text-transform: uppercase; letter-spacing: 1px;
+    }
+    .card .detail { font-size: 0.75rem; color: var(--muted); margin-top: 4px; }
+    .card.high .value { color: var(--high); }
+    .card.high { border-color: var(--high); }
+    .card.medium .value { color: var(--medium); }
+    .card.medium { border-color: var(--medium); }
+    .card.low .value { color: var(--low); }
+    .card.low { border-color: var(--low); }
+
+    /* Coverage bar */
+    .bar-container {
+      display: flex; justify-content: center; margin-bottom: 32px;
+    }
+    .bar-wrapper { width: 80%; max-width: 700px; }
+    .bar-label { font-size: 0.85rem; color: var(--muted); margin-bottom: 6px; }
+    .bar {
+      height: 22px; background: #2a2a4a; border-radius: 11px; overflow: hidden;
+    }
+    .bar-fill {
+      height: 100%; border-radius: 11px;
+      transition: width 0.4s ease;
+    }
+    .bar-fill.high { background: var(--high); }
+    .bar-fill.medium { background: var(--medium); }
+    .bar-fill.low { background: var(--low); }
+
+    /* File table */
+    .table-container {
+      background: var(--card); border: 1px solid var(--border);
+      border-radius: 10px; overflow: hidden; margin-bottom: 24px;
+    }
+    .table-title {
+      padding: 14px 18px; font-weight: 600; font-size: 1rem;
+      border-bottom: 1px solid var(--border);
+    }
+    .search-box {
+      padding: 10px 18px;
+      border-bottom: 1px solid var(--border);
+    }
+    .search-box input {
+      width: 100%; padding: 8px 12px;
+      background: var(--bg); border: 1px solid var(--border);
+      border-radius: 6px; color: var(--text); font-size: 0.85rem;
+    }
+    .search-box input::placeholder { color: var(--muted); }
+    table {
+      width: 100%; border-collapse: collapse; font-size: 0.85rem;
+    }
+    th {
+      text-align: left; padding: 10px 14px;
+      color: var(--muted); font-weight: 600;
+      text-transform: uppercase; font-size: 0.75rem;
+      letter-spacing: 0.5px; cursor: pointer;
+      user-select: none; border-bottom: 1px solid var(--border);
+    }
+    th:hover { color: var(--text); }
+    td {
+      padding: 10px 14px; border-bottom: 1px solid var(--border);
+    }
+    tr:hover { background: var(--table-hover); }
+    .file-name { font-family: 'SF Mono', Monaco, monospace; font-size: 0.82rem; }
+    .high { color: var(--high); font-weight: 600; }
+    .medium { color: var(--medium); font-weight: 600; }
+    .low { color: var(--low); font-weight: 600; }
+
+    .footer {
+      text-align: center; color: var(--muted);
+      font-size: 0.75rem; margin-top: 24px;
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>${title}</h1>
+    <p class="meta">Generated on ${timestamp}</p>
+  </div>
+
+  <div class="summary">${summaryCards}</div>
+
+  <div class="bar-container">
+    <div class="bar-wrapper">
+      <div class="bar-label">Overall Line Coverage: ${totals.lines.pct}%</div>
+      <div class="bar">
+        <div class="bar-fill ${this._pctClass(totals.lines.pct)}" style="width: ${totals.lines.pct}%"></div>
+      </div>
+    </div>
+  </div>
+
+  <div class="table-container">
+    <div class="table-title">Per-File Coverage Breakdown</div>
+    <div class="search-box">
+      <input type="text" id="fileFilter" placeholder="Filter files..." oninput="filterFiles()" />
+    </div>
+    <table id="coverageTable">
+      <thead>
+        <tr>
+          <th onclick="sortTable(0)">File</th>
+          <th onclick="sortTable(1)">Stmts %</th>
+          <th onclick="sortTable(2)">Branch %</th>
+          <th onclick="sortTable(3)">Funcs %</th>
+          <th onclick="sortTable(4)">Lines %</th>
+          <th onclick="sortTable(5)">Lines</th>
+        </tr>
+      </thead>
+      <tbody>${fileRows}</tbody>
+    </table>
+  </div>
+
+  <div class="footer">
+    Generated by Unit Testing Framework &bull; Coverage Reporter
+  </div>
+
+  <script>
+    function filterFiles() {
+      const q = document.getElementById('fileFilter').value.toLowerCase();
+      const rows = document.querySelectorAll('#coverageTable tbody tr');
+      rows.forEach(row => {
+        const name = row.querySelector('.file-name').textContent.toLowerCase();
+        row.style.display = name.includes(q) ? '' : 'none';
+      });
+    }
+
+    let sortDir = {};
+    function sortTable(col) {
+      const table = document.getElementById('coverageTable');
+      const tbody = table.querySelector('tbody');
+      const rows = Array.from(tbody.querySelectorAll('tr'));
+      sortDir[col] = !sortDir[col];
+      rows.sort((a, b) => {
+        let av = a.cells[col].textContent.replace('%', '').trim();
+        let bv = b.cells[col].textContent.replace('%', '').trim();
+        const na = parseFloat(av), nb = parseFloat(bv);
+        if (!isNaN(na) && !isNaN(nb)) {
+          return sortDir[col] ? na - nb : nb - na;
+        }
+        return sortDir[col] ? av.localeCompare(bv) : bv.localeCompare(av);
+      });
+      rows.forEach(r => tbody.appendChild(r));
+    }
+  </script>
+</body>
+</html>`;
+  }
+  _pctClass(pct) {
+    if (pct >= 80) return 'high';
+    if (pct >= 50) return 'medium';
+    return 'low';
+  }
+  _escapeHtml(str) {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  }
+}
+exports.default = CoverageReporter;

package/build/src/reporters/reporter-handler.js

@@ -23,7 +23,8 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 
 const BUILTIN_ALIASES = {
   'framework-default': _path.default.resolve(__dirname, 'default-reporter.js'),
-  'html-report': _path.default.resolve(__dirname, 'html-reporter.js')
+  'html-report': _path.default.resolve(__dirname, 'html-reporter.js'),
+  'coverage-report': _path.default.resolve(__dirname, 'coverage-reporter.js')
 };
 
 /**

package/build/src/runner/jest-runner.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = createJestRunner;
-var _path = _interopRequireDefault(require("path"));
-var _defaultConfig = require("../config/default-config.js");
-var _reporterHandler = require("../reporters/reporter-handler.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); } /**
+var _runnerBase = require("./runner-base.js");
+/**
  * jest-runner.js
  *
  * Core module that runs Jest programmatically via @jest/core's runCLI.
@@ -17,10 +14,10 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
  *   import createJestRunner from 'unit-testing-framework';
  *   await createJestRunner({ projectRoot: process.cwd() });
  */
+
 /**
  * @typedef {object} RunnerOptions
  * @property {string}  [projectRoot]   - Absolute path to the consumer project (default: cwd).
- * @property {boolean} [coverage]      - Enable coverage collection.
  * @property {string[]} [testFiles]    - Specific test file patterns to run.
  * @property {string}  [testPathPattern] - Regex pattern to match test file paths (e.g. 'myFile.test.js').
  * @property {boolean} [verbose]       - Verbose output.
@@ -38,7 +35,6 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
 async function createJestRunner(options = {}) {
   const {
     projectRoot = process.cwd(),
-    coverage,
     testFiles,
     testPathPattern,
     verbose,
@@ -47,82 +43,22 @@ async function createJestRunner(options = {}) {
     watch = false
   } = options;
 
-  // ── 1. Get default configuration ───────────────────────────
-  const mergedConfig = (0, _defaultConfig.getDefaultConfig)(projectRoot);
-
-  // ── 2. Apply CLI-level overrides ───────────────────────────
-  if (coverage !== undefined) mergedConfig.collectCoverage = coverage;
-  if (verbose !== undefined) mergedConfig.verbose = verbose;
-  if (maxWorkers !== undefined) mergedConfig.maxWorkers = maxWorkers;
-  if (silent !== undefined) mergedConfig.silent = silent;
+  // ── 1. Build base config with overrides ────────────────────
+  const config = (0, _runnerBase.createBaseConfig)(projectRoot, {
+    verbose,
+    maxWorkers,
+    silent
+  });
 
-  // ── 3. Resolve reporters ───────────────────────────────────
-  mergedConfig.reporters = (0, _reporterHandler.resolveReporters)(mergedConfig.reporters, projectRoot);
+  // ── 2. Resolve reporters ───────────────────────────────────
+  (0, _runnerBase.resolveConfigReporters)(config, projectRoot);
 
-  // ── 4. Build argv for runCLI ───────────────────────────────
-  //    runCLI expects a yargs-like argv object.
-  const argv = buildArgv(mergedConfig, {
+  // ── 3. Build argv & run Jest ───────────────────────────────
+  const argv = (0, _runnerBase.buildArgv)(config, {
     testFiles,
     testPathPattern,
     watch,
     projectRoot
   });
-
-  // ── 5. Run Jest programmatically ───────────────────────────
-  //    Lazy-import to keep startup fast; @jest/core is heavy.
-  const {
-    runCLI
-  } = await Promise.resolve().then(() => _interopRequireWildcard(require('@jest/core')));
-  const {
-    results
-  } = await runCLI(argv, [projectRoot]);
-
-  // ── 6. Return results for the caller to inspect ────────────
-  return results;
-}
-
-/**
- * Build a yargs-compatible argv object that runCLI understands.
- *
- * @param {object} config - Merged Jest config.
- * @param {object} extra
- * @param {string[]} [extra.testFiles]
- * @param {string}  [extra.testPathPattern]
- * @param {boolean}  [extra.watch]
- * @param {string}   extra.projectRoot
- * @returns {object}
- */
-function buildArgv(config, {
-  testFiles,
-  testPathPattern,
-  watch,
-  projectRoot
-}) {
-  const argv = {
-    // Serialise the config so Jest uses our merged config
-    // instead of searching for jest.config.* files.
-    config: JSON.stringify(config),
-    // Project root for resolution
-    rootDir: projectRoot,
-    // Flags
-    watch: watch,
-    watchAll: false,
-    ci: process.env.CI === 'true',
-    // Pass-through values that CLI users might expect
-    verbose: config.verbose ?? true,
-    collectCoverage: config.collectCoverage ?? false,
-    passWithNoTests: config.passWithNoTests ?? true,
-    maxWorkers: config.maxWorkers ?? '50%',
-    silent: config.silent ?? false,
-    // Do not search for config files automatically
-    _: testFiles ?? [],
-    $0: 'unit-testing-framework'
-  };
-
-  // If a specific test file/pattern is provided, use testPathPattern
-  // so Jest only runs matching test files.
-  if (testPathPattern) {
-    argv.testPathPattern = testPathPattern;
-  }
-  return argv;
+  return (0, _runnerBase.executeJest)(argv, projectRoot);
 }

package/build/src/runner/runner-base.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildArgv = buildArgv;
+exports.createBaseConfig = createBaseConfig;
+exports.executeJest = executeJest;
+exports.resolveConfigReporters = resolveConfigReporters;
+var _defaultConfig = require("../config/default-config.js");
+var _reporterHandler = require("../reporters/reporter-handler.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); } /**
+ * runner-base.js
+ *
+ * Shared utilities used by both jest-runner.js (tests only)
+ * and coverage-runner.js (tests + coverage).
+ *
+ * Keeps common logic in one place so neither runner duplicates it.
+ */
+/**
+ * Create the base Jest config with common CLI overrides applied.
+ *
+ * @param {string} projectRoot
+ * @param {object} [overrides]
+ * @param {boolean} [overrides.verbose]
+ * @param {number|string} [overrides.maxWorkers]
+ * @param {boolean} [overrides.silent]
+ * @returns {import('@jest/types').Config.InitialOptions}
+ */
+function createBaseConfig(projectRoot, overrides = {}) {
+  const config = (0, _defaultConfig.getDefaultConfig)(projectRoot);
+  if (overrides.verbose !== undefined) config.verbose = overrides.verbose;
+  if (overrides.maxWorkers !== undefined) config.maxWorkers = overrides.maxWorkers;
+  if (overrides.silent !== undefined) config.silent = overrides.silent;
+  return config;
+}
+
+/**
+ * Resolve reporter aliases in the config and return the updated config.
+ *
+ * @param {object} config - Mutable Jest config.
+ * @param {string} projectRoot
+ * @returns {object} The same config reference (mutated).
+ */
+function resolveConfigReporters(config, projectRoot) {
+  config.reporters = (0, _reporterHandler.resolveReporters)(config.reporters, projectRoot);
+  return config;
+}
+
+/**
+ * Build a yargs-compatible argv object that runCLI understands.
+ *
+ * @param {object} config - Merged Jest config.
+ * @param {object} params
+ * @param {string[]} [params.testFiles]       - Explicit test file patterns.
+ * @param {string}   [params.testPathPattern] - Regex to filter test files.
+ * @param {boolean}  [params.watch]           - Watch mode flag.
+ * @param {string}   params.projectRoot       - Consumer project root.
+ * @param {object}   [params.argvOverrides]   - Extra keys merged into argv (e.g. { collectCoverage: true }).
+ * @returns {object}
+ */
+function buildArgv(config, {
+  testFiles,
+  testPathPattern,
+  watch = false,
+  projectRoot,
+  argvOverrides = {}
+}) {
+  const argv = {
+    // Serialise the config so Jest uses our merged config
+    // instead of searching for jest.config.* files.
+    config: JSON.stringify(config),
+    // Project root for resolution
+    rootDir: projectRoot,
+    // Flags
+    watch,
+    watchAll: false,
+    ci: process.env.CI === 'true',
+    // Pass-through values that CLI users might expect
+    verbose: config.verbose ?? true,
+    collectCoverage: config.collectCoverage ?? false,
+    passWithNoTests: config.passWithNoTests ?? true,
+    maxWorkers: config.maxWorkers ?? '50%',
+    silent: config.silent ?? false,
+    // Do not search for config files automatically
+    _: testFiles ?? [],
+    $0: 'unit-testing-framework',
+    // Caller-specific overrides (e.g. coverage runner forces collectCoverage: true)
+    ...argvOverrides
+  };
+  if (testPathPattern) {
+    argv.testPathPattern = testPathPattern;
+  }
+  return argv;
+}
+
+/**
+ * Lazy-import @jest/core and execute runCLI.
+ *
+ * @param {object} argv - yargs-style argv for runCLI.
+ * @param {string} projectRoot
+ * @returns {Promise<import('@jest/core').AggregatedResult>}
+ */
+async function executeJest(argv, projectRoot) {
+  const {
+    runCLI
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require('@jest/core')));
+  const {
+    results
+  } = await runCLI(argv, [projectRoot]);
+  return results;
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@zohodesk/unit-testing-framework",
-  "version": "0.0.14-experimental",
+  "version": "0.0.15-experimental",
   "description": "A modular Jest-based unit testing framework",
   "main": "./build/index.js",
   "exports": {
     ".": "./build/index.js",
     "./config": "./build/src/config/default-config.js",
     "./reporters": "./build/src/reporters/reporter-handler.js",
-    "./runner": "./build/src/runner/jest-runner.js"
+    "./runner": "./build/src/runner/jest-runner.js",
+    "./coverage": "./build/src/coverage/coverage-runner.js"
   },
   "files": [
     "build/"