flow-coverage-report/dist/lib/report-text.js

Generate an HTML report of the flow coverage data

'use strict';

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _path = _interopRequireDefault(require("path"));

var _terminalTable = _interopRequireDefault(require("terminal-table"));

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function renderTextReport(coverageData, options) {
  var print = options.log || console.log.bind(console);
  var filesTable = new _terminalTable["default"]({
    leftPadding: 1,
    rightPadding: 1,
    borderStyle: 2
  });
  filesTable.push(['filename', 'annotation', 'percent', 'total', 'covered', 'uncovered']);
  var row = 0;

  var _iterator = _createForOfIteratorHelper(Object.keys(coverageData.files).sort()),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var filename = _step.value;
      row += 1;
      var data = coverageData.files[filename];
      var annotation = data.annotation || 'no flow';
      var covered = data.expressions.covered_count;
      var uncovered = data.expressions.uncovered_count;
      var percent = data.percent;
      filesTable.push([filename, annotation, data.isError ? "\u26A0 Error" : percent + ' %', covered + uncovered, covered, uncovered]);
      var rowColor = void 0;

      if (data.isFlow && percent >= (options.threshold || 80)) {
        rowColor = 'green';
      } else {
        rowColor = 'red';
      }

      if (data.isError) {
        rowColor = 'red';
      }

      filesTable.attrRange({
        row: [row]
      }, {
        color: rowColor
      });
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  filesTable.attrRange({
    column: [1, 5]
  }, {
    align: 'right'
  });
  var summaryTablePre = new _terminalTable["default"]({
    leftPadding: 1,
    rightPadding: 1,
    borderStyle: 2
  });
  summaryTablePre.push(['included glob patterns:', coverageData.globIncludePatterns.join(', ')]);
  summaryTablePre.push(['excluded glob patterns:', (coverageData.globExcludePatterns || []).join(', ')]);
  summaryTablePre.push(['threshold:', coverageData.threshold]);
  summaryTablePre.push(['concurrent files:', coverageData.concurrentFiles]);
  summaryTablePre.push(['generated at:', coverageData.generatedAt]);
  summaryTablePre.push(['flow version:', coverageData.flowStatus.flowVersion]);
  summaryTablePre.push(['flow check passed:', (coverageData.flowStatus.passed ? 'yes' : 'no') + ' (' + (coverageData.flowStatus.errors.length >= 50 ? ' >= 50' : coverageData.flowStatus.errors.length) + ' errors)']);
  summaryTablePre.attrRange({
    row: [6]
  }, {
    color: coverageData.flowStatus.passed ? 'green' : 'red'
  });
  summaryTablePre.attrRange({
    column: [0, 1]
  }, {
    align: 'right'
  });
  var summaryTable = new _terminalTable["default"]({
    leftPadding: 1,
    rightPadding: 1,
    borderStyle: 2
  });
  summaryTable.push(['project', 'percent', 'total', 'covered', 'uncovered']);
  var summaryTotal = coverageData.covered_count + coverageData.uncovered_count;
  var summaryPercent = coverageData.percent;
  var summaryColor;

  if (summaryPercent >= (options.threshold || 80)) {
    summaryColor = 'green';
  } else {
    summaryColor = 'red';
  }

  summaryTable.push([_path["default"].basename(options.projectDir), summaryPercent + ' %', summaryTotal, coverageData.covered_count, coverageData.uncovered_count]);
  summaryTable.attrRange({
    row: [1]
  }, {
    color: summaryColor
  });
  summaryTable.attrRange({
    column: [1, 5]
  }, {
    align: 'right'
  });
  var waitForDrain = new Promise(function (resolve) {
    process.stdout.once('drain', resolve);
    var flushed = process.stdout.write('');

    if (flushed || options.log) {
      resolve();
    }
  });
  print(String(filesTable));
  print(String(summaryTablePre));
  print(String(summaryTable));
  return waitForDrain;
}

function generateFlowCoverageReportText(coverageData, options) {
  return renderTextReport(coverageData, options);
}

var ReportText = {
  render: renderTextReport,
  generate: generateFlowCoverageReportText
};
var _default = ReportText;
exports["default"] = _default;
//# sourceMappingURL=report-text.js.map