electron-compile
Version:
Electron supporting package to compile JS and CSS in Electron applications
552 lines (453 loc) • 55.9 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.createCompilerHostFromProjectRoot = exports.createCompilerHostFromConfigFile = exports.createCompilerHostFromBabelRc = undefined;
/**
* 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
*/
let createCompilerHostFromBabelRc = exports.createCompilerHostFromBabelRc = (() => {
var _ref = _asyncToGenerator(function* (file) {
let rootCacheDir = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
let sourceMapPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
let info = JSON.parse((yield _promise.pfs.readFile(file, 'utf8')));
// package.json
if ('babel' in info) {
info = info.babel;
}
if ('env' in info) {
let 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) {
let appRoot = _path2.default.dirname(file);
return createCompilerHostFromConfiguration({
appRoot: appRoot,
options: getDefaultConfiguration(appRoot),
rootCacheDir,
sourceMapPath
});
}
return createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: {
'application/javascript': info
},
rootCacheDir,
sourceMapPath
});
});
return function createCompilerHostFromBabelRc(_x5) {
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
*/
let createCompilerHostFromConfigFile = exports.createCompilerHostFromConfigFile = (() => {
var _ref2 = _asyncToGenerator(function* (file) {
let rootCacheDir = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
let sourceMapPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
let info = JSON.parse((yield _promise.pfs.readFile(file, 'utf8')));
if ('env' in info) {
let ourEnv = process.env.ELECTRON_COMPILE_ENV || process.env.NODE_ENV || 'development';
info = info.env[ourEnv];
}
return createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: info,
rootCacheDir,
sourceMapPath
});
});
return function createCompilerHostFromConfigFile(_x8) {
return _ref2.apply(this, arguments);
};
})();
/**
* Creates a configured {@link CompilerHost} instance from the project root
* directory. This method first searches for a .compilerc (or .compilerc.json), 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.
*
* @param {string} sourceMapPath (optional) The directory to store sourcemap separately
* if compiler option enabled to emit.
*
* @return {Promise<CompilerHost>} A set-up compiler host
*/
let createCompilerHostFromProjectRoot = exports.createCompilerHostFromProjectRoot = (() => {
var _ref3 = _asyncToGenerator(function* (rootDir) {
let rootCacheDir = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
let sourceMapPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
let compilerc = _path2.default.join(rootDir, '.compilerc');
if (statSyncNoException(compilerc)) {
d(`Found a .compilerc at ${compilerc}, using it`);
return yield createCompilerHostFromConfigFile(compilerc, rootCacheDir, sourceMapPath);
}
compilerc += '.json';
if (statSyncNoException(compilerc)) {
d(`Found a .compilerc at ${compilerc}, using it`);
return yield createCompilerHostFromConfigFile(compilerc, rootCacheDir, sourceMapPath);
}
let babelrc = _path2.default.join(rootDir, '.babelrc');
if (statSyncNoException(babelrc)) {
d(`Found a .babelrc at ${babelrc}, using it`);
return yield createCompilerHostFromBabelRc(babelrc, rootCacheDir, sourceMapPath);
}
d(`Using package.json or default parameters at ${rootDir}`);
return yield createCompilerHostFromBabelRc(_path2.default.join(rootDir, 'package.json'), rootCacheDir, sourceMapPath);
});
return function createCompilerHostFromProjectRoot(_x11) {
return _ref3.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 _fs = require('fs');
var _fs2 = _interopRequireDefault(_fs);
var _path = require('path');
var _path2 = _interopRequireDefault(_path);
var _zlib = require('zlib');
var _zlib2 = _interopRequireDefault(_zlib);
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 _requireHook = require('./require-hook');
var _requireHook2 = _interopRequireDefault(_requireHook);
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"); }); }; }
const 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
let 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) {
let isProduction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
let globalVar = global || window;
globalVar.globalCompilerHost = compilerHost;
(0, _requireHook2.default)(compilerHost, isProduction);
if ('type' in process && process.type === 'browser') {
var _require = require('electron');
const app = _require.app;
var _require2 = require('./protocol-hook');
const initializeProtocolHook = _require2.initializeProtocolHook;
let protoify = function () {
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.
*
* @param {string} cacheDir If not passed in, read-only will look in
* `appRoot/.cache` and dev mode will compile to a
* temporary directory. If it is passed in, both modes
* will cache to/from `appRoot/{cacheDir}`
*
* @param {string} sourceMapPath (optional) The directory to store sourcemap separately
* if compiler option enabled to emit.
* Default to cachePath if not specified, will be ignored for read-only mode.
*/
function init(appRoot, mainModule) {
let productionMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
let cacheDir = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
let sourceMapPath = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
let compilerHost = null;
let rootCacheDir = _path2.default.join(appRoot, cacheDir || '.cache');
if (productionMode === null) {
productionMode = !!statSyncNoException(rootCacheDir);
}
if (productionMode) {
compilerHost = _compilerHost2.default.createReadonlyFromConfigurationSync(rootCacheDir, appRoot);
} else {
// if cacheDir was passed in, pass it along. Otherwise, default to a tempdir.
const cachePath = cacheDir ? rootCacheDir : null;
const mapPath = sourceMapPath ? _path2.default.join(appRoot, sourceMapPath) : cachePath;
compilerHost = createCompilerHostFromProjectRootSync(appRoot, cachePath, mapPath);
}
initializeGlobalHooks(compilerHost, productionMode);
require.main.require(mainModule);
}
/**
* Creates a {@link CompilerHost} with the given information. This method is
* usually called by {@link createCompilerHostFromProjectRoot}.
*
* @private
*/
function createCompilerHostFromConfiguration(info) {
let compilers = createCompilers();
let rootCacheDir = info.rootCacheDir || calculateDefaultCompileCacheDirectory();
const sourceMapPath = info.sourceMapPath || info.rootCacheDir;
if (info.sourceMapPath) {
createSourceMapDirectory(sourceMapPath);
}
d(`Creating CompilerHost: ${JSON.stringify(info)}, rootCacheDir = ${rootCacheDir}, sourceMapPath = ${sourceMapPath}`);
let fileChangeCache = new _fileChangeCache2.default(info.appRoot);
let compilerInfo = _path2.default.join(rootCacheDir, 'compiler-info.json.gz');
let json = {};
if (_fs2.default.existsSync(compilerInfo)) {
let buf = _fs2.default.readFileSync(compilerInfo);
json = JSON.parse(_zlib2.default.gunzipSync(buf));
fileChangeCache = _fileChangeCache2.default.loadFromData(json.fileChangeCache, info.appRoot, false);
}
Object.keys(info.options || {}).forEach(x => {
let opts = info.options[x];
if (!(x in compilers)) {
throw new Error(`Found compiler settings for missing compiler: ${x}`);
}
// NB: Let's hope this isn't a valid compiler option...
if (opts.passthrough) {
compilers[x] = compilers['text/plain'];
delete opts.passthrough;
}
d(`Setting options for ${x}: ${JSON.stringify(opts)}`);
compilers[x].compilerOptions = opts;
});
let ret = new _compilerHost2.default(rootCacheDir, compilers, fileChangeCache, false, compilers['text/plain'], null, json.mimeTypesToRegister);
// 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: ${JSON.stringify(info)}`);
ret.saveConfigurationSync();
return ret;
}function createCompilerHostFromBabelRcSync(file) {
let rootCacheDir = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
let sourceMapPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
let info = JSON.parse(_fs2.default.readFileSync(file, 'utf8'));
// package.json
if ('babel' in info) {
info = info.babel;
}
if ('env' in info) {
let 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) {
let appRoot = _path2.default.dirname(file);
return createCompilerHostFromConfiguration({
appRoot: appRoot,
options: getDefaultConfiguration(appRoot),
rootCacheDir,
sourceMapPath
});
}
return createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: {
'application/javascript': info
},
rootCacheDir,
sourceMapPath
});
}
function createCompilerHostFromConfigFileSync(file) {
let rootCacheDir = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
let sourceMapPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
let info = JSON.parse(_fs2.default.readFileSync(file, 'utf8'));
if ('env' in info) {
let ourEnv = process.env.ELECTRON_COMPILE_ENV || process.env.NODE_ENV || 'development';
info = info.env[ourEnv];
}
return createCompilerHostFromConfiguration({
appRoot: _path2.default.dirname(file),
options: info,
rootCacheDir,
sourceMapPath
});
}
function createCompilerHostFromProjectRootSync(rootDir) {
let rootCacheDir = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
let sourceMapPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
let compilerc = _path2.default.join(rootDir, '.compilerc');
if (statSyncNoException(compilerc)) {
d(`Found a .compilerc at ${compilerc}, using it`);
return createCompilerHostFromConfigFileSync(compilerc, rootCacheDir, sourceMapPath);
}
let babelrc = _path2.default.join(rootDir, '.babelrc');
if (statSyncNoException(babelrc)) {
d(`Found a .babelrc at ${babelrc}, using it`);
return createCompilerHostFromBabelRcSync(babelrc, rootCacheDir, sourceMapPath);
}
d(`Using package.json or default parameters at ${rootDir}`);
return createCompilerHostFromBabelRcSync(_path2.default.join(rootDir, 'package.json'), rootCacheDir, sourceMapPath);
}
/**
* 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() {
let tmpDir = process.env.TEMP || process.env.TMPDIR || '/tmp';
let hash = require('crypto').createHash('md5').update(process.execPath).digest('hex');
let cacheDir = _path2.default.join(tmpDir, `compileCache_${hash}`);
_mkdirp2.default.sync(cacheDir);
d(`Using default cache directory: ${cacheDir}`);
return cacheDir;
}
function createSourceMapDirectory(sourceMapPath) {
_mkdirp2.default.sync(sourceMapPath);
d(`Using separate sourcemap path at ${sourceMapPath}`);
}
function getElectronVersion(rootDir) {
if (process.versions.electron) {
return process.versions.electron;
}
let ourPkgJson = require(_path2.default.join(rootDir, 'package.json'));
let version = ['electron-prebuilt-compile', 'electron'].map(mod => {
if (ourPkgJson.devDependencies && ourPkgJson.devDependencies[mod]) {
// NB: lol this code
let verRange = ourPkgJson.devDependencies[mod];
let m = verRange.match(/(\d+\.\d+\.\d+)/);
if (m && m[1]) return m[1];
}
try {
return process.mainModule.require(`${mod}/package.json`).version;
} catch (e) {
// NB: This usually doesn't work, but sometimes maybe?
}
try {
let p = _path2.default.join(rootDir, mod, 'package.json');
return require(p).version;
} catch (e) {
return null;
}
}).find(x => !!x);
if (!version) {
throw new Error("Can't automatically discover the version of Electron, you probably need a .compilerc file");
}
return version;
}
/**
* Returns the default .configrc if no configuration information can be found.
*
* @return {Object} A list of default config settings for electron-compiler.
*/
function getDefaultConfiguration(rootDir) {
return {
'application/javascript': {
"presets": [["env", {
"targets": {
"electron": getElectronVersion(rootDir)
}
}], "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).
const locations = ['electron-compilers', '../../electron-compilers'];
for (let location of locations) {
try {
allCompilerClasses = require(location);
} catch (e) {
// Yolo
}
}
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.
let ret = {};
let instantiatedClasses = allCompilerClasses.map(Klass => {
if ('createFromCompilers' in Klass) {
return Klass.createFromCompilers(ret);
} else {
return new Klass();
}
});
instantiatedClasses.reduce((acc, x) => {
let Klass = Object.getPrototypeOf(x).constructor;
for (let type of Klass.getInputMimeTypes()) {
acc[type] = x;
}
return acc;
}, ret);
return ret;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/config-parser.js"],"names":["file","rootCacheDir","sourceMapPath","info","JSON","parse","pfs","readFile","babel","ourEnv","process","env","BABEL_ENV","NODE_ENV","appRoot","path","dirname","createCompilerHostFromConfiguration","options","getDefaultConfiguration","createCompilerHostFromBabelRc","ELECTRON_COMPILE_ENV","createCompilerHostFromConfigFile","rootDir","compilerc","join","statSyncNoException","d","babelrc","createCompilerHostFromProjectRoot","initializeGlobalHooks","init","createCompilerHostFromBabelRcSync","createCompilerHostFromConfigFileSync","createCompilerHostFromProjectRootSync","calculateDefaultCompileCacheDirectory","createCompilers","require","allCompilerClasses","fsPath","fs","statSync","e","compilerHost","isProduction","globalVar","global","window","globalCompilerHost","type","app","initializeProtocolHook","protoify","isReady","on","mainModule","productionMode","cacheDir","CompilerHost","createReadonlyFromConfigurationSync","cachePath","mapPath","main","compilers","createSourceMapDirectory","stringify","fileChangeCache","FileChangedCache","compilerInfo","json","existsSync","buf","readFileSync","zlib","gunzipSync","loadFromData","Object","keys","forEach","x","opts","Error","passthrough","compilerOptions","ret","mimeTypesToRegister","saveConfigurationSync","tmpDir","TEMP","TMPDIR","hash","createHash","update","execPath","digest","mkdirp","sync","getElectronVersion","versions","electron","ourPkgJson","version","map","mod","devDependencies","verRange","m","match","p","find","locations","location","instantiatedClasses","Klass","createFromCompilers","reduce","acc","getPrototypeOf","constructor","getInputMimeTypes"],"mappings":"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","file":"config-parser.js","sourcesContent":["import fs from 'fs';\nimport path from 'path';\nimport zlib from 'zlib';\nimport mkdirp from 'mkdirp';\nimport {pfs} from './promise';\n\nimport FileChangedCache from './file-change-cache';\nimport CompilerHost from './compiler-host';\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, isProduction=false) {\n  let globalVar = (global || window);\n  globalVar.globalCompilerHost = compilerHost;\n\n  registerRequireExtension(compilerHost, isProduction);\n\n  if ('type' in process && process.type === 'browser') {\n    const { app } = require('electron');\n    const { initializeProtocolHook } = require('./protocol-hook');\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 *\n * @param  {string} cacheDir  If not passed in, read-only will look in\n *                            `appRoot/.cache` and dev mode will compile to a\n *                            temporary directory. If it is passed in, both modes\n *                            will cache to/from `appRoot/{cacheDir}`\n *\n * @param {string} sourceMapPath (optional) The directory to store sourcemap separately\n *                               if compiler option enabled to emit.\n *                               Default to cachePath if not specified, will be ignored for read-only mode.\n */\nexport function init(appRoot, mainModule, productionMode = null, cacheDir = null, sourceMapPath = null) {\n  let compilerHost = null;\n  let rootCacheDir = path.join(appRoot, cacheDir || '.cache');\n\n  if (productionMode === null) {\n    productionMode = !!statSyncNoException(rootCacheDir);\n  }\n\n  if (productionMode) {\n    compilerHost = CompilerHost.createReadonlyFromConfigurationSync(rootCacheDir, appRoot);\n  } else {\n    // if cacheDir was passed in, pass it along. Otherwise, default to a tempdir.\n    const cachePath = cacheDir ? rootCacheDir : null;\n    const mapPath = sourceMapPath ? path.join(appRoot, sourceMapPath) : cachePath;\n    compilerHost = createCompilerHostFromProjectRootSync(appRoot, cachePath, mapPath);\n  }\n\n  initializeGlobalHooks(compilerHost, productionMode);\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  const sourceMapPath = info.sourceMapPath || info.rootCacheDir;\n\n  if (info.sourceMapPath) {\n    createSourceMapDirectory(sourceMapPath);\n  }\n\n  d(`Creating CompilerHost: ${JSON.stringify(info)}, rootCacheDir = ${rootCacheDir}, sourceMapPath = ${sourceMapPath}`);\n  let fileChangeCache = new FileChangedCache(info.appRoot);\n\n  let compilerInfo = path.join(rootCacheDir, 'compiler-info.json.gz');\n  let json = {};\n  if (fs.existsSync(compilerInfo)) {\n    let buf = fs.readFileSync(compilerInfo);\n    json = JSON.parse(zlib.gunzipSync(buf));\n    fileChangeCache = FileChangedCache.loadFromData(json.fileChangeCache, info.appRoot, false);\n  }\n\n  Object.keys(info.options || {}).forEach((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    // NB: Let's hope this isn't a valid compiler option...\n    if (opts.passthrough) {\n      compilers[x] = compilers['text/plain'];\n      delete opts.passthrough;\n    }\n\n    d(`Setting options for ${x}: ${JSON.stringify(opts)}`);\n    compilers[x].compilerOptions = opts;\n  });\n\n  let ret = new CompilerHost(rootCacheDir, compilers, fileChangeCache, false, compilers['text/plain'], null, json.mimeTypesToRegister);\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, sourceMapPath = 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    let appRoot = path.dirname(file);\n    return createCompilerHostFromConfiguration({\n      appRoot: appRoot,\n      options: getDefaultConfiguration(appRoot),\n      rootCacheDir,\n      sourceMapPath\n    });\n  }\n\n  return createCompilerHostFromConfiguration({\n    appRoot: path.dirname(file),\n    options: {\n      'application/javascript': info\n    },\n    rootCacheDir,\n    sourceMapPath\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, sourceMapPath = 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    sourceMapPath\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 (or .compilerc.json), 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 * @param {string} sourceMapPath (optional) The directory to store sourcemap separately\n *                               if compiler option enabled to emit.\n *\n * @return {Promise<CompilerHost>}  A set-up compiler host\n */\nexport async function createCompilerHostFromProjectRoot(rootDir, rootCacheDir = null, sourceMapPath = 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, sourceMapPath);\n  }\n  compilerc += '.json';\n  if (statSyncNoException(compilerc)) {\n    d(`Found a .compilerc at ${compilerc}, using it`);\n    return await createCompilerHostFromConfigFile(compilerc, rootCacheDir, sourceMapPath);\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, sourceMapPath);\n  }\n\n  d(`Using package.json or default parameters at ${rootDir}`);\n  return await createCompilerHostFromBabelRc(path.join(rootDir, 'package.json'), rootCacheDir, sourceMapPath);\n}\n\nexport function createCompilerHostFromBabelRcSync(file, rootCacheDir=null, sourceMapPath = 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    let appRoot = path.dirname(file)\n    return createCompilerHostFromConfiguration({\n      appRoot: appRoot,\n      options: getDefaultConfiguration(appRoot),\n      rootCacheDir,\n      sourceMapPath\n    });\n  }\n\n  return createCompilerHostFromConfiguration({\n    appRoot: path.dirname(file),\n    options: {\n      'application/javascript': info\n    },\n    rootCacheDir,\n    sourceMapPath\n  });\n}\n\nexport function createCompilerHostFromConfigFileSync(file, rootCacheDir=null, sourceMapPath = 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    sourceMapPath\n  });\n}\n\nexport function createCompilerHostFromProjectRootSync(rootDir, rootCacheDir = null, sourceMapPath = 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, sourceMapPath);\n  }\n\n  let babelrc = path.join(rootDir, '.babelrc');\n  if (statSyncNoExcepti