motion/lib/runner/bundler/install.js

motion - moving development forward

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.installAll = undefined;

let installAll = exports.installAll = function () {
  var ref = _asyncToGenerator(function* (requires) {
    try {
      requires = requires || _cache2.default.getExternals();

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

      if (!requires.length) return requires;

      // determine whats new
      const installed = yield (0, _installed.readInstalled)();
      const fresh = yield getNew(requires, installed);

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

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

        // new motion excluded require like babel-runtime, see rmExternals
        if (requires.length) {
          yield (0, _installed.writeInstalled)(installed);
          yield (0, _externals.writeExternals)({ 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) {
      (0, _fns.handleError)(e);
    }
  });

  return function installAll(_x2) {
    return ref.apply(this, arguments);
  };
}();

exports.getNew = getNew;
exports.isInstalling = isInstalling;
exports.finishedInstalling = finishedInstalling;

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

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

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

var _cache2 = _interopRequireDefault(_cache);

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

var _opts2 = _interopRequireDefault(_opts);

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

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

var _npm2 = _interopRequireDefault(_npm);

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

var _normalize2 = _interopRequireDefault(_normalize);

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

var _remakeInstallDir2 = _interopRequireDefault(_remakeInstallDir);

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

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

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) { 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 { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

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

// finds the new externals to install
function getNew(requires) {
  let installed = arguments.length <= 1 || arguments[1] === undefined ? (0, _installed.readInstalledCache)() : arguments[1];

  if (!requires.length) return requires;

  const names = (0, _normalize2.default)(requires);
  if (!names.length) return names;

  const fresh = _fns._.difference(names, installed, installing);
  _fns.log.externals('DOWN', 'fresh', fresh);
  return fresh;
}

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

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

      (0, _messages.onStart)(dep);

      try {
        yield _npm2.default.save(dep);
        _fns.log.externals('install', 'succces, saved', dep);
        successful.push(dep);
        (0, _messages.onFinish)(dep);
      } catch (e) {
        console.error(`\n  ${ e.message }`.red);
        failed.push(dep);
        _fns.log.externals('package install failed', dep, e.message, e.stack);
        (0, _messages.onError)(dep, e);
      } finally {
        let installed = installing.shift();

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

    return function installNext() {
      return ref.apply(this, arguments);
    };
  }();

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

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

      logInstalled(successful);
      yield (0, _installed.writeInstalled)(finalPaths, toInstall);
      yield (0, _externals.writeExternals)();

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

    return function done() {
      return ref.apply(this, arguments);
    };
  }();

  let isDone = false;

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

  return new Promise(res => {
    // start
    installNext();

    let finish = setInterval(() => {
      if (isDone) {
        clearInterval(finish);
        finishedWatchers.forEach(w => w());
        res();
      }
    }, 50);
  });
}

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

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

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

// check for install finish
function finishedInstalling() {
  return new Promise(finishedInstallingLoop);
}

function isDone() {
  return !(0, _opts2.default)('watching') ? !_isInstalling && (0, _opts2.default)('hasRunInitialInstall') : !_isInstalling;
}

function finishedInstallingLoop(res) {
  if (isDone()) res();else {
    setTimeout(() => finishedInstallingLoop(res), 100);
  }
}
//# sourceMappingURL=install.js.map