electron-compile
Version:
Electron supporting package to compile JS and CSS in Electron applications
589 lines (473 loc) • 44.4 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.createCompilerHostFromProjectRoot = exports.createCompilerHostFromConfigFile = exports.createCompilerHostFromBabelRc = undefined;
var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _getIterator2 = require('babel-runtime/core-js/get-iterator');
var _getIterator3 = _interopRequireDefault(_getIterator2);
var _regenerator = require('babel-runtime/regenerator');
var _regenerator2 = _interopRequireDefault(_regenerator);
var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
var _keys = require('babel-runtime/core-js/object/keys');
var _keys2 = _interopRequireDefault(_keys);
var _stringify = require('babel-runtime/core-js/json/stringify');
var _stringify2 = _interopRequireDefault(_stringify);
/**
* Creates a compiler host from a .babelrc file. This method is usually called
* from {@link createCompilerHostFromProjectRoot} instead of used directly.
*
* @param {string} file The path to a .babelrc file
*
* @param {string} rootCacheDir (optional) The directory to use as a cache.
*
* @return {Promise<CompilerHost>} A set-up compiler host
*/
var createCompilerHostFromBabelRc = exports.createCompilerHostFromBabelRc = function () {
var ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(file) {
var rootCacheDir = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
var info, ourEnv;
return _regenerator2.default.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.t0 = JSON;
_context.next = 3;
return _promise.pfs.readFile(file, 'utf8');
case 3:
_context.t1 = _context.sent;
info = _context.t0.parse.call(_context.t0, _context.t1);
// package.json
if ('babel' in info) {
info = info.babel;
}
if ('env' in info) {
ourEnv = process.env.BABEL_ENV || process.env.NODE_ENV || 'development';
info = info.env[ourEnv];
}
// Are we still package.json (i.e. is there no babel info whatsoever?)
if (!('name' in info && 'version' in info)) {
_context.next = 9;
break;
}
return _context.abrupt('return', createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: getDefaultConfiguration(),
rootCacheDir: rootCacheDir
}));
case 9:
return _context.abrupt('return', createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: {
'application/javascript': info
},
rootCacheDir: rootCacheDir
}));
case 10:
case 'end':
return _context.stop();
}
}
}, _callee, this);
}));
return function createCompilerHostFromBabelRc(_x3) {
return ref.apply(this, arguments);
};
}();
/**
* Creates a compiler host from a .compilerc file. This method is usually called
* from {@link createCompilerHostFromProjectRoot} instead of used directly.
*
* @param {string} file The path to a .compilerc file
*
* @param {string} rootCacheDir (optional) The directory to use as a cache.
*
* @return {Promise<CompilerHost>} A set-up compiler host
*/
var createCompilerHostFromConfigFile = exports.createCompilerHostFromConfigFile = function () {
var ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(file) {
var rootCacheDir = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
var info, _ourEnv;
return _regenerator2.default.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_context2.t0 = JSON;
_context2.next = 3;
return _promise.pfs.readFile(file, 'utf8');
case 3:
_context2.t1 = _context2.sent;
info = _context2.t0.parse.call(_context2.t0, _context2.t1);
if ('env' in info) {
_ourEnv = process.env.ELECTRON_COMPILE_ENV || process.env.NODE_ENV || 'development';
info = info.env[_ourEnv];
}
return _context2.abrupt('return', createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: info,
rootCacheDir: rootCacheDir
}));
case 7:
case 'end':
return _context2.stop();
}
}
}, _callee2, this);
}));
return function createCompilerHostFromConfigFile(_x5) {
return ref.apply(this, arguments);
};
}();
/**
* Creates a configured {@link CompilerHost} instance from the project root
* directory. This method first searches for a .compilerc, then falls back to the
* default locations for Babel configuration info. If neither are found, defaults
* to standard settings
*
* @param {string} rootDir The root application directory (i.e. the directory
* that has the app's package.json)
*
* @param {string} rootCacheDir (optional) The directory to use as a cache.
*
* @return {Promise<CompilerHost>} A set-up compiler host
*/
var createCompilerHostFromProjectRoot = exports.createCompilerHostFromProjectRoot = function () {
var ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(rootDir) {
var rootCacheDir = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
var compilerc, babelrc;
return _regenerator2.default.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
compilerc = _path2.default.join(rootDir, '.compilerc');
if (!statSyncNoException(compilerc)) {
_context3.next = 6;
break;
}
d('Found a .compilerc at ' + compilerc + ', using it');
_context3.next = 5;
return createCompilerHostFromConfigFile(compilerc, rootCacheDir);
case 5:
return _context3.abrupt('return', _context3.sent);
case 6:
babelrc = _path2.default.join(rootDir, '.babelrc');
if (!statSyncNoException(babelrc)) {
_context3.next = 12;
break;
}
d('Found a .babelrc at ' + babelrc + ', using it');
_context3.next = 11;
return createCompilerHostFromBabelRc(babelrc, rootCacheDir);
case 11:
return _context3.abrupt('return', _context3.sent);
case 12:
d('Using package.json or default parameters at ' + rootDir);
_context3.next = 15;
return createCompilerHostFromBabelRc(_path2.default.join(rootDir, 'package.json'), rootCacheDir);
case 15:
return _context3.abrupt('return', _context3.sent);
case 16:
case 'end':
return _context3.stop();
}
}
}, _callee3, this);
}));
return function createCompilerHostFromProjectRoot(_x7) {
return ref.apply(this, arguments);
};
}();
exports.initializeGlobalHooks = initializeGlobalHooks;
exports.init = init;
exports.createCompilerHostFromConfiguration = createCompilerHostFromConfiguration;
exports.createCompilerHostFromBabelRcSync = createCompilerHostFromBabelRcSync;
exports.createCompilerHostFromConfigFileSync = createCompilerHostFromConfigFileSync;
exports.createCompilerHostFromProjectRootSync = createCompilerHostFromProjectRootSync;
exports.calculateDefaultCompileCacheDirectory = calculateDefaultCompileCacheDirectory;
exports.getDefaultConfiguration = getDefaultConfiguration;
exports.createCompilers = createCompilers;
var _lodash = require('lodash');
var _lodash2 = _interopRequireDefault(_lodash);
var _fs = require('fs');
var _fs2 = _interopRequireDefault(_fs);
var _path = require('path');
var _path2 = _interopRequireDefault(_path);
var _mkdirp = require('mkdirp');
var _mkdirp2 = _interopRequireDefault(_mkdirp);
var _promise = require('./promise');
var _fileChangeCache = require('./file-change-cache');
var _fileChangeCache2 = _interopRequireDefault(_fileChangeCache);
var _compilerHost = require('./compiler-host');
var _compilerHost2 = _interopRequireDefault(_compilerHost);
var _protocolHook = require('./protocol-hook');
var _requireHook = require('./require-hook');
var _requireHook2 = _interopRequireDefault(_requireHook);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var d = require('debug')('electron-compile:config-parser');
// NB: We intentionally delay-load this so that in production, you can create
// cache-only versions of these compilers
var allCompilerClasses = null;
function statSyncNoException(fsPath) {
if ('statSyncNoException' in _fs2.default) {
return _fs2.default.statSyncNoException(fsPath);
}
try {
return _fs2.default.statSync(fsPath);
} catch (e) {
return null;
}
}
/**
* Initialize the global hooks (protocol hook for file:, node.js hook)
* independent of initializing the compiler. This method is usually called by
* init instead of directly
*
* @param {CompilerHost} compilerHost The compiler host to use.
*
*/
function initializeGlobalHooks(compilerHost) {
var globalVar = global || window;
globalVar.globalCompilerHost = compilerHost;
(0, _requireHook2.default)(compilerHost);
if ('type' in process && process.type === 'browser') {
var _require = require('electron');
var app = _require.app;
var protoify = function protoify() {
(0, _protocolHook.initializeProtocolHook)(compilerHost);
};
if (app.isReady()) {
protoify();
} else {
app.on('ready', protoify);
}
}
}
/**
* Initialize electron-compile and set it up, either for development or
* production use. This is almost always the only method you need to use in order
* to use electron-compile.
*
* @param {string} appRoot The top-level directory for your application (i.e.
* the one which has your package.json).
*
* @param {string} mainModule The module to require in, relative to the module
* calling init, that will start your app. Write this
* as if you were writing a require call from here.
*
* @param {bool} productionMode If explicitly True/False, will set read-only
* mode to be disabled/enabled. If not, we'll
* guess based on the presence of a production
* cache.
*/
function init(appRoot, mainModule) {
var productionMode = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];
var compilerHost = null;
var cacheDir = _path2.default.join(appRoot, '.cache');
if (productionMode === null) {
productionMode = !!statSyncNoException(cacheDir);
}
if (productionMode) {
// In read-only mode, we'll assume that everything is in `appRoot/.cache`
compilerHost = _compilerHost2.default.createReadonlyFromConfigurationSync(cacheDir, appRoot);
} else {
compilerHost = createCompilerHostFromProjectRootSync(appRoot);
}
initializeGlobalHooks(compilerHost);
require.main.require(mainModule);
}
/**
* Creates a {@link CompilerHost} with the given information. This method is
* usually called by {@link createCompilerHostFromProjectRoot}.
*
* @private
*/
function createCompilerHostFromConfiguration(info) {
var compilers = createCompilers();
var rootCacheDir = info.rootCacheDir || calculateDefaultCompileCacheDirectory();
d('Creating CompilerHost: ' + (0, _stringify2.default)(info) + ', rootCacheDir = ' + rootCacheDir);
var fileChangeCache = new _fileChangeCache2.default(info.appRoot);
var ret = new _compilerHost2.default(rootCacheDir, compilers, fileChangeCache, false, compilers['text/plain']);
_lodash2.default.each((0, _keys2.default)(info.options || {}), function (x) {
var opts = info.options[x];
if (!(x in compilers)) {
throw new Error('Found compiler settings for missing compiler: ' + x);
}
d('Setting options for ' + x + ': ' + (0, _stringify2.default)(opts));
compilers[x].compilerOptions = opts;
});
// NB: It's super important that we guarantee that the configuration is saved
// out, because we'll need to re-read it in the renderer process
d('Created compiler host with options: ' + (0, _stringify2.default)(info));
ret.saveConfigurationSync();
return ret;
}function createCompilerHostFromBabelRcSync(file) {
var rootCacheDir = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
var info = JSON.parse(_fs2.default.readFileSync(file, 'utf8'));
// package.json
if ('babel' in info) {
info = info.babel;
}
if ('env' in info) {
var _ourEnv2 = process.env.BABEL_ENV || process.env.NODE_ENV || 'development';
info = info.env[_ourEnv2];
}
// Are we still package.json (i.e. is there no babel info whatsoever?)
if ('name' in info && 'version' in info) {
return createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: getDefaultConfiguration(),
rootCacheDir: rootCacheDir
});
}
return createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: {
'application/javascript': info
},
rootCacheDir: rootCacheDir
});
}
function createCompilerHostFromConfigFileSync(file) {
var rootCacheDir = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
var info = JSON.parse(_fs2.default.readFileSync(file, 'utf8'));
if ('env' in info) {
var _ourEnv3 = process.env.ELECTRON_COMPILE_ENV || process.env.NODE_ENV || 'development';
info = info.env[_ourEnv3];
}
return createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: info,
rootCacheDir: rootCacheDir
});
}
function createCompilerHostFromProjectRootSync(rootDir) {
var rootCacheDir = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
var compilerc = _path2.default.join(rootDir, '.compilerc');
if (statSyncNoException(compilerc)) {
d('Found a .compilerc at ' + compilerc + ', using it');
return createCompilerHostFromConfigFileSync(compilerc, rootCacheDir);
}
var babelrc = _path2.default.join(rootDir, '.babelrc');
if (statSyncNoException(babelrc)) {
d('Found a .babelrc at ' + babelrc + ', using it');
return createCompilerHostFromBabelRcSync(babelrc, rootCacheDir);
}
d('Using package.json or default parameters at ' + rootDir);
return createCompilerHostFromBabelRcSync(_path2.default.join(rootDir, 'package.json'), rootCacheDir);
}
/**
* Returns what electron-compile would use as a default rootCacheDir. Usually only
* used for debugging purposes
*
* @return {string} A path that may or may not exist where electron-compile would
* set up a development mode cache.
*/
function calculateDefaultCompileCacheDirectory() {
var tmpDir = process.env.TEMP || process.env.TMPDIR || '/tmp';
var hash = require('crypto').createHash('md5').update(process.execPath).digest('hex');
var cacheDir = _path2.default.join(tmpDir, 'compileCache_' + hash);
_mkdirp2.default.sync(cacheDir);
d('Using default cache directory: ' + cacheDir);
return cacheDir;
}
/**
* Returns the default .configrc if no configuration information can be found.
*
* @return {Object} A list of default config settings for electron-compiler.
*/
function getDefaultConfiguration() {
return {
'application/javascript': {
"presets": ["stage-0", "es2015", "react"],
"sourceMaps": "inline"
}
};
}
/**
* Allows you to create new instances of all compilers that are supported by
* electron-compile and use them directly. Currently supports Babel, CoffeeScript,
* TypeScript, LESS, and Jade.
*
* @return {Object} An Object whose Keys are MIME types, and whose values
* are instances of @{link CompilerBase}.
*/
function createCompilers() {
if (!allCompilerClasses) {
// First we want to see if electron-compilers itself has been installed with
// devDependencies. If that's not the case, check to see if
// electron-compilers is installed as a peer dependency (probably as a
// devDependency of the root project).
var locations = ['electron-compilers', '../../electron-compilers'];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = (0, _getIterator3.default)(locations), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var location = _step.value;
try {
allCompilerClasses = require(location);
} catch (e) {
// Yolo
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
if (!allCompilerClasses) {
throw new Error("Electron compilers not found but were requested to be loaded");
}
}
// NB: Note that this code is carefully set up so that InlineHtmlCompiler
// (i.e. classes with `createFromCompilers`) initially get an empty object,
// but will have a reference to the final result of what we return, which
// resolves the circular dependency we'd otherwise have here.
var ret = {};
var instantiatedClasses = _lodash2.default.map(allCompilerClasses, function (Klass) {
if ('createFromCompilers' in Klass) {
return Klass.createFromCompilers(ret);
} else {
return new Klass();
}
});
_lodash2.default.reduce(instantiatedClasses, function (acc, x) {
var Klass = (0, _getPrototypeOf2.default)(x).constructor;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = (0, _getIterator3.default)(Klass.getInputMimeTypes()), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var type = _step2.value;
acc[type] = x;
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return acc;
}, ret);
return ret;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/config-parser.js"],"names":[],"mappings":"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","file":"config-parser.js","sourcesContent":["import _ from 'lodash';\nimport fs from 'fs';\nimport path from 'path';\nimport mkdirp from 'mkdirp';\nimport {pfs} from './promise';\n\nimport FileChangedCache from './file-change-cache';\nimport CompilerHost from './compiler-host';\nimport { initializeProtocolHook } from './protocol-hook';\nimport registerRequireExtension from './require-hook';\n\nconst d = require('debug')('electron-compile:config-parser');\n\n// NB: We intentionally delay-load this so that in production, you can create\n// cache-only versions of these compilers\nlet allCompilerClasses = null;\n\nfunction statSyncNoException(fsPath) {\n  if ('statSyncNoException' in fs) {\n    return fs.statSyncNoException(fsPath);\n  }\n  \n  try {\n    return fs.statSync(fsPath);\n  } catch (e) {\n    return null;\n  }\n}\n\n\n/**\n * Initialize the global hooks (protocol hook for file:, node.js hook) \n * independent of initializing the compiler. This method is usually called by\n * init instead of directly\n * \n * @param {CompilerHost} compilerHost  The compiler host to use.\n *  \n */ \nexport function initializeGlobalHooks(compilerHost) {\n  let globalVar = (global || window);\n  globalVar.globalCompilerHost = compilerHost;\n\n  registerRequireExtension(compilerHost);\n\n  if ('type' in process && process.type === 'browser') {\n    const { app } = require('electron');\n    \n    let protoify = function() { initializeProtocolHook(compilerHost); };\n    if (app.isReady()) {\n      protoify();\n    } else {\n      app.on('ready', protoify);\n    }\n  }\n}\n\n\n/**\n * Initialize electron-compile and set it up, either for development or \n * production use. This is almost always the only method you need to use in order\n * to use electron-compile.\n *  \n * @param  {string} appRoot  The top-level directory for your application (i.e.\n *                           the one which has your package.json).\n *\n * @param  {string} mainModule  The module to require in, relative to the module\n *                              calling init, that will start your app. Write this \n *                              as if you were writing a require call from here.\n *\n * @param  {bool} productionMode   If explicitly True/False, will set read-only\n *                                 mode to be disabled/enabled. If not, we'll\n *                                 guess based on the presence of a production\n *                                 cache.\n */ \nexport function init(appRoot, mainModule, productionMode = null) {\n  let compilerHost = null;\n  let cacheDir = path.join(appRoot, '.cache');\n  \n  if (productionMode === null) {\n    productionMode = !!statSyncNoException(cacheDir);\n  }\n  \n  if (productionMode) {\n    // In read-only mode, we'll assume that everything is in `appRoot/.cache`\n    compilerHost = CompilerHost.createReadonlyFromConfigurationSync(cacheDir, appRoot);\n  } else {\n    compilerHost = createCompilerHostFromProjectRootSync(appRoot);\n  }\n  \n  initializeGlobalHooks(compilerHost);\n  require.main.require(mainModule);\n}\n\n\n/**\n * Creates a {@link CompilerHost} with the given information. This method is\n * usually called by {@link createCompilerHostFromProjectRoot}.\n *  \n * @private\n */ \nexport function createCompilerHostFromConfiguration(info) {\n  let compilers = createCompilers();\n  let rootCacheDir = info.rootCacheDir || calculateDefaultCompileCacheDirectory();\n  \n  d(`Creating CompilerHost: ${JSON.stringify(info)}, rootCacheDir = ${rootCacheDir}`);\n  let fileChangeCache = new FileChangedCache(info.appRoot);\n  let ret = new CompilerHost(rootCacheDir, compilers, fileChangeCache, false, compilers['text/plain']);\n  \n  _.each(Object.keys(info.options || {}), (x) => {\n    let opts = info.options[x];\n    if (!(x in compilers)) {\n      throw new Error(`Found compiler settings for missing compiler: ${x}`);\n    }\n    \n    d(`Setting options for ${x}: ${JSON.stringify(opts)}`);\n    compilers[x].compilerOptions = opts;\n  });\n  \n  // NB: It's super important that we guarantee that the configuration is saved\n  // out, because we'll need to re-read it in the renderer process\n  d(`Created compiler host with options: ${JSON.stringify(info)}`);\n  ret.saveConfigurationSync();\n  return ret;\n}\n\n/**\n * Creates a compiler host from a .babelrc file. This method is usually called\n * from {@link createCompilerHostFromProjectRoot} instead of used directly.\n *  \n * @param  {string} file  The path to a .babelrc file\n *\n * @param  {string} rootCacheDir (optional)  The directory to use as a cache.\n *\n * @return {Promise<CompilerHost>}  A set-up compiler host\n */ \nexport async function createCompilerHostFromBabelRc(file, rootCacheDir=null) {\n  let info = JSON.parse(await pfs.readFile(file, 'utf8'));\n  \n  // package.json\n  if ('babel' in info) {\n    info = info.babel;\n  }\n  \n  if ('env' in info) {\n    let ourEnv = process.env.BABEL_ENV || process.env.NODE_ENV || 'development';\n    info = info.env[ourEnv];\n  }\n  \n  // Are we still package.json (i.e. is there no babel info whatsoever?)\n  if ('name' in info && 'version' in info) {\n    return createCompilerHostFromConfiguration({\n      appRoot: path.dirname(file),\n      options: getDefaultConfiguration(),\n      rootCacheDir\n    });\n  }\n  \n  return createCompilerHostFromConfiguration({\n    appRoot: path.dirname(file),\n    options: {\n      'application/javascript': info\n    },\n    rootCacheDir\n  });\n}\n\n\n/**\n * Creates a compiler host from a .compilerc file. This method is usually called\n * from {@link createCompilerHostFromProjectRoot} instead of used directly.\n *  \n * @param  {string} file  The path to a .compilerc file\n *\n * @param  {string} rootCacheDir (optional)  The directory to use as a cache.\n *\n * @return {Promise<CompilerHost>}  A set-up compiler host\n */ \nexport async function createCompilerHostFromConfigFile(file, rootCacheDir=null) {\n  let info = JSON.parse(await pfs.readFile(file, 'utf8'));\n  \n  if ('env' in info) {\n    let ourEnv = process.env.ELECTRON_COMPILE_ENV || process.env.NODE_ENV || 'development';\n    info = info.env[ourEnv];\n  }\n  \n  return createCompilerHostFromConfiguration({\n    appRoot: path.dirname(file),\n    options: info,\n    rootCacheDir\n  });\n}\n\n\n/**\n * Creates a configured {@link CompilerHost} instance from the project root \n * directory. This method first searches for a .compilerc, then falls back to the\n * default locations for Babel configuration info. If neither are found, defaults\n * to standard settings\n *  \n * @param  {string} rootDir  The root application directory (i.e. the directory\n *                           that has the app's package.json)\n *\n * @param  {string} rootCacheDir (optional)  The directory to use as a cache.\n *\n * @return {Promise<CompilerHost>}  A set-up compiler host\n */ \nexport async function createCompilerHostFromProjectRoot(rootDir, rootCacheDir=null) {\n  let compilerc = path.join(rootDir, '.compilerc');\n  if (statSyncNoException(compilerc)) {\n    d(`Found a .compilerc at ${compilerc}, using it`);\n    return await createCompilerHostFromConfigFile(compilerc, rootCacheDir);\n  }\n  \n  let babelrc = path.join(rootDir, '.babelrc');\n  if (statSyncNoException(babelrc)) {\n    d(`Found a .babelrc at ${babelrc}, using it`);\n    return await createCompilerHostFromBabelRc(babelrc, rootCacheDir);\n  }\n    \n  d(`Using package.json or default parameters at ${rootDir}`);\n  return await createCompilerHostFromBabelRc(path.join(rootDir, 'package.json'), rootCacheDir);\n}\n\nexport function createCompilerHostFromBabelRcSync(file, rootCacheDir=null) {\n  let info = JSON.parse(fs.readFileSync(file, 'utf8'));\n  \n  // package.json\n  if ('babel' in info) {\n    info = info.babel;\n  }\n  \n  if ('env' in info) {\n    let ourEnv = process.env.BABEL_ENV || process.env.NODE_ENV || 'development';\n    info = info.env[ourEnv];\n  }\n  \n  // Are we still package.json (i.e. is there no babel info whatsoever?)\n  if ('name' in info && 'version' in info) {\n    return createCompilerHostFromConfiguration({\n      appRoot: path.dirname(file),\n      options: getDefaultConfiguration(),\n      rootCacheDir\n    });\n  }\n  \n  return createCompilerHostFromConfiguration({\n    appRoot: path.dirname(file),\n    options: {\n      'application/javascript': info\n    },\n    rootCacheDir\n  });\n}\n\nexport function createCompilerHostFromConfigFileSync(file, rootCacheDir=null) {\n  let info = JSON.parse(fs.readFileSync(file, 'utf8'));\n  \n  if ('env' in info) {\n    let ourEnv = process.env.ELECTRON_COMPILE_ENV || process.env.NODE_ENV || 'development';\n    info = info.env[ourEnv];\n  }\n  \n  return createCompilerHostFromConfiguration({\n    appRoot: path.dirname(file),\n    options: info,\n    rootCacheDir\n  });\n}\n\nexport function createCompilerHostFromProjectRootSync(rootDir, rootCacheDir=null) {\n  let compilerc = path.join(rootDir, '.compilerc');\n  if (statSyncNoException(compilerc)) {\n    d(`Found a .compilerc at ${compilerc}, using it`);\n    return createCompilerHostFromConfigFileSync(compilerc, rootCacheDir);\n  }\n  \n  let babelrc = path.join(rootDir, '.babelrc');\n  if (statSyncNoException(babelrc)) {\n    d(`Found a .babelrc at ${babelrc}, using it`);\n    return createCompilerHostFromBabelRcSync(babelrc, rootCacheDir);\n  }\n    \n  d(`Using package.json or default parameters at ${rootDir}`);\n  return createCompilerHostFromBabelRcSync(path.join(rootDir, 'package.json'), rootCacheDir);\n}\n\n/**\n * Returns what electron-compile would use as a default rootCacheDir. Usually only\n * used for debugging purposes\n *  \n * @return {string}  A path that may or may not exist where electron-compile would\n *                   set up a development mode cache.\n */ \nexport function calculateDefaultCompileCacheDirectory() {\n  let tmpDir = process.env.TEMP || process.env.TMPDIR || '/tmp';\n  let hash = require('crypto').createHash('md5').update(process.execPath).digest('hex');\n\n  let cacheDir = path.join(tmpDir, `compileCache_${hash}`);\n  mkdirp.sync(cacheDir);\n  \n  d(`Using default cache directory: ${cacheDir}`);\n  return cacheDir;\n}\n\n\n/**\n * Returns the default .configrc if no configuration information can be found.\n *  \n * @return {Object}  A list of default config settings for electron-compiler.\n */ \nexport function getDefaultConfiguration() {\n  return {\n    'application/javascript': {\n      \"presets\": [\"stage-0\", \"es2015\", \"react\"],\n      \"sourceMaps\": \"inline\"\n    }\n  };\n}\n\n/**\n * Allows you to create new instances of all compilers that are supported by \n * electron-compile and use them directly. Currently supports Babel, CoffeeScript, \n * TypeScript, LESS, and Jade.\n *  \n * @return {Object}  An Object whose Keys are MIME types, and whose values \n * are instances of @{link CompilerBase}.\n */ \nexport function createCompilers() {\n  if (!allCompilerClasses) {\n    // First we want to see if electron-compilers itself has been installed with\n    // devDependencies. If that's not the case, check to see if\n    // electron-compilers is installed as a peer dependency (probably as a\n    // devDependency of the root project).\n    const locations = ['electron-compilers', '../../electron-compilers'];\n\n    for (let location of locations) {\n      try {\n        allCompilerClasses = require(location);\n      } catch (e) {\n        // Yolo\n      }\n    }\n\n    if (!allCompilerClasses) {\n      throw new Error(\"Electron compilers not found but were requested to be loaded\");\n    }\n  }\n\n  // NB: Note that this code is carefully set up so that InlineHtmlCompiler \n  // (i.e. classes with `createFromCompilers`) initially get an empty object,\n  // but will have a reference to the final result of what we return, which\n  // resolves the circular dependency we'd otherwise have here.\n  let ret = {};\n  let instantiatedClasses = _.map(allCompilerClasses, (Klass) => {\n    if ('createFromCompilers' in Klass) {\n      return Klass.createFromCompilers(ret);\n    } else {\n      return new Klass();\n    }\n  });\n\n  _.reduce(instantiatedClasses, (acc,x) => {\n    let Klass = Object.getPrototypeOf(x).constructor;\n\n    for (let type of Klass.getInputMimeTypes()) { acc[type] = x; }\n    return acc;\n  }, ret);\n  \n  return ret;\n}\n"]}