flow-coverage-report/dist/lib/index.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"] = generateFlowCoverageReport;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

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

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

var _config = require("./cli/config");

var _flow = require("./flow");

var _promisified = require("./promisified");

var _reportHtml = _interopRequireDefault(require("./report-html"));

var _reportBadge = _interopRequireDefault(require("./report-badge"));

var _reportJson = _interopRequireDefault(require("./report-json"));

var _reportText = _interopRequireDefault(require("./report-text"));

// User Scenarios
// 1. generate text report from a project dir
// 2. generate text report from a project dir and save json to file
// 3. generate text report from a project dir and html report
// 4. generate text/html report from a saved json file
// 5. set a custom threshold
// 6. set a custom output dir
// 7. usa a saved json file to compute coverage trend (and fail on negative trends)
function generateFlowCoverageReport(_x) {
  return _generateFlowCoverageReport.apply(this, arguments);
}

function _generateFlowCoverageReport() {
  _generateFlowCoverageReport = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(options) {
    var projectDir, temporaryDirPath, coverageData, reportResults, reportTypes;
    return _regenerator["default"].wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            // Apply defaults to options.
            projectDir = options.projectDir;

            if (!(process.env.VERBOSE && process.env.VERBOSE === 'DUMP_JSON')) {
              _context.next = 6;
              break;
            }

            _context.next = 4;
            return (0, _promisified.withTmpDir)('flow-coverage-report');

          case 4:
            temporaryDirPath = _context.sent;
            console.log("Verbose DUMP_JSON mode enabled (".concat(temporaryDirPath, ")"));

          case 6:
            options.flowCommandPath = options.flowCommandPath || 'flow';
            options.flowCommandTimeout = options.flowCommandTimeout || _config.DEFAULT_FLOW_TIMEOUT; // Defaults to 15s

            options.outputDir = options.outputDir || './flow-coverage';
            options.outputDir = _path["default"].isAbsolute(options.outputDir) ? options.outputDir : _path["default"].resolve(_path["default"].join(projectDir, options.outputDir));
            options.globIncludePatterns = options.globIncludePatterns || [];
            options.globExcludePatterns = options.globExcludePatterns || [];
            options.concurrentFiles = options.concurrentFiles || 1;

            if (!Array.isArray(options.globExcludePatterns)) {
              options.globExcludePatterns = [options.globExcludePatterns];
            } // Apply validation checks.


            if (projectDir) {
              _context.next = 16;
              break;
            }

            throw new TypeError('projectDir option is mandatory');

          case 16:
            if (!(options.globIncludePatterns.length === 0)) {
              _context.next = 18;
              break;
            }

            throw new TypeError('empty globIncludePatterns option');

          case 18:
            if (options.threshold) {
              _context.next = 20;
              break;
            }

            throw new TypeError('threshold option is mandatory');

          case 20:
            _context.next = 22;
            return (0, _flow.collectFlowCoverage)(options, temporaryDirPath);

          case 22:
            coverageData = _context.sent;
            reportResults = [];
            reportTypes = options.reportTypes || ['text'];

            if (reportTypes.includes('json')) {
              reportResults.push(_reportJson["default"].generate(coverageData, options));
            }

            if (reportTypes.includes('text')) {
              reportResults.push(_reportText["default"].generate(coverageData, options));
            } // Run the badge reporter implicitly if the html report has been included.


            if (reportTypes.includes('badge') || reportTypes.includes('html')) {
              reportResults.push(_reportBadge["default"].generate(coverageData, options));
            }

            if (reportTypes.includes('html')) {
              // eslint-disable-next-line promise/prefer-await-to-then
              reportResults.push(_reportHtml["default"].generate(coverageData, options).then(function () {
                console.log("View generated HTML Report at file://".concat(options.outputDir, "/index.html"));
              }));
            }

            _context.next = 31;
            return Promise.all(reportResults);

          case 31:
            return _context.abrupt("return", [coverageData, options]);

          case 32:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _generateFlowCoverageReport.apply(this, arguments);
}
//# sourceMappingURL=index.js.map