create-component-template/dist/lib/config/importer.js

Generates react components from templates

'use strict';

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var path = require('path');

var _require = require('../utils/logger'),
    logError = _require.logError,
    logInfo = _require.logInfo;

var defaultArgs = require('../args/default.js');

var _require2 = require('../utils/pathing'),
    getModuleRootDir = _require2.getModuleRootDir;

/*
  1 - check for specified config location
  2 - check appRootDir
  3 - check package.json
  4 - get from default path
 */


var importConfig = function () {
  var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(appRootDir, configPath) {
    var config;
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            config = void 0;
            _context.prev = 1;

            if (!configPath) {
              _context.next = 4;
              break;
            }

            return _context.abrupt('return', getConfigFromProvidedConfigPath(appRootDir, configPath));

          case 4:

            // Root Dir
            // No Throw but move next
            config = getConfigFromRootDir(appRootDir);

            if (!config) {
              _context.next = 7;
              break;
            }

            return _context.abrupt('return', config);

          case 7:

            // Package Json
            // No Throw but move next
            config = getConfigFromPackageJson(appRootDir);

            if (!config) {
              _context.next = 10;
              break;
            }

            return _context.abrupt('return', config);

          case 10:

            // Default Config
            config = getConfigFromDefaultConfigPath(getModuleRootDir(), defaultArgs.configPath);

            if (!config) {
              _context.next = 13;
              break;
            }

            return _context.abrupt('return', config);

          case 13:
            _context.next = 19;
            break;

          case 15:
            _context.prev = 15;
            _context.t0 = _context['catch'](1);

            logError(_context.t0 + '\n      cct.config could not be loaded. please see the README for details on setting cct.config');
            throw _context.t0;

          case 19:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, undefined, [[1, 15]]);
  }));

  return function importConfig(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();

var getConfigFromProvidedConfigPath = function getConfigFromProvidedConfigPath(appRootDir, configPath) {
  try {
    return require(path.join(appRootDir, configPath));
  } catch (err) {
    throw new Error('cct.config at provided config path not found');
  }
};

var getConfigFromRootDir = function getConfigFromRootDir(appRootDir) {
  try {
    return require(path.join(appRootDir, 'cct.config.js'));
  } catch (err) {}
};

var getConfigFromPackageJson = function getConfigFromPackageJson(appRootDir) {
  return require(appRootDir + '/package.json')['cct.config'];
};

var getConfigFromDefaultConfigPath = function getConfigFromDefaultConfigPath(moduleRootDir, configPath) {
  logInfo('No config file found. Reverting to default templates.');

  return require(path.join(moduleRootDir, configPath));
};

module.exports = importConfig;