Mini Shell

"use strict";

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var globby = require('globby');

var Commander = require('commander');

var _require = require('.'),
    isAcceptedNodeVersion = _require.isAcceptedNodeVersion,
    writePackageJSON = _require.writePackageJSON,
    writeBabelRC = _require.writeBabelRC,
    writeMochaOpts = _require.writeMochaOpts,
    installDeps = _require.installDeps;

if (!isAcceptedNodeVersion()) {
  throw new Error("Babel 7 will only support Node 4 and higher");
}

Commander.usage('[options]').option('-w, --write', 'Write back updated configure files').option('-i, --install', 'Install all the updated dependencies').allowUnknownOption(false).parse(process.argv);

function hasFlow() {
  return _hasFlow.apply(this, arguments);
} // TODO: allow passing a specific path


function _hasFlow() {
  _hasFlow = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee2() {
    var flowConfigs;
    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return globby(['**/.flowconfig', '!**/node_modules/**']);

          case 2:
            flowConfigs = _context2.sent;
            return _context2.abrupt("return", flowConfigs.length > 0);

          case 4:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _hasFlow.apply(this, arguments);
}

_asyncToGenerator(
/*#__PURE__*/
regeneratorRuntime.mark(function _callee() {
  var paths, packages, mochaOpts, flow, upgradeOptions;
  return regeneratorRuntime.wrap(function _callee$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _context.next = 2;
          return globby(['**/.babelrc', '!**/node_modules/**']);

        case 2:
          paths = _context.sent;
          _context.next = 5;
          return globby(['**/package.json', '!**/node_modules/**']);

        case 5:
          packages = _context.sent;
          _context.next = 8;
          return globby(['**/mocha.opts', '!**/node_modules/**']);

        case 8:
          mochaOpts = _context.sent;
          _context.next = 11;
          return hasFlow();

        case 11:
          flow = _context.sent;
          upgradeOptions = {
            hasFlow: flow,
            write: Commander.write
          }; // if not a monorepo

          if (packages.length === 1) {
            if (paths.length > 1) {
              console.log("We suggest using the new 'overrides' option instead of nested .babelrc's, can check out http://new.babeljs.io/docs/en/next/babelrc.html#overrides");
              console.log("");
            }

            paths.forEach(function (p) {
              return writeBabelRC(p, upgradeOptions);
            });
          }

          mochaOpts.forEach(function (p) {
            return writeMochaOpts(p, upgradeOptions);
          }); // TODO: allow passing a specific path

          _context.next = 17;
          return writePackageJSON(upgradeOptions);

        case 17:
          if (Commander.install) {
            _context.next = 19;
            break;
          }

          return _context.abrupt("return");

        case 19:
          if (!Commander.write) {
            _context.next = 25;
            break;
          }

          console.log('Installing new dependencies');
          _context.next = 23;
          return installDeps();

        case 23:
          _context.next = 27;
          break;

        case 25:
          console.error('Run babel-upgrade with --write (or) -w and --install for it to install the newly added dependencies');
          process.exit(1);

        case 27:
        case "end":
          return _context.stop();
      }
    }
  }, _callee);
}))();