motion/lib/cli/index.js

'use strict';

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

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 _ora = require('ora');

var _ora2 = _interopRequireDefault(_ora);

var _open = require('open');

var _open2 = _interopRequireDefault(_open);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

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

var _lodash2 = _interopRequireDefault(_lodash);

var _stripAnsi = require('strip-ansi');

var _stripAnsi2 = _interopRequireDefault(_stripAnsi);

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

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

var _vorpal = require('./vorpal');

var _vorpal2 = _interopRequireDefault(_vorpal);

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) { step("next", value); }, function (err) { 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 CLI = function () {
  function CLI(projectPath, config) {
    _classCallCheck(this, CLI);

    this.vorpal = new _vorpal2.default();
    this.active = false;
    this.config = config;
    this.emitter = new _sbEventKit.Emitter();
    this.projectPath = projectPath;
    this.subscriptions = new _sbEventKit.CompositeDisposable();

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

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

      var serverAddress = 'http://localhost:' + this.config.webServerPort + '/';
      var manifest = {};
      try {
        Object.assign({}, require(_path2.default.join(this.projectPath, 'package.json')));
      } catch (_) {}

      this.vorpal.activate(manifest.name || _path2.default.basename(this.projectPath));
      this.vorpal.log(_chalk2.default.green('Server running at') + ' ' + serverAddress);
      this.vorpal.log('' + _chalk2.default.yellow('Type ' + _chalk2.default.underline('help') + ' to get list of available commands'));
      this.vorpal.addCommand('open', 'Open this app in Browser', function () {
        (0, _open2.default)(serverAddress);
      });
      this.vorpal.addCommand('editor', 'Open this app in Atom', _asyncToGenerator(function* () {
        var defaultEditor = 'atom';
        var editor = process.env.EDITOR || defaultEditor;

        var editorName = _path2.default.basename(editor);
        if (editorName === 'nano' || editorName === 'vi' || editorName === 'vim') {
          editor = defaultEditor;
        }

        yield (0, _sbExec.exec)(editor, [_this.projectPath]);
      }));
      this.vorpal.addCommand('build', 'Build this app for production usage', _asyncToGenerator(function* () {
        yield _this.emitter.emit('should-build');
        _this.vorpal.log('Dist files built successfully in', _path2.default.relative(_this.projectPath, _this.config.outputDirectory));
      }));
      this.vorpal.replaceCommand('exit', 'Exit motion daemon', function () {
        _this.emitter.emit('should-dispose');
        process.exit();
      });
      this.active = true;
    }
  }, {
    key: 'deactivate',
    value: function deactivate() {
      this.vorpal.deactivate();
    }
  }, {
    key: 'log',
    value: function log(given) {
      var contents = given;
      if (this.active) {
        this.vorpal.log(contents);
      } else {
        if (!process.stdout.isTTY) {
          contents = (0, _stripAnsi2.default)(contents);
        }
        console.log(contents);
      }
    }
  }, {
    key: 'addSpinner',
    value: function addSpinner(text) {
      if (!this.active) {
        this.log(text);
        return;
      }

      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) {
      if (!this.active) {
        return;
      }

      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() {
      if (!this.active) {
        return;
      }
      var spinner = this.spinner;
      if (spinner) {
        spinner.instance.stop();
        this.vorpal.instance.ui.refresh();
      }
    }
  }, {
    key: 'onShouldBuild',
    value: function onShouldBuild(callback) {
      return this.emitter.on('should-build', callback);
    }
  }, {
    key: 'onShouldDispose',
    value: function onShouldDispose(callback) {
      return this.emitter.on('should-dispose', callback);
    }
  }, {
    key: 'dispose',
    value: function dispose() {
      this.vorpal.dispose();
      this.subscriptions.dispose();
    }
  }]);

  return CLI;
}();

exports.default = CLI;