motion/lib/index.js

'use strict';

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 _sbFs = require('sb-fs');

var _sbFs2 = _interopRequireDefault(_sbFs);

var _sbCopy = require('sb-copy');

var _sbCopy2 = _interopRequireDefault(_sbCopy);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _sbConfigFile = require('sb-config-file');

var _sbConfigFile2 = _interopRequireDefault(_sbConfigFile);

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

var _compilation = require('./compilation');

var _compilation2 = _interopRequireDefault(_compilation);

var _helpers = require('./helpers');

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 PRIVATE_VAR = {};

var Motion = function () {
  function Motion(privateVar, projectPath, config, options) {
    _classCallCheck(this, Motion);

    if (privateVar !== PRIVATE_VAR) {
      throw new Error('Invalid invocation of new Motion(). Use Motion.get() instead');
    }

    this.config = config;
    this.options = options;
    this.projectPath = projectPath;
    this.compilation = new _compilation2.default(projectPath, config, options);
    this.subscriptions = new _sbEventKit.CompositeDisposable();

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

  _createClass(Motion, [{
    key: 'exists',
    value: function () {
      var _ref = _asyncToGenerator(function* () {
        return _sbFs2.default.exists(_path2.default.join(this.projectPath, _helpers.CONFIG_FILE_NAME));
      });

      function exists() {
        return _ref.apply(this, arguments);
      }

      return exists;
    }()
  }, {
    key: 'watch',
    value: function () {
      var _ref2 = _asyncToGenerator(function* () {
        if (!(yield this.exists())) {
          throw new Error('Unable to run, directory is not a motion app');
        }
        try {
          yield this.compilation.watch(this.options.useCache);
        } catch (error) {
          (yield this.compilation.getPundle(true)).context.report(error);
          return false;
        }
        return true;
      });

      function watch() {
        return _ref2.apply(this, arguments);
      }

      return watch;
    }()
  }, {
    key: 'build',
    value: function () {
      var _ref3 = _asyncToGenerator(function* () {
        if (!(yield this.exists())) {
          throw new Error('Unable to run, directory is not a motion app');
        }
        try {
          yield this.compilation.build(this.options.useCache);
        } catch (error) {
          (yield this.compilation.getPundle(false)).context.report(error);
        }
      });

      function build() {
        return _ref3.apply(this, arguments);
      }

      return build;
    }()
  }, {
    key: 'init',
    value: function () {
      var _ref4 = _asyncToGenerator(function* () {
        var overwrite = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        if (yield this.exists()) {
          throw new Error('Directory is already a motion app');
        }
        yield _sbFs2.default.mkdirp(this.projectPath);
        yield _sbFs2.default.mkdirp(this.config.outputDirectory);
        yield (0, _sbCopy2.default)(_path2.default.normalize(_path2.default.join(__dirname, '..', 'template', 'bundle')), this.projectPath, {
          overwrite: overwrite,
          failIfExists: false
        });
        yield (0, _sbCopy2.default)(_path2.default.normalize(_path2.default.join(__dirname, '..', 'template', 'dist')), this.config.outputDirectory, {
          overwrite: overwrite,
          failIfExists: false
        });
        yield _sbFs2.default.writeFile(_path2.default.join(this.projectPath, _helpers.CONFIG_FILE_NAME), JSON.stringify(_helpers.CONFIG_FILE_DEFAULT, null, 2));
      });

      function init() {
        return _ref4.apply(this, arguments);
      }

      return init;
    }()
  }, {
    key: 'dispose',
    value: function dispose() {
      this.subscriptions.dispose();
    }
  }], [{
    key: 'create',
    value: function () {
      var _ref5 = _asyncToGenerator(function* (projectRoot, options) {
        var configFile = yield _sbConfigFile2.default.get(_path2.default.join(projectRoot, _helpers.CONFIG_FILE_NAME), _helpers.CONFIG_FILE_DEFAULT, _helpers.CONFIG_FILE_OPTIONS);
        var config = yield configFile.get();

        config.outputDirectory = _path2.default.resolve(projectRoot, config.outputDirectory);

        return new Motion(PRIVATE_VAR, projectRoot, config, options);
      });

      function create(_x2, _x3) {
        return _ref5.apply(this, arguments);
      }

      return create;
    }()
  }]);

  return Motion;
}();

module.exports = Motion;