motion/lib/runner/bundler/install.js

motion - moving development forward

exports.__esModule = true;

// ensures all packages installed, uninstalled, written out to bundle

var install = _asyncToGenerator(function* (force) {
  _libFns.log.externals('install');
  try {
    yield _libRemakeInstallDir2['default'](force);
    yield _uninstall.uninstall();
    yield installAll();
    yield _externals.externals({ force: force });
  } catch (e) {
    _libFns.handleError(e);
    throw new Error(e);
  }
});

exports.install = install;
exports.willInstall = willInstall;
exports.getNew = getNew;

var installAll = _asyncToGenerator(function* (requires) {
  try {
    requires = requires || _cache2['default'].getExternals();

    // nothing to install
    if (!requires.length && !_isInstalling && _opts2['default']('finishingFirstBuild')) _opts2['default'].set('hasRunInitialInstall', true);

    if (!requires.length) return requires;

    // determine whats new
    var installed = yield _libInstalled.readInstalled();
    var fresh = yield getNew(requires, installed);

    _libFns.log.externals('installAll fresh', fresh);

    // nothing new
    if (!fresh.length) {
      if (!_isInstalling && _opts2['default']('finishingFirstBuild')) _opts2['default'].set('hasRunInitialInstall', true);

      // new motion excluded require like babel-runtime, see rmExternals
      if (requires.length) {
        yield _libInstalled.writeInstalled(installed);
        yield _externals.externals({ silent: true });
      }
      return;
    }

    // track full require paths "babel-runtime/interop/etc"
    installingFullNames = installingFullNames.concat(requires);

    // push installing
    installing = installing.concat(fresh);

    // check if already installing stuff
    if (_isInstalling) return yield finishedInstalls();

    // install!
    _isInstalling = true;
    yield runInstall(installed);
  } catch (e) {
    _libFns.handleError(e);
  }
});

exports.installAll = installAll;
exports.isInstalling = isInstalling;
exports.finishedInstalling = finishedInstalling;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { var callNext = step.bind(null, 'next'); var callThrow = step.bind(null, 'throw'); function step(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(callNext, callThrow); } } callNext(); }); }; }

var _libInstalled = require('./lib/installed');

var _libFns = require('../lib/fns');

var _cache = require('../cache');

var _cache2 = _interopRequireDefault(_cache);

var _opts = require('../opts');

var _opts2 = _interopRequireDefault(_opts);

var _libMessages = require('./lib/messages');

var _libNpm = require('./lib/npm');

var _libNpm2 = _interopRequireDefault(_libNpm);

var _libNormalize = require('./lib/normalize');

var _libNormalize2 = _interopRequireDefault(_libNormalize);

var _libRemakeInstallDir = require('./lib/remakeInstallDir');

var _libRemakeInstallDir2 = _interopRequireDefault(_libRemakeInstallDir);

var _uninstall = require('./uninstall');

var _externals = require('./externals');

var successful = [];
var failed = [];
var installingFullNames = [];
var installing = [];
var _isInstalling = false;

// used to quickly check if a file will trigger an install

function willInstall(imports) {
  // TODO dont ignore internals
  return !!getNew(imports.filter(function (x) {
    return x.charAt(0) != '.';
  })).length;
}

// finds the new externals to install

function getNew(requires) {
  var installed = arguments.length <= 1 || arguments[1] === undefined ? _libInstalled.readInstalledCache() : arguments[1];

  if (!requires.length) return requires;

  var names = _libNormalize2['default'](requires);
  if (!names.length) return names;

  var fresh = _libFns._.difference(names, installed, installing);
  // log.externals('DOWN', '  ', names, '- ', installed, '- ', installing, '  = ', fresh)
  return fresh;
}

function runInstall(prevInstalled, toInstall) {
  var installNext = _asyncToGenerator(function* () {
    var dep = installing[0];

    // ignore empty
    if (dep === '') {
      installing.shift();
      return;
    }

    _libMessages.onStart(dep);

    try {
      yield _libNpm2['default'].save(dep);
      _libFns.log.externals('install', 'succces, saved', dep);
      successful.push(dep);
      _libMessages.onFinish(dep);
    } catch (e) {
      console.error(('\n  ' + e.message).red);
      failed.push(dep);
      _libFns.log.externals('package install failed', dep, e.message, e.stack);
      _libMessages.onError(dep, e);
    } finally {
      var installed = installing.shift();

      // remove
      _libFns.log.externals('install, finally:', installing);
      next();
    }
  });

  var done = _asyncToGenerator(function* () {
    var installedFullPaths = _libFns._.uniq(_libFns._.flattenDeep(_libFns._.compact(installingFullNames)));
    var finalPaths = _libFns._.uniq([].concat(prevInstalled, installedFullPaths));
    _libFns.log.externals('DONE, finalPaths', finalPaths);

    // remove failed
    if (failed && failed.length) finalPaths = finalPaths.filter(function (dep) {
      return failed.indexOf(dep) >= 0;
    });

    logInstalled(successful);
    yield _libInstalled.writeInstalled(finalPaths, toInstall);
    yield _externals.externals();

    // reset
    installingFullNames = [];
    failed = [];
    _isInstalling = false;
    _opts2['default'].set('hasRunInitialInstall', true);
    isDone = true;
  });

  var isDone = false;

  function next() {
    _libFns.log.externals('next #', installing.length);
    return installing.length ? installNext() : done();
  }

  return new Promise(function (res) {
    // start
    installNext();

    var finish = setInterval(function () {
      if (isDone) {
        clearInterval(finish);
        finishedWatchers.forEach(function (w) {
          return w();
        });
        res();
      }
    }, 50);
  });
}

// to ensure we wait for installs
var finishedWatchers = [];
function finishedInstalls() {
  return new Promise(function (res) {
    finishedWatchers.push(function () {
      res();
    });
  });
}

function logInstalled(deps) {
  if (!deps.length) return;
  deps = _libFns._.uniq(deps); // TODO this is fixing a bug upwards
  print(('\n  Installed ' + deps.length + ' packages').dim);
  deps.forEach(function (dep) {
    return print(('  ✓ ' + dep).green);
  });
}

function isInstalling() {
  _libFns.log.externals('isInstalling()', _isInstalling);
  return _isInstalling;
}

// check for install finish

function finishedInstalling() {
  return new Promise(finishedInstallingLoop);
}

function isDone() {
  return _opts2['default']('build') && !_opts2['default']('watch') ? !_isInstalling && _opts2['default']('hasRunInitialInstall') : !_isInstalling;
}

function finishedInstallingLoop(res) {
  if (isDone()) res();else {
    setTimeout(function () {
      return finishedInstallingLoop(res);
    }, 100);
  }
}