motion/lib/cli/index.js

'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _sbEventKit = require('sb-event-kit');

var _ora = require('ora');

var _ora2 = _interopRequireDefault(_ora);

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _open = require('open');

var _open2 = _interopRequireDefault(_open);

var _lodash = require('lodash.uniq');

var _lodash2 = _interopRequireDefault(_lodash);

var _sbExec = require('sb-exec');

var _cli2 = require('./cli');

var _cli3 = _interopRequireDefault(_cli2);

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"); }); }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var SPINNER_GLUE = ' & ';

var Main = function () {
  function Main(config) {
    _classCallCheck(this, Main);

    this.cli = new _cli3.default();
    this.active = false;
    this.config = config;
    this.emitter = new _sbEventKit.Emitter();
    this.subscriptions = new _sbEventKit.CompositeDisposable();

    this.subscriptions.add(this.emitter);
  }

  _createClass(Main, [{
    key: 'activate',
    value: function activate() {
      var _this = this;

      if (this.active) {
        this.cli.activate();
        return;
      }

      var serverAddress = 'http://localhost:' + this.config.get('webServerPort') + '/';

      this.cli.activate();
      this.cli.log(_chalk2.default.green('Server running at') + ' ' + serverAddress);
      this.cli.log('' + _chalk2.default.yellow('Type ' + _chalk2.default.underline('help') + ' to get list of available commands'));
      this.cli.addCommand('open', 'Open this app in Browser', function () {
        (0, _open2.default)(serverAddress);
      });
      this.cli.addCommand('editor', 'Open this app in Atom', _asyncToGenerator(function* () {
        yield (0, _sbExec.exec)('atom', [_this.config.getBundleDirectory()]);
      }));
      this.cli.addCommand('build', 'Build this app for production usage', _asyncToGenerator(function* () {
        yield _this.emitter.emit('should-build');
        _this.cli.log('Dist files built successfully in', _this.config.getPublicDirectory());
      }));
      this.cli.addCommand('reload', 'Rebuild the bundle clearing all cache', _asyncToGenerator(function* () {
        try {
          yield _this.emitter.emit('should-reload');
          _this.cli.log('Bundle reloaded peacefully');
        } catch (_) {
          _this.cli.log('Unable to reload the bundle', _);
        }
      }));
      this.cli.replaceCommand('exit', 'Exit motion daemon', function () {
        _this.emitter.emit('should-dispose');
        process.exit();
      });
      // TODO: Read manifest scripts and prompt to run them here
    }
  }, {
    key: 'deactivate',
    value: function deactivate() {
      this.cli.deactivate();
    }
  }, {
    key: 'log',
    value: function log() {
      var _cli;

      (_cli = this.cli).log.apply(_cli, arguments);
    }
  }, {
    key: 'addSpinner',
    value: function addSpinner(text) {
      var spinner = this.spinner;
      if (spinner) {
        spinner.texts.push(text);
        spinner.instance.text = (0, _lodash2.default)(spinner.texts).join(SPINNER_GLUE);
      } else {
        var _instance = new _ora2.default({
          text: text,
          color: 'yellow'
        });
        this.spinner = {
          texts: [text],
          instance: _instance
        };
        _instance.start();
      }
    }
  }, {
    key: 'removeSpinner',
    value: function removeSpinner(text) {
      var spinner = this.spinner;
      if (spinner) {
        var index = spinner.texts.indexOf(text);
        if (index !== -1) {
          spinner.texts.splice(index, 1);
        }
        if (spinner.texts.length) {
          spinner.instance.text = (0, _lodash2.default)(spinner.texts).join(SPINNER_GLUE);
        } else {
          this.removeAllSpinners();
        }
      }
    }
  }, {
    key: 'removeAllSpinners',
    value: function removeAllSpinners() {
      var spinner = this.spinner;
      if (spinner) {
        spinner.instance.stop();
        this.cli.instance.ui.refresh();
      }
    }
  }, {
    key: 'onShouldBuild',
    value: function onShouldBuild(callback) {
      return this.emitter.on('should-build', callback);
    }
  }, {
    key: 'onShouldReload',
    value: function onShouldReload(callback) {
      return this.emitter.on('should-reload', callback);
    }
  }, {
    key: 'onShouldDispose',
    value: function onShouldDispose(callback) {
      return this.emitter.on('should-dispose', callback);
    }
  }, {
    key: 'dispose',
    value: function dispose() {
      this.cli.dispose();
      this.subscriptions.dispose();
    }
  }]);

  return Main;
}();

exports.default = Main;
//# sourceMappingURL=index.js.map