electron-compile
Version:
Electron supporting package to compile JS and CSS in Electron applications
332 lines (275 loc) • 36.3 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
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 _digestForObject = require('./digest-for-object');
var _digestForObject2 = _interopRequireDefault(_digestForObject);
var _promise = require('./promise');
var _mkdirp = require('mkdirp');
var _mkdirp2 = _interopRequireDefault(_mkdirp);
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:compile-cache');
/**
* CompileCache manages getting and setting entries for a single compiler; each
* in-use compiler will have an instance of this class, usually created via
* {@link createFromCompiler}.
*
* You usually will not use this class directly, it is an implementation class
* for {@link CompileHost}.
*/
class CompileCache {
/**
* Creates an instance, usually used for testing only.
*
* @param {string} cachePath The root directory to use as a cache path
*
* @param {FileChangedCache} fileChangeCache A file-change cache that is
* optionally pre-loaded.
*/
constructor(cachePath, fileChangeCache) {
this.cachePath = cachePath;
this.fileChangeCache = fileChangeCache;
}
/**
* Creates a CompileCache from a class compatible with the CompilerBase
* interface. This method uses the compiler name / version / options to
* generate a unique directory name for cached results
*
* @param {string} cachePath The root path to use for the cache, a directory
* representing the hash of the compiler parameters
* will be created here.
*
* @param {CompilerBase} compiler The compiler to use for version / option
* information.
*
* @param {FileChangedCache} fileChangeCache A file-change cache that is
* optionally pre-loaded.
*
* @param {boolean} readOnlyMode Don't attempt to create the cache directory.
*
* @return {CompileCache} A configured CompileCache instance.
*/
static createFromCompiler(cachePath, compiler, fileChangeCache) {
let readOnlyMode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
let newCachePath = null;
let getCachePath = () => {
if (newCachePath) return newCachePath;
const digestObj = {
name: compiler.name || Object.getPrototypeOf(compiler).constructor.name,
version: compiler.getCompilerVersion(),
options: compiler.compilerOptions
};
newCachePath = _path2.default.join(cachePath, (0, _digestForObject2.default)(digestObj));
d(`Path for ${ digestObj.name }: ${ newCachePath }`);
d(`Set up with parameters: ${ JSON.stringify(digestObj) }`);
if (!readOnlyMode) _mkdirp2.default.sync(newCachePath);
return newCachePath;
};
let ret = new CompileCache('', fileChangeCache);
ret.getCachePath = getCachePath;
return ret;
}
/**
* Returns a file's compiled contents from the cache.
*
* @param {string} filePath The path to the file. FileChangedCache will look
* up the hash and use that as the key in the cache.
*
* @return {Promise<Object>} An object with all kinds of information
*
* @property {Object} hashInfo The hash information returned from getHashForPath
* @property {string} code The source code if the file was a text file
* @property {Buffer} binaryData The file if it was a binary file
* @property {string} mimeType The MIME type saved in the cache.
* @property {string[]} dependentFiles The dependent files returned from
* compiling the file, if any.
*/
get(filePath) {
var _this = this;
return _asyncToGenerator(function* () {
d(`Fetching ${ filePath } from cache`);
let hashInfo = yield _this.fileChangeCache.getHashForPath(_path2.default.resolve(filePath));
let code = null;
let mimeType = null;
let binaryData = null;
let dependentFiles = null;
let cacheFile = null;
try {
cacheFile = _path2.default.join(_this.getCachePath(), hashInfo.hash);
let result = null;
if (hashInfo.isFileBinary) {
d("File is binary, reading out info");
let info = JSON.parse((yield _promise.pfs.readFile(cacheFile + '.info')));
mimeType = info.mimeType;
dependentFiles = info.dependentFiles;
binaryData = hashInfo.binaryData;
if (!binaryData) {
binaryData = yield _promise.pfs.readFile(cacheFile);
binaryData = yield _promise.pzlib.gunzip(binaryData);
}
} else {
let buf = yield _promise.pfs.readFile(cacheFile);
let str = (yield _promise.pzlib.gunzip(buf)).toString('utf8');
result = JSON.parse(str);
code = result.code;
mimeType = result.mimeType;
dependentFiles = result.dependentFiles;
}
} catch (e) {
d(`Failed to read cache for ${ filePath }, looked in ${ cacheFile }: ${ e.message }`);
}
return { hashInfo, code, mimeType, binaryData, dependentFiles };
})();
}
/**
* Saves a compiled result to cache
*
* @param {Object} hashInfo The hash information returned from getHashForPath
*
* @param {string / Buffer} codeOrBinaryData The file's contents, either as
* a string or a Buffer.
* @param {string} mimeType The MIME type returned by the compiler.
*
* @param {string[]} dependentFiles The list of dependent files returned by
* the compiler.
* @return {Promise} Completion.
*/
save(hashInfo, codeOrBinaryData, mimeType, dependentFiles) {
var _this2 = this;
return _asyncToGenerator(function* () {
let buf = null;
let target = _path2.default.join(_this2.getCachePath(), hashInfo.hash);
d(`Saving to ${ target }`);
if (hashInfo.isFileBinary) {
buf = yield _promise.pzlib.gzip(codeOrBinaryData);
yield _promise.pfs.writeFile(target + '.info', JSON.stringify({ mimeType, dependentFiles }), 'utf8');
} else {
buf = yield _promise.pzlib.gzip(new Buffer(JSON.stringify({ code: codeOrBinaryData, mimeType, dependentFiles })));
}
yield _promise.pfs.writeFile(target, buf);
})();
}
/**
* Attempts to first get a key via {@link get}, then if it fails, call a method
* to retrieve the contents, then save the result to cache.
*
* The fetcher parameter is expected to have the signature:
*
* Promise<Object> fetcher(filePath : string, hashInfo : Object);
*
* hashInfo is a value returned from getHashForPath
* The return value of fetcher must be an Object with the properties:
*
* mimeType - the MIME type of the data to save
* code (optional) - the source code as a string, if file is text
* binaryData (optional) - the file contents as a Buffer, if file is binary
* dependentFiles - the dependent files returned by the compiler.
*
* @param {string} filePath The path to the file. FileChangedCache will look
* up the hash and use that as the key in the cache.
*
* @param {Function} fetcher A method which conforms to the description above.
*
* @return {Promise<Object>} An Object which has the same fields as the
* {@link get} method return result.
*/
getOrFetch(filePath, fetcher) {
var _this3 = this;
return _asyncToGenerator(function* () {
let cacheResult = yield _this3.get(filePath);
if (cacheResult.code || cacheResult.binaryData) return cacheResult;
let result = (yield fetcher(filePath, cacheResult.hashInfo)) || { hashInfo: cacheResult.hashInfo };
if (result.mimeType && !cacheResult.hashInfo.isInNodeModules) {
d(`Cache miss: saving out info for ${ filePath }`);
yield _this3.save(cacheResult.hashInfo, result.code || result.binaryData, result.mimeType, result.dependentFiles);
}
result.hashInfo = cacheResult.hashInfo;
return result;
})();
}
getSync(filePath) {
d(`Fetching ${ filePath } from cache`);
let hashInfo = this.fileChangeCache.getHashForPathSync(_path2.default.resolve(filePath));
let code = null;
let mimeType = null;
let binaryData = null;
let dependentFiles = null;
try {
let cacheFile = _path2.default.join(this.getCachePath(), hashInfo.hash);
let result = null;
if (hashInfo.isFileBinary) {
d("File is binary, reading out info");
let info = JSON.parse(_fs2.default.readFileSync(cacheFile + '.info'));
mimeType = info.mimeType;
dependentFiles = info.dependentFiles;
binaryData = hashInfo.binaryData;
if (!binaryData) {
binaryData = _fs2.default.readFileSync(cacheFile);
binaryData = _zlib2.default.gunzipSync(binaryData);
}
} else {
let buf = _fs2.default.readFileSync(cacheFile);
let str = _zlib2.default.gunzipSync(buf).toString('utf8');
result = JSON.parse(str);
code = result.code;
mimeType = result.mimeType;
dependentFiles = result.dependentFiles;
}
} catch (e) {
d(`Failed to read cache for ${ filePath }`);
}
return { hashInfo, code, mimeType, binaryData, dependentFiles };
}
saveSync(hashInfo, codeOrBinaryData, mimeType, dependentFiles) {
let buf = null;
let target = _path2.default.join(this.getCachePath(), hashInfo.hash);
d(`Saving to ${ target }`);
if (hashInfo.isFileBinary) {
buf = _zlib2.default.gzipSync(codeOrBinaryData);
_fs2.default.writeFileSync(target + '.info', JSON.stringify({ mimeType, dependentFiles }), 'utf8');
} else {
buf = _zlib2.default.gzipSync(new Buffer(JSON.stringify({ code: codeOrBinaryData, mimeType, dependentFiles })));
}
_fs2.default.writeFileSync(target, buf);
}
getOrFetchSync(filePath, fetcher) {
let cacheResult = this.getSync(filePath);
if (cacheResult.code || cacheResult.binaryData) return cacheResult;
let result = fetcher(filePath, cacheResult.hashInfo) || { hashInfo: cacheResult.hashInfo };
if (result.mimeType && !cacheResult.hashInfo.isInNodeModules) {
d(`Cache miss: saving out info for ${ filePath }`);
this.saveSync(cacheResult.hashInfo, result.code || result.binaryData, result.mimeType, result.dependentFiles);
}
result.hashInfo = cacheResult.hashInfo;
return result;
}
/**
* @private
*/
getCachePath() {
// NB: This is an evil hack so that createFromCompiler can stomp it
// at will
return this.cachePath;
}
/**
* Returns whether a file should not be compiled. Note that this doesn't
* necessarily mean it won't end up in the cache, only that its contents are
* saved verbatim instead of trying to find an appropriate compiler.
*
* @param {Object} hashInfo The hash information returned from getHashForPath
*
* @return {boolean} True if a file should be ignored
*/
static shouldPassthrough(hashInfo) {
return hashInfo.isMinified || hashInfo.isInNodeModules || hashInfo.hasSourceMap || hashInfo.isFileBinary;
}
}
exports.default = CompileCache;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/compile-cache.js"],"names":["d","require","CompileCache","constructor","cachePath","fileChangeCache","createFromCompiler","compiler","readOnlyMode","newCachePath","getCachePath","digestObj","name","Object","getPrototypeOf","version","getCompilerVersion","options","compilerOptions","join","JSON","stringify","sync","ret","get","filePath","hashInfo","getHashForPath","resolve","code","mimeType","binaryData","dependentFiles","cacheFile","hash","result","isFileBinary","info","parse","readFile","gunzip","buf","str","toString","e","message","save","codeOrBinaryData","target","gzip","writeFile","Buffer","getOrFetch","fetcher","cacheResult","isInNodeModules","getSync","getHashForPathSync","readFileSync","gunzipSync","saveSync","gzipSync","writeFileSync","getOrFetchSync","shouldPassthrough","isMinified","hasSourceMap"],"mappings":"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","file":"compile-cache.js","sourcesContent":["import fs from 'fs';\r\nimport path from 'path';\r\nimport zlib from 'zlib';\r\nimport createDigestForObject from './digest-for-object';\r\nimport {pfs, pzlib} from './promise';\r\nimport mkdirp from 'mkdirp';\r\n\r\nconst d = require('debug-electron')('electron-compile:compile-cache');\r\n\r\n/**\r\n * CompileCache manages getting and setting entries for a single compiler; each\r\n * in-use compiler will have an instance of this class, usually created via\r\n * {@link createFromCompiler}.\r\n *\r\n * You usually will not use this class directly, it is an implementation class\r\n * for {@link CompileHost}.\r\n */\r\nexport default class CompileCache {\r\n  /**\r\n   * Creates an instance, usually used for testing only.\r\n   *\r\n   * @param  {string} cachePath  The root directory to use as a cache path\r\n   *\r\n   * @param  {FileChangedCache} fileChangeCache  A file-change cache that is\r\n   *                                             optionally pre-loaded.\r\n   */\r\n  constructor(cachePath, fileChangeCache) {\r\n    this.cachePath = cachePath;\r\n    this.fileChangeCache = fileChangeCache;\r\n  }\r\n\r\n  /**\r\n   * Creates a CompileCache from a class compatible with the CompilerBase\r\n   * interface. This method uses the compiler name / version / options to\r\n   * generate a unique directory name for cached results\r\n   *\r\n   * @param  {string} cachePath  The root path to use for the cache, a directory\r\n   *                             representing the hash of the compiler parameters\r\n   *                             will be created here.\r\n   *\r\n   * @param  {CompilerBase} compiler  The compiler to use for version / option\r\n   *                                  information.\r\n   *\r\n   * @param  {FileChangedCache} fileChangeCache  A file-change cache that is\r\n   *                                             optionally pre-loaded.\r\n   *\r\n   * @param  {boolean} readOnlyMode  Don't attempt to create the cache directory.\r\n   *\r\n   * @return {CompileCache}  A configured CompileCache instance.\r\n   */\r\n  static createFromCompiler(cachePath, compiler, fileChangeCache, readOnlyMode=false) {\r\n    let newCachePath = null;\r\n    let getCachePath = () => {\r\n      if (newCachePath) return newCachePath;\r\n\r\n      const digestObj = {\r\n        name: compiler.name || Object.getPrototypeOf(compiler).constructor.name,\r\n        version: compiler.getCompilerVersion(),\r\n        options: compiler.compilerOptions\r\n      };\r\n\r\n      newCachePath = path.join(cachePath, createDigestForObject(digestObj));\r\n\r\n      d(`Path for ${digestObj.name}: ${newCachePath}`);\r\n      d(`Set up with parameters: ${JSON.stringify(digestObj)}`);\r\n\r\n      if (!readOnlyMode) mkdirp.sync(newCachePath);\r\n      return newCachePath;\r\n    };\r\n\r\n    let ret = new CompileCache('', fileChangeCache);\r\n    ret.getCachePath = getCachePath;\r\n\r\n    return ret;\r\n  }\r\n\r\n  /**\r\n   * Returns a file's compiled contents from the cache.\r\n   *\r\n   * @param  {string} filePath  The path to the file. FileChangedCache will look\r\n   *                            up the hash and use that as the key in the cache.\r\n   *\r\n   * @return {Promise<Object>}  An object with all kinds of information\r\n   *\r\n   * @property {Object} hashInfo  The hash information returned from getHashForPath\r\n   * @property {string} code  The source code if the file was a text file\r\n   * @property {Buffer} binaryData  The file if it was a binary file\r\n   * @property {string} mimeType  The MIME type saved in the cache.\r\n   * @property {string[]} dependentFiles  The dependent files returned from\r\n   *                                      compiling the file, if any.\r\n   */\r\n  async get(filePath) {\r\n    d(`Fetching ${filePath} from cache`);\r\n    let hashInfo = await this.fileChangeCache.getHashForPath(path.resolve(filePath));\r\n\r\n    let code = null;\r\n    let mimeType = null;\r\n    let binaryData = null;\r\n    let dependentFiles = null;\r\n\r\n    let cacheFile = null;\r\n    try {\r\n      cacheFile = path.join(this.getCachePath(), hashInfo.hash);\r\n      let result = null;\r\n\r\n      if (hashInfo.isFileBinary) {\r\n        d(\"File is binary, reading out info\");\r\n        let info = JSON.parse(await pfs.readFile(cacheFile + '.info'));\r\n        mimeType = info.mimeType;\r\n        dependentFiles = info.dependentFiles;\r\n\r\n        binaryData = hashInfo.binaryData;\r\n        if (!binaryData) {\r\n          binaryData = await pfs.readFile(cacheFile);\r\n          binaryData = await pzlib.gunzip(binaryData);\r\n        }\r\n      } else {\r\n        let buf = await pfs.readFile(cacheFile);\r\n        let str = (await pzlib.gunzip(buf)).toString('utf8');\r\n\r\n        result = JSON.parse(str);\r\n        code = result.code;\r\n        mimeType = result.mimeType;\r\n        dependentFiles = result.dependentFiles;\r\n      }\r\n    } catch (e) {\r\n      d(`Failed to read cache for ${filePath}, looked in ${cacheFile}: ${e.message}`);\r\n    }\r\n\r\n    return { hashInfo, code, mimeType, binaryData, dependentFiles };\r\n  }\r\n\r\n\r\n  /**\r\n   * Saves a compiled result to cache\r\n   *\r\n   * @param  {Object} hashInfo  The hash information returned from getHashForPath\r\n   *\r\n   * @param  {string / Buffer} codeOrBinaryData   The file's contents, either as\r\n   *                                              a string or a Buffer.\r\n   * @param  {string} mimeType  The MIME type returned by the compiler.\r\n   *\r\n   * @param  {string[]} dependentFiles  The list of dependent files returned by\r\n   *                                    the compiler.\r\n   * @return {Promise}  Completion.\r\n   */\r\n  async save(hashInfo, codeOrBinaryData, mimeType, dependentFiles) {\r\n    let buf = null;\r\n    let target = path.join(this.getCachePath(), hashInfo.hash);\r\n    d(`Saving to ${target}`);\r\n\r\n    if (hashInfo.isFileBinary) {\r\n      buf = await pzlib.gzip(codeOrBinaryData);\r\n      await pfs.writeFile(target + '.info', JSON.stringify({mimeType, dependentFiles}), 'utf8');\r\n    } else {\r\n      buf = await pzlib.gzip(new Buffer(JSON.stringify({code: codeOrBinaryData, mimeType, dependentFiles})));\r\n    }\r\n\r\n    await pfs.writeFile(target, buf);\r\n  }\r\n\r\n  /**\r\n   * Attempts to first get a key via {@link get}, then if it fails, call a method\r\n   * to retrieve the contents, then save the result to cache.\r\n   *\r\n   * The fetcher parameter is expected to have the signature:\r\n   *\r\n   * Promise<Object> fetcher(filePath : string, hashInfo : Object);\r\n   *\r\n   * hashInfo is a value returned from getHashForPath\r\n   * The return value of fetcher must be an Object with the properties:\r\n   *\r\n   * mimeType - the MIME type of the data to save\r\n   * code (optional) - the source code as a string, if file is text\r\n   * binaryData (optional) - the file contents as a Buffer, if file is binary\r\n   * dependentFiles - the dependent files returned by the compiler.\r\n   *\r\n   * @param  {string} filePath  The path to the file. FileChangedCache will look\r\n   *                            up the hash and use that as the key in the cache.\r\n   *\r\n   * @param  {Function} fetcher  A method which conforms to the description above.\r\n   *\r\n   * @return {Promise<Object>}  An Object which has the same fields as the\r\n   *                            {@link get} method return result.\r\n   */\r\n  async getOrFetch(filePath, fetcher) {\r\n    let cacheResult = await this.get(filePath);\r\n    if (cacheResult.code || cacheResult.binaryData) return cacheResult;\r\n\r\n    let result = await fetcher(filePath, cacheResult.hashInfo) || { hashInfo: cacheResult.hashInfo };\r\n\r\n    if (result.mimeType && !cacheResult.hashInfo.isInNodeModules) {\r\n      d(`Cache miss: saving out info for ${filePath}`);\r\n      await this.save(cacheResult.hashInfo, result.code || result.binaryData, result.mimeType, result.dependentFiles);\r\n    }\r\n\r\n    result.hashInfo = cacheResult.hashInfo;\r\n    return result;\r\n  }\r\n\r\n  getSync(filePath) {\r\n    d(`Fetching ${filePath} from cache`);\r\n    let hashInfo = this.fileChangeCache.getHashForPathSync(path.resolve(filePath));\r\n\r\n    let code = null;\r\n    let mimeType = null;\r\n    let binaryData = null;\r\n    let dependentFiles = null;\r\n\r\n    try {\r\n      let cacheFile = path.join(this.getCachePath(), hashInfo.hash);\r\n\r\n      let result = null;\r\n      if (hashInfo.isFileBinary) {\r\n        d(\"File is binary, reading out info\");\r\n        let info = JSON.parse(fs.readFileSync(cacheFile + '.info'));\r\n        mimeType = info.mimeType;\r\n        dependentFiles = info.dependentFiles;\r\n\r\n        binaryData = hashInfo.binaryData;\r\n        if (!binaryData) {\r\n          binaryData = fs.readFileSync(cacheFile);\r\n          binaryData = zlib.gunzipSync(binaryData);\r\n        }\r\n      } else {\r\n        let buf = fs.readFileSync(cacheFile);\r\n        let str = (zlib.gunzipSync(buf)).toString('utf8');\r\n\r\n        result = JSON.parse(str);\r\n        code = result.code;\r\n        mimeType = result.mimeType;\r\n        dependentFiles = result.dependentFiles;\r\n      }\r\n    } catch (e) {\r\n      d(`Failed to read cache for ${filePath}`);\r\n    }\r\n\r\n    return { hashInfo, code, mimeType, binaryData, dependentFiles };\r\n  }\r\n\r\n  saveSync(hashInfo, codeOrBinaryData, mimeType, dependentFiles) {\r\n    let buf = null;\r\n    let target = path.join(this.getCachePath(), hashInfo.hash);\r\n    d(`Saving to ${target}`);\r\n\r\n    if (hashInfo.isFileBinary) {\r\n      buf = zlib.gzipSync(codeOrBinaryData);\r\n      fs.writeFileSync(target + '.info', JSON.stringify({mimeType, dependentFiles}), 'utf8');\r\n    } else {\r\n      buf = zlib.gzipSync(new Buffer(JSON.stringify({code: codeOrBinaryData, mimeType, dependentFiles})));\r\n    }\r\n\r\n    fs.writeFileSync(target, buf);\r\n  }\r\n\r\n  getOrFetchSync(filePath, fetcher) {\r\n    let cacheResult = this.getSync(filePath);\r\n    if (cacheResult.code || cacheResult.binaryData) return cacheResult;\r\n\r\n    let result = fetcher(filePath, cacheResult.hashInfo) || { hashInfo: cacheResult.hashInfo };\r\n\r\n    if (result.mimeType && !cacheResult.hashInfo.isInNodeModules) {\r\n      d(`Cache miss: saving out info for ${filePath}`);\r\n      this.saveSync(cacheResult.hashInfo, result.code || result.binaryData, result.mimeType, result.dependentFiles);\r\n    }\r\n\r\n    result.hashInfo = cacheResult.hashInfo;\r\n    return result;\r\n  }\r\n\r\n\r\n  /**\r\n   * @private\r\n   */\r\n  getCachePath() {\r\n    // NB: This is an evil hack so that createFromCompiler can stomp it\r\n    // at will\r\n    return this.cachePath;\r\n  }\r\n\r\n\r\n  /**\r\n   * Returns whether a file should not be compiled. Note that this doesn't\r\n   * necessarily mean it won't end up in the cache, only that its contents are\r\n   * saved verbatim instead of trying to find an appropriate compiler.\r\n   *\r\n   * @param  {Object} hashInfo  The hash information returned from getHashForPath\r\n   *\r\n   * @return {boolean}  True if a file should be ignored\r\n   */\r\n  static shouldPassthrough(hashInfo) {\r\n    return hashInfo.isMinified || hashInfo.isInNodeModules || hashInfo.hasSourceMap || hashInfo.isFileBinary;\r\n  }\r\n}\r\n"]}