electron-compile/lib/config-parser.js

Electron supporting package to compile JS and CSS in Electron applications

'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 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) {
      return createCompilerHostFromConfiguration({
        appRoot: _path2.default.dirname(file),
        options: getDefaultConfiguration(),
        rootCacheDir
      });
    }

    return createCompilerHostFromConfiguration({
      appRoot: _path2.default.dirname(file),
      options: {
        'application/javascript': info
      },
      rootCacheDir
    });
  });

  return function createCompilerHostFromBabelRc(_x3, _x4) {
    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 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
    });
  });

  return function createCompilerHostFromConfigFile(_x6, _x7) {
    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.
 *
 * @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 compilerc = _path2.default.join(rootDir, '.compilerc');
    if (statSyncNoException(compilerc)) {
      d(`Found a .compilerc at ${ compilerc }, using it`);
      return yield createCompilerHostFromConfigFile(compilerc, rootCacheDir);
    }
    compilerc += '.json';
    if (statSyncNoException(compilerc)) {
      d(`Found a .compilerc at ${ compilerc }, using it`);
      return yield createCompilerHostFromConfigFile(compilerc, rootCacheDir);
    }

    let babelrc = _path2.default.join(rootDir, '.babelrc');
    if (statSyncNoException(babelrc)) {
      d(`Found a .babelrc at ${ babelrc }, using it`);
      return yield createCompilerHostFromBabelRc(babelrc, rootCacheDir);
    }

    d(`Using package.json or default parameters at ${ rootDir }`);
    return yield createCompilerHostFromBabelRc(_path2.default.join(rootDir, 'package.json'), rootCacheDir);
  });

  return function createCompilerHostFromProjectRoot(_x9, _x10) {
    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')('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 globalVar = global || window;
  globalVar.globalCompilerHost = compilerHost;

  (0, _requireHook2.default)(compilerHost);

  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}`
 */
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 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.
    if (cacheDir) {
      compilerHost = createCompilerHostFromProjectRootSync(appRoot, rootCacheDir);
    } 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) {
  let compilers = createCompilers();
  let rootCacheDir = info.rootCacheDir || calculateDefaultCompileCacheDirectory();

  d(`Creating CompilerHost: ${ JSON.stringify(info) }, rootCacheDir = ${ rootCacheDir }`);
  let fileChangeCache = new _fileChangeCache2.default(info.appRoot);

  let compilerInfo = _path2.default.join(rootCacheDir, 'compiler-info.json.gz');
  if (_fs2.default.existsSync(compilerInfo)) {
    let buf = _fs2.default.readFileSync(compilerInfo);
    let 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']);

  // 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 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) {
    return createCompilerHostFromConfiguration({
      appRoot: _path2.default.dirname(file),
      options: getDefaultConfiguration(),
      rootCacheDir
    });
  }

  return createCompilerHostFromConfiguration({
    appRoot: _path2.default.dirname(file),
    options: {
      'application/javascript': info
    },
    rootCacheDir
  });
}

function createCompilerHostFromConfigFileSync(file) {
  let rootCacheDir = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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
  });
}

function createCompilerHostFromProjectRootSync(rootDir) {
  let rootCacheDir = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

  let compilerc = _path2.default.join(rootDir, '.compilerc');
  if (statSyncNoException(compilerc)) {
    d(`Found a .compilerc at ${ compilerc }, using it`);
    return createCompilerHostFromConfigFileSync(compilerc, rootCacheDir);
  }

  let 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() {
  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;
}

/**
 * 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": ["es2016-node5", "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;base64,{"version":3,"sources":["../src/config-parser.js"],"names":["file","rootCacheDir","info","JSON","parse","readFile","babel","ourEnv","process","env","BABEL_ENV","NODE_ENV","createCompilerHostFromConfiguration","appRoot","dirname","options","getDefaultConfiguration","createCompilerHostFromBabelRc","ELECTRON_COMPILE_ENV","createCompilerHostFromConfigFile","rootDir","compilerc","join","statSyncNoException","d","babelrc","createCompilerHostFromProjectRoot","initializeGlobalHooks","init","createCompilerHostFromBabelRcSync","createCompilerHostFromConfigFileSync","createCompilerHostFromProjectRootSync","calculateDefaultCompileCacheDirectory","createCompilers","require","allCompilerClasses","fsPath","statSync","e","compilerHost","globalVar","global","window","globalCompilerHost","type","app","initializeProtocolHook","protoify","isReady","on","mainModule","productionMode","cacheDir","createReadonlyFromConfigurationSync","main","compilers","stringify","fileChangeCache","compilerInfo","existsSync","buf","readFileSync","json","gunzipSync","loadFromData","Object","keys","forEach","x","opts","Error","passthrough","compilerOptions","ret","saveConfigurationSync","tmpDir","TEMP","TMPDIR","hash","createHash","update","execPath","digest","sync","locations","location","instantiatedClasses","map","Klass","createFromCompilers","reduce","acc","getPrototypeOf","constructor","getInputMimeTypes"],"mappings":";;;;;;;AAqJA;;;;;;;;;;;+BAUO,WAA6CA,IAA7C,EAAsE;AAAA,QAAnBC,YAAmB,uEAAN,IAAM;;AAC3E,QAAIC,OAAOC,KAAKC,KAAL,EAAW,MAAM,aAAIC,QAAJ,CAAaL,IAAb,EAAmB,MAAnB,CAAjB,EAAX;;AAEA;AACA,QAAI,WAAWE,IAAf,EAAqB;AACnBA,aAAOA,KAAKI,KAAZ;AACD;;AAED,QAAI,SAASJ,IAAb,EAAmB;AACjB,UAAIK,SAASC,QAAQC,GAAR,CAAYC,SAAZ,IAAyBF,QAAQC,GAAR,CAAYE,QAArC,IAAiD,aAA9D;AACAT,aAAOA,KAAKO,GAAL,CAASF,MAAT,CAAP;AACD;;AAED;AACA,QAAI,UAAUL,IAAV,IAAkB,aAAaA,IAAnC,EAAyC;AACvC,aAAOU,oCAAoC;AACzCC,iBAAS,eAAKC,OAAL,CAAad,IAAb,CADgC;AAEzCe,iBAASC,yBAFgC;AAGzCf;AAHyC,OAApC,CAAP;AAKD;;AAED,WAAOW,oCAAoC;AACzCC,eAAS,eAAKC,OAAL,CAAad,IAAb,CADgC;AAEzCe,eAAS;AACP,kCAA0Bb;AADnB,OAFgC;AAKzCD;AALyC,KAApC,CAAP;AAOD,G;;kBA7BqBgB,6B;;;;;AAgCtB;;;;;;;;;;;;;gCAUO,WAAgDjB,IAAhD,EAAyE;AAAA,QAAnBC,YAAmB,uEAAN,IAAM;;AAC9E,QAAIC,OAAOC,KAAKC,KAAL,EAAW,MAAM,aAAIC,QAAJ,CAAaL,IAAb,EAAmB,MAAnB,CAAjB,EAAX;;AAEA,QAAI,SAASE,IAAb,EAAmB;AACjB,UAAIK,SAASC,QAAQC,GAAR,CAAYS,oBAAZ,IAAoCV,QAAQC,GAAR,CAAYE,QAAhD,IAA4D,aAAzE;AACAT,aAAOA,KAAKO,GAAL,CAASF,MAAT,CAAP;AACD;;AAED,WAAOK,oCAAoC;AACzCC,eAAS,eAAKC,OAAL,CAAad,IAAb,CADgC;AAEzCe,eAASb,IAFgC;AAGzCD;AAHyC,KAApC,CAAP;AAKD,G;;kBAbqBkB,gC;;;;;AAgBtB;;;;;;;;;;;;;;;;gCAaO,WAAiDC,OAAjD,EAA6E;AAAA,QAAnBnB,YAAmB,uEAAN,IAAM;;AAClF,QAAIoB,YAAY,eAAKC,IAAL,CAAUF,OAAV,EAAmB,YAAnB,CAAhB;AACA,QAAIG,oBAAoBF,SAApB,CAAJ,EAAoC;AAClCG,QAAG,0BAAwBH,SAAU,aAArC;AACA,aAAO,MAAMF,iCAAiCE,SAAjC,EAA4CpB,YAA5C,CAAb;AACD;AACDoB,iBAAa,OAAb;AACA,QAAIE,oBAAoBF,SAApB,CAAJ,EAAoC;AAClCG,QAAG,0BAAwBH,SAAU,aAArC;AACA,aAAO,MAAMF,iCAAiCE,SAAjC,EAA4CpB,YAA5C,CAAb;AACD;;AAED,QAAIwB,UAAU,eAAKH,IAAL,CAAUF,OAAV,EAAmB,UAAnB,CAAd;AACA,QAAIG,oBAAoBE,OAApB,CAAJ,EAAkC;AAChCD,QAAG,wBAAsBC,OAAQ,aAAjC;AACA,aAAO,MAAMR,8BAA8BQ,OAA9B,EAAuCxB,YAAvC,CAAb;AACD;;AAEDuB,MAAG,gDAA8CJ,OAAQ,GAAzD;AACA,WAAO,MAAMH,8BAA8B,eAAKK,IAAL,CAAUF,OAAV,EAAmB,cAAnB,CAA9B,EAAkEnB,YAAlE,CAAb;AACD,G;;kBApBqByB,iC;;;;;QAjMNC,qB,GAAAA,qB;QA0CAC,I,GAAAA,I;QA+BAhB,mC,GAAAA,mC;QA8IAiB,iC,GAAAA,iC;QA+BAC,oC,GAAAA,oC;QAeAC,qC,GAAAA,qC;QAwBAC,qC,GAAAA,qC;QAiBAhB,uB,GAAAA,uB;QAiBAiB,e,GAAAA,e;;AApWhB;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;AAEA;;;;AACA;;;;AACA;;;;;;;;AAEA,MAAMT,IAAIU,QAAQ,gBAAR,EAA0B,gCAA1B,CAAV;;AAEA;AACA;AACA,IAAIC,qBAAqB,IAAzB;;AAEA,SAASZ,mBAAT,CAA6Ba,MAA7B,EAAqC;AACnC,MAAI,qCAAJ,EAAiC;AAC/B,WAAO,aAAGb,mBAAH,CAAuBa,MAAvB,CAAP;AACD;;AAED,MAAI;AACF,WAAO,aAAGC,QAAH,CAAYD,MAAZ,CAAP;AACD,GAFD,CAEE,OAAOE,CAAP,EAAU;AACV,WAAO,IAAP;AACD;AACF;;AAGD;;;;;;;;AAQO,SAASX,qBAAT,CAA+BY,YAA/B,EAA6C;AAClD,MAAIC,YAAaC,UAAUC,MAA3B;AACAF,YAAUG,kBAAV,GAA+BJ,YAA/B;;AAEA,6BAAyBA,YAAzB;;AAEA,MAAI,UAAU/B,OAAV,IAAqBA,QAAQoC,IAAR,KAAiB,SAA1C,EAAqD;AAAA,mBACnCV,QAAQ,UAAR,CADmC;;AAAA,UAC3CW,GAD2C,YAC3CA,GAD2C;;AAAA,oBAEhBX,QAAQ,iBAAR,CAFgB;;AAAA,UAE3CY,sBAF2C,aAE3CA,sBAF2C;;;AAInD,QAAIC,WAAW,YAAW;AAAED,6BAAuBP,YAAvB;AAAuC,KAAnE;AACA,QAAIM,IAAIG,OAAJ,EAAJ,EAAmB;AACjBD;AACD,KAFD,MAEO;AACLF,UAAII,EAAJ,CAAO,OAAP,EAAgBF,QAAhB;AACD;AACF;AACF;;AAGD;;;;;;;;;;;;;;;;;;;;;;AAsBO,SAASnB,IAAT,CAAcf,OAAd,EAAuBqC,UAAvB,EAA2E;AAAA,MAAxCC,cAAwC,uEAAvB,IAAuB;AAAA,MAAjBC,QAAiB,uEAAN,IAAM;;AAChF,MAAIb,eAAe,IAAnB;AACA,MAAItC,eAAe,eAAKqB,IAAL,CAAUT,OAAV,EAAmBuC,YAAY,QAA/B,CAAnB;;AAEA,MAAID,mBAAmB,IAAvB,EAA6B;AAC3BA,qBAAiB,CAAC,CAAC5B,oBAAoBtB,YAApB,CAAnB;AACD;;AAED,MAAIkD,cAAJ,EAAoB;AAClBZ,mBAAe,uBAAac,mCAAb,CAAiDpD,YAAjD,EAA+DY,OAA/D,CAAf;AACD,GAFD,MAEO;AACL;AACA,QAAIuC,QAAJ,EAAc;AACZb,qBAAeR,sCAAsClB,OAAtC,EAA+CZ,YAA/C,CAAf;AACD,KAFD,MAEO;AACLsC,qBAAeR,sCAAsClB,OAAtC,CAAf;AACD;AAEF;;AAEDc,wBAAsBY,YAAtB;AACAL,UAAQoB,IAAR,CAAapB,OAAb,CAAqBgB,UAArB;AACD;;AAGD;;;;;;AAMO,SAAStC,mCAAT,CAA6CV,IAA7C,EAAmD;AACxD,MAAIqD,YAAYtB,iBAAhB;AACA,MAAIhC,eAAeC,KAAKD,YAAL,IAAqB+B,uCAAxC;;AAEAR,IAAG,2BAAyBrB,KAAKqD,SAAL,CAAetD,IAAf,CAAqB,sBAAmBD,YAAa,GAAjF;AACA,MAAIwD,kBAAkB,8BAAqBvD,KAAKW,OAA1B,CAAtB;;AAEA,MAAI6C,eAAe,eAAKpC,IAAL,CAAUrB,YAAV,EAAwB,uBAAxB,CAAnB;AACA,MAAI,aAAG0D,UAAH,CAAcD,YAAd,CAAJ,EAAiC;AAC/B,QAAIE,MAAM,aAAGC,YAAH,CAAgBH,YAAhB,CAAV;AACA,QAAII,OAAO3D,KAAKC,KAAL,CAAW,eAAK2D,UAAL,CAAgBH,GAAhB,CAAX,CAAX;AACAH,sBAAkB,0BAAiBO,YAAjB,CAA8BF,KAAKL,eAAnC,EAAoDvD,KAAKW,OAAzD,EAAkE,KAAlE,CAAlB;AACD;;AAEDoD,SAAOC,IAAP,CAAYhE,KAAKa,OAAL,IAAgB,EAA5B,EAAgCoD,OAAhC,CAAyCC,CAAD,IAAO;AAC7C,QAAIC,OAAOnE,KAAKa,OAAL,CAAaqD,CAAb,CAAX;AACA,QAAI,EAAEA,KAAKb,SAAP,CAAJ,EAAuB;AACrB,YAAM,IAAIe,KAAJ,CAAW,kDAAgDF,CAAE,GAA7D,CAAN;AACD;;AAED;AACA,QAAIC,KAAKE,WAAT,EAAsB;AACpBhB,gBAAUa,CAAV,IAAeb,UAAU,YAAV,CAAf;AACA,aAAOc,KAAKE,WAAZ;AACD;;AAED/C,MAAG,wBAAsB4C,CAAE,OAAIjE,KAAKqD,SAAL,CAAea,IAAf,CAAqB,GAApD;AACAd,cAAUa,CAAV,EAAaI,eAAb,GAA+BH,IAA/B;AACD,GAdD;;AAgBA,MAAII,MAAM,2BAAiBxE,YAAjB,EAA+BsD,SAA/B,EAA0CE,eAA1C,EAA2D,KAA3D,EAAkEF,UAAU,YAAV,CAAlE,CAAV;;AAEA;AACA;AACA/B,IAAG,wCAAsCrB,KAAKqD,SAAL,CAAetD,IAAf,CAAqB,GAA9D;AACAuE,MAAIC,qBAAJ;AACA,SAAOD,GAAP;AACD,CAyGM,SAAS5C,iCAAT,CAA2C7B,IAA3C,EAAoE;AAAA,MAAnBC,YAAmB,uEAAN,IAAM;;AACzE,MAAIC,OAAOC,KAAKC,KAAL,CAAW,aAAGyD,YAAH,CAAgB7D,IAAhB,EAAsB,MAAtB,CAAX,CAAX;;AAEA;AACA,MAAI,WAAWE,IAAf,EAAqB;AACnBA,WAAOA,KAAKI,KAAZ;AACD;;AAED,MAAI,SAASJ,IAAb,EAAmB;AACjB,QAAIK,SAASC,QAAQC,GAAR,CAAYC,SAAZ,IAAyBF,QAAQC,GAAR,CAAYE,QAArC,IAAiD,aAA9D;AACAT,WAAOA,KAAKO,GAAL,CAASF,MAAT,CAAP;AACD;;AAED;AACA,MAAI,UAAUL,IAAV,IAAkB,aAAaA,IAAnC,EAAyC;AACvC,WAAOU,oCAAoC;AACzCC,eAAS,eAAKC,OAAL,CAAad,IAAb,CADgC;AAEzCe,eAASC,yBAFgC;AAGzCf;AAHyC,KAApC,CAAP;AAKD;;AAED,SAAOW,oCAAoC;AACzCC,aAAS,eAAKC,OAAL,CAAad,IAAb,CADgC;AAEzCe,aAAS;AACP,gCAA0Bb;AADnB,KAFgC;AAKzCD;AALyC,GAApC,CAAP;AAOD;;AAEM,SAAS6B,oCAAT,CAA8C9B,IAA9C,EAAuE;AAAA,MAAnBC,YAAmB,uEAAN,IAAM;;AAC5E,MAAIC,OAAOC,KAAKC,KAAL,CAAW,aAAGyD,YAAH,CAAgB7D,IAAhB,EAAsB,MAAtB,CAAX,CAAX;;AAEA,MAAI,SAASE,IAAb,EAAmB;AACjB,QAAIK,SAASC,QAAQC,GAAR,CAAYS,oBAAZ,IAAoCV,QAAQC,GAAR,CAAYE,QAAhD,IAA4D,aAAzE;AACAT,WAAOA,KAAKO,GAAL,CAASF,MAAT,CAAP;AACD;;AAED,SAAOK,oCAAoC;AACzCC,aAAS,eAAKC,OAAL,CAAad,IAAb,CADgC;AAEzCe,aAASb,IAFgC;AAGzCD;AAHyC,GAApC,CAAP;AAKD;;AAEM,SAAS8B,qCAAT,CAA+CX,OAA/C,EAA2E;AAAA,MAAnBnB,YAAmB,uEAAN,IAAM;;AAChF,MAAIoB,YAAY,eAAKC,IAAL,CAAUF,OAAV,EAAmB,YAAnB,CAAhB;AACA,MAAIG,oBAAoBF,SAApB,CAAJ,EAAoC;AAClCG,MAAG,0BAAwBH,SAAU,aAArC;AACA,WAAOS,qCAAqCT,SAArC,EAAgDpB,YAAhD,CAAP;AACD;;AAED,MAAIwB,UAAU,eAAKH,IAAL,CAAUF,OAAV,EAAmB,UAAnB,CAAd;AACA,MAAIG,oBAAoBE,OAApB,CAAJ,EAAkC;AAChCD,MAAG,wBAAsBC,OAAQ,aAAjC;AACA,WAAOI,kCAAkCJ,OAAlC,EAA2CxB,YAA3C,CAAP;AACD;;AAEDuB,IAAG,gDAA8CJ,OAAQ,GAAzD;AACA,SAAOS,kCAAkC,eAAKP,IAAL,CAAUF,OAAV,EAAmB,cAAnB,CAAlC,EAAsEnB,YAAtE,CAAP;AACD;;AAED;;;;;;;AAOO,SAAS+B,qCAAT,GAAiD;AACtD,MAAI2C,SAASnE,QAAQC,GAAR,CAAYmE,IAAZ,IAAoBpE,QAAQC,GAAR,CAAYoE,MAAhC,IAA0C,MAAvD;AACA,MAAIC,OAAO5C,QAAQ,QAAR,EAAkB6C,UAAlB,CAA6B,KAA7B,EAAoCC,MAApC,CAA2CxE,QAAQyE,QAAnD,EAA6DC,MAA7D,CAAoE,KAApE,CAAX;;AAEA,MAAI9B,WAAW,eAAK9B,IAAL,CAAUqD,MAAV,EAAmB,iBAAeG,IAAK,GAAvC,CAAf;AACA,mBAAOK,IAAP,CAAY/B,QAAZ;;AAEA5B,IAAG,mCAAiC4B,QAAS,GAA7C;AACA,SAAOA,QAAP;AACD;;AAGD;;;;;AAKO,SAASpC,uBAAT,GAAmC;AACxC,SAAO;AACL,8BAA0B;AACxB,iBAAW,CAAC,cAAD,EAAiB,OAAjB,CADa;AAExB,oBAAc;AAFU;AADrB,GAAP;AAMD;;AAED;;;;;;;;AAQO,SAASiB,eAAT,GAA2B;AAChC,MAAI,CAACE,kBAAL,EAAyB;AACvB;AACA;AACA;AACA;AACA,UAAMiD,YAAY,CAAC,oBAAD,EAAuB,0BAAvB,CAAlB;;AAEA,SAAK,IAAIC,QAAT,IAAqBD,SAArB,EAAgC;AAC9B,UAAI;AACFjD,6BAAqBD,QAAQmD,QAAR,CAArB;AACD,OAFD,CAEE,OAAO/C,CAAP,EAAU;AACV;AACD;AACF;;AAED,QAAI,CAACH,kBAAL,EAAyB;AACvB,YAAM,IAAImC,KAAJ,CAAU,8DAAV,CAAN;AACD;AACF;;AAED;AACA;AACA;AACA;AACA,MAAIG,MAAM,EAAV;AACA,MAAIa,sBAAsBnD,mBAAmBoD,GAAnB,CAAwBC,KAAD,IAAW;AAC1D,QAAI,yBAAyBA,KAA7B,EAAoC;AAClC,aAAOA,MAAMC,mBAAN,CAA0BhB,GAA1B,CAAP;AACD,KAFD,MAEO;AACL,aAAO,IAAIe,KAAJ,EAAP;AACD;AACF,GANyB,CAA1B;;AAQAF,sBAAoBI,MAApB,CAA2B,CAACC,GAAD,EAAKvB,CAAL,KAAW;AACpC,QAAIoB,QAAQvB,OAAO2B,cAAP,CAAsBxB,CAAtB,EAAyByB,WAArC;;AAEA,SAAK,IAAIjD,IAAT,IAAiB4C,MAAMM,iBAAN,EAAjB,EAA4C;AAAEH,UAAI/C,IAAJ,IAAYwB,CAAZ;AAAgB;AAC9D,WAAOuB,GAAP;AACD,GALD,EAKGlB,GALH;;AAOA,SAAOA,GAAP;AACD","file":"config-parser.js","sourcesContent":["import fs from 'fs';\r\nimport path from 'path';\r\nimport zlib from 'zlib';\r\nimport mkdirp from 'mkdirp';\r\nimport {pfs} from './promise';\r\n\r\nimport FileChangedCache from './file-change-cache';\r\nimport CompilerHost from './compiler-host';\r\nimport registerRequireExtension from './require-hook';\r\n\r\nconst d = require('debug-electron')('electron-compile:config-parser');\r\n\r\n// NB: We intentionally delay-load this so that in production, you can create\r\n// cache-only versions of these compilers\r\nlet allCompilerClasses = null;\r\n\r\nfunction statSyncNoException(fsPath) {\r\n  if ('statSyncNoException' in fs) {\r\n    return fs.statSyncNoException(fsPath);\r\n  }\r\n\r\n  try {\r\n    return fs.statSync(fsPath);\r\n  } catch (e) {\r\n    return null;\r\n  }\r\n}\r\n\r\n\r\n/**\r\n * Initialize the global hooks (protocol hook for file:, node.js hook)\r\n * independent of initializing the compiler. This method is usually called by\r\n * init instead of directly\r\n *\r\n * @param {CompilerHost} compilerHost  The compiler host to use.\r\n *\r\n */\r\nexport function initializeGlobalHooks(compilerHost) {\r\n  let globalVar = (global || window);\r\n  globalVar.globalCompilerHost = compilerHost;\r\n\r\n  registerRequireExtension(compilerHost);\r\n\r\n  if ('type' in process && process.type === 'browser') {\r\n    const { app } = require('electron');\r\n    const { initializeProtocolHook } = require('./protocol-hook');\r\n\r\n    let protoify = function() { initializeProtocolHook(compilerHost); };\r\n    if (app.isReady()) {\r\n      protoify();\r\n    } else {\r\n      app.on('ready', protoify);\r\n    }\r\n  }\r\n}\r\n\r\n\r\n/**\r\n * Initialize electron-compile and set it up, either for development or\r\n * production use. This is almost always the only method you need to use in order\r\n * to use electron-compile.\r\n *\r\n * @param  {string} appRoot  The top-level directory for your application (i.e.\r\n *                           the one which has your package.json).\r\n *\r\n * @param  {string} mainModule  The module to require in, relative to the module\r\n *                              calling init, that will start your app. Write this\r\n *                              as if you were writing a require call from here.\r\n *\r\n * @param  {bool} productionMode   If explicitly True/False, will set read-only\r\n *                                 mode to be disabled/enabled. If not, we'll\r\n *                                 guess based on the presence of a production\r\n *                                 cache.\r\n *\r\n * @param  {string} cacheDir  If not passed in, read-only will look in\r\n *                            `appRoot/.cache` and dev mode will compile to a\r\n *                            temporary directory. If it is passed in, both modes\r\n *                            will cache to/from `appRoot/{cacheDir}`\r\n */\r\nexport function init(appRoot, mainModule, productionMode = null, cacheDir = null) {\r\n  let compilerHost = null;\r\n  let rootCacheDir = path.join(appRoot, cacheDir || '.cache');\r\n\r\n  if (productionMode === null) {\r\n    productionMode = !!statSyncNoException(rootCacheDir);\r\n  }\r\n\r\n  if (productionMode) {\r\n    compilerHost = CompilerHost.createReadonlyFromConfigurationSync(rootCacheDir, appRoot);\r\n  } else {\r\n    // if cacheDir was passed in, pass it along. Otherwise, default to a tempdir.\r\n    if (cacheDir) {\r\n      compilerHost = createCompilerHostFromProjectRootSync(appRoot, rootCacheDir);\r\n    } else {\r\n      compilerHost = createCompilerHostFromProjectRootSync(appRoot);\r\n    }\r\n\r\n  }\r\n\r\n  initializeGlobalHooks(compilerHost);\r\n  require.main.require(mainModule);\r\n}\r\n\r\n\r\n/**\r\n * Creates a {@link CompilerHost} with the given information. This method is\r\n * usually called by {@link createCompilerHostFromProjectRoot}.\r\n *\r\n * @private\r\n */\r\nexport function createCompilerHostFromConfiguration(info) {\r\n  let compilers = createCompilers();\r\n  let rootCacheDir = info.rootCacheDir || calculateDefaultCompileCacheDirectory();\r\n\r\n  d(`Creating CompilerHost: ${JSON.stringify(info)}, rootCacheDir = ${rootCacheDir}`);\r\n  let fileChangeCache = new FileChangedCache(info.appRoot);\r\n\r\n  let compilerInfo = path.join(rootCacheDir, 'compiler-info.json.gz');\r\n  if (fs.existsSync(compilerInfo)) {\r\n    let buf = fs.readFileSync(compilerInfo);\r\n    let json = JSON.parse(zlib.gunzipSync(buf));\r\n    fileChangeCache = FileChangedCache.loadFromData(json.fileChangeCache, info.appRoot, false);\r\n  }\r\n\r\n  Object.keys(info.options || {}).forEach((x) => {\r\n    let opts = info.options[x];\r\n    if (!(x in compilers)) {\r\n      throw new Error(`Found compiler settings for missing compiler: ${x}`);\r\n    }\r\n\r\n    // NB: Let's hope this isn't a valid compiler option...\r\n    if (opts.passthrough) {\r\n      compilers[x] = compilers['text/plain'];\r\n      delete opts.passthrough;\r\n    }\r\n\r\n    d(`Setting options for ${x}: ${JSON.stringify(opts)}`);\r\n    compilers[x].compilerOptions = opts;\r\n  });\r\n\r\n  let ret = new CompilerHost(rootCacheDir, compilers, fileChangeCache, false, compilers['text/plain']);\r\n\r\n  // NB: It's super important that we guarantee that the configuration is saved\r\n  // out, because we'll need to re-read it in the renderer process\r\n  d(`Created compiler host with options: ${JSON.stringify(info)}`);\r\n  ret.saveConfigurationSync();\r\n  return ret;\r\n}\r\n\r\n/**\r\n * Creates a compiler host from a .babelrc file. This method is usually called\r\n * from {@link createCompilerHostFromProjectRoot} instead of used directly.\r\n *\r\n * @param  {string} file  The path to a .babelrc file\r\n *\r\n * @param  {string} rootCacheDir (optional)  The directory to use as a cache.\r\n *\r\n * @return {Promise<CompilerHost>}  A set-up compiler host\r\n */\r\nexport async function createCompilerHostFromBabelRc(file, rootCacheDir=null) {\r\n  let info = JSON.parse(await pfs.readFile(file, 'utf8'));\r\n\r\n  // package.json\r\n  if ('babel' in info) {\r\n    info = info.babel;\r\n  }\r\n\r\n  if ('env' in info) {\r\n    let ourEnv = process.env.BABEL_ENV || process.env.NODE_ENV || 'development';\r\n    info = info.env[ourEnv];\r\n  }\r\n\r\n  // Are we still package.json (i.e. is there no babel info whatsoever?)\r\n  if ('name' in info && 'version' in info) {\r\n    return createCompilerHostFromConfiguration({\r\n      appRoot: path.dirname(file),\r\n      options: getDefaultConfiguration(),\r\n      rootCacheDir\r\n    });\r\n  }\r\n\r\n  return createCompilerHostFromConfiguration({\r\n    appRoot: path.dirname(file),\r\n    options: {\r\n      'application/javascript': info\r\n    },\r\n    rootCacheDir\r\n  });\r\n}\r\n\r\n\r\n/**\r\n * Creates a compiler host from a .compilerc file. This method is usually called\r\n * from {@link createCompilerHostFromProjectRoot} instead of used directly.\r\n *\r\n * @param  {string} file  The path to a .compilerc file\r\n *\r\n * @param  {string} rootCacheDir (optional)  The directory to use as a cache.\r\n *\r\n * @return {Promise<CompilerHost>}  A set-up compiler host\r\n */\r\nexport async function createCompilerHostFromConfigFile(file, rootCacheDir=null) {\r\n  let info = JSON.parse(await pfs.readFile(file, 'utf8'));\r\n\r\n  if ('env' in info) {\r\n    let ourEnv = process.env.ELECTRON_COMPILE_ENV || process.env.NODE_ENV || 'development';\r\n    info = info.env[ourEnv];\r\n  }\r\n\r\n  return createCompilerHostFromConfiguration({\r\n    appRoot: path.dirname(file),\r\n    options: info,\r\n    rootCacheDir\r\n  });\r\n}\r\n\r\n\r\n/**\r\n * Creates a configured {@link CompilerHost} instance from the project root\r\n * directory. This method first searches for a .compilerc (or .compilerc.json), then falls back to the\r\n * default locations for Babel configuration info. If neither are found, defaults\r\n * to standard settings\r\n *\r\n * @param  {string} rootDir  The root application directory (i.e. the directory\r\n *                           that has the app's package.json)\r\n *\r\n * @param  {string} rootCacheDir (optional)  The directory to use as a cache.\r\n *\r\n * @return {Promise<CompilerHost>}  A set-up compiler host\r\n */\r\nexport async function createCompilerHostFromProjectRoot(rootDir, rootCacheDir=null) {\r\n  let compilerc = path.join(rootDir, '.compilerc');\r\n  if (statSyncNoException(compilerc)) {\r\n    d(`Found a .compilerc at ${compilerc}, using it`);\r\n    return await createCompilerHostFromConfigFile(compilerc, rootCacheDir);\r\n  }\r\n  compilerc += '.json';\r\n  if (statSyncNoException(compilerc)) {\r\n    d(`Found a .compilerc at ${compilerc}, using it`);\r\n    return await createCompilerHostFromConfigFile(compilerc, rootCacheDir);\r\n  }\r\n\r\n  let babelrc = path.join(rootDir, '.babelrc');\r\n  if (statSyncNoException(babelrc)) {\r\n    d(`Found a .babelrc at ${babelrc}, using it`);\r\n    return await createCompilerHostFromBabelRc(babelrc, rootCacheDir);\r\n  }\r\n\r\n  d(`Using package.json or default parameters at ${rootDir}`);\r\n  return await createCompilerHostFromBabelRc(path.join(rootDir, 'package.json'), rootCacheDir);\r\n}\r\n\r\nexport function createCompilerHostFromBabelRcSync(file, rootCacheDir=null) {\r\n  let info = JSON.parse(fs.readFileSync(file, 'utf8'));\r\n\r\n  // package.json\r\n  if ('babel' in info) {\r\n    info = info.babel;\r\n  }\r\n\r\n  if ('env' in info) {\r\n    let ourEnv = process.env.BABEL_ENV || process.env.NODE_ENV || 'development';\r\n    info = info.env[ourEnv];\r\n  }\r\n\r\n  // Are we still package.json (i.e. is there no babel info whatsoever?)\r\n  if ('name' in info && 'version' in info) {\r\n    return createCompilerHostFromConfiguration({\r\n      appRoot: path.dirname(file),\r\n      options: getDefaultConfiguration(),\r\n      rootCacheDir\r\n    });\r\n  }\r\n\r\n  return createCompilerHostFromConfiguration({\r\n    appRoot: path.dirname(file),\r\n    options: {\r\n      'application/javascript': info\r\n    },\r\n    rootCacheDir\r\n  });\r\n}\r\n\r\nexport function createCompilerHostFromConfigFileSync(file, rootCacheDir=null) {\r\n  let info = JSON.parse(fs.readFileSync(file, 'utf8'));\r\n\r\n  if ('env' in info) {\r\n    let ourEnv = process.env.ELECTRON_COMPILE_ENV || process.env.NODE_ENV || 'development';\r\n    info = info.env[ourEnv];\r\n  }\r\n\r\n  return createCompilerHostFromConfiguration({\r\n    appRoot: path.dirname(file),\r\n    options: info,\r\n    rootCacheDir\r\n  });\r\n}\r\n\r\nexport function createCompilerHostFromProjectRootSync(rootDir, rootCacheDir=null) {\r\n  let compilerc = path.join(rootDir, '.compilerc');\r\n  if (statSyncNoException(compilerc)) {\r\n    d(`Found a .compilerc at ${compilerc}, using it`);\r\n    return createCompilerHostFromConfigFileSync(compilerc, rootCacheDir);\r\n  }\r\n\r\n  let babelrc = path.join(rootDir, '.babelrc');\r\n  if (statSyncNoException(babelrc)) {\r\n    d(`Found a .babelrc at ${babelrc}, using it`);\r\n    return createCompilerHostFromBabelRcSync(babelrc, rootCacheDir);\r\n  }\r\n\r\n  d(`Using package.json or default parameters at ${rootDir}`);\r\n  return createCompilerHostFromBabelRcSync(path.join(rootDir, 'package.json'), rootCacheDir);\r\n}\r\n\r\n/**\r\n * Returns what electron-compile would use as a default rootCacheDir. Usually only\r\n * used for debugging purposes\r\n *\r\n * @return {string}  A path that may or may not exist where electron-compile would\r\n *                   set up a development mode cache.\r\n */\r\nexport function calculateDefaultCompileCacheDirectory() {\r\n  let tmpDir = process.env.TEMP || process.env.TMPDIR || '/tmp';\r\n  let hash = require('crypto').createHash('md5').update(process.execPath).digest('hex');\r\n\r\n  let cacheDir = path.join(tmpDir, `compileCache_${hash}`);\r\n  mkdirp.sync(cacheDir);\r\n\r\n  d(`Using default cache directory: ${cacheDir}`);\r\n  return cacheDir;\r\n}\r\n\r\n\r\n/**\r\n * Returns the default .configrc if no configuration information can be found.\r\n *\r\n * @return {Object}  A list of default config settings for electron-compiler.\r\n */\r\nexport function getDefaultConfiguration() {\r\n  return {\r\n    'application/javascript': {\r\n      \"presets\": [\"es2016-node5\", \"react\"],\r\n      \"sourceMaps\": \"inline\"\r\n    }\r\n  };\r\n}\r\n\r\n/**\r\n * Allows you to create new instances of all compilers that are supported by\r\n * electron-compile and use them directly. Currently supports Babel, CoffeeScript,\r\n * TypeScript, Less, and Jade.\r\n *\r\n * @return {Object}  An Object whose Keys are MIME types, and whose values\r\n * are instances of @{link CompilerBase}.\r\n */\r\nexport function createCompilers() {\r\n  if (!allCompilerClasses) {\r\n    // First we want to see if electron-compilers itself has been installed with\r\n    // devDependencies. If that's not the case, check to see if\r\n    // electron-compilers is installed as a peer dependency (probably as a\r\n    // devDependency of the root project).\r\n    const locations = ['electron-compilers', '../../electron-compilers'];\r\n\r\n    for (let location of locations) {\r\n      try {\r\n        allCompilerClasses = require(location);\r\n      } catch (e) {\r\n        // Yolo\r\n      }\r\n    }\r\n\r\n    if (!allCompilerClasses) {\r\n      throw new Error(\"Electron compilers not found but were requested to be loaded\");\r\n    }\r\n  }\r\n\r\n  // NB: Note that this code is carefully set up so that InlineHtmlCompiler\r\n  // (i.e. classes with `createFromCompilers`) initially get an empty object,\r\n  // but will have a reference to the final result of what we return, which\r\n  // resolves the circular dependency we'd otherwise have here.\r\n  let ret = {};\r\n  let instantiatedClasses = allCompilerClasses.map((Klass) => {\r\n    if ('createFromCompilers' in Klass) {\r\n      return Klass.createFromCompilers(ret);\r\n    } else {\r\n      return new Klass();\r\n    }\r\n  });\r\n\r\n  instantiatedClasses.reduce((acc,x) => {\r\n    let Klass = Object.getPrototypeOf(x).constructor;\r\n\r\n    for (let type of Klass.getInputMimeTypes()) { acc[type] = x; }\r\n    return acc;\r\n  }, ret);\r\n\r\n  return ret;\r\n}\r\n"]}