File Manager

Editing File: /home/ubuntu/voice-assistant-frontend/node_modules/babel-loader/lib/cache.js

"use strict";

/**
 * Read the contents from the compressed file.
 *
 * @async
 * @params {String} filename
 * @params {Boolean} compress
 */
const read = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator(function* (filename, compress) {
    const data = yield readFile(filename + (compress ? ".gz" : ""));
    const content = compress ? yield gunzip(data) : data;
    return JSON.parse(content.toString());
  });
  return function read(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();

/**
 * Write contents into a compressed file.
 *
 * @async
 * @params {String} filename
 * @params {Boolean} compress
 * @params {String} result
 */
const write = /*#__PURE__*/function () {
  var _ref2 = _asyncToGenerator(function* (filename, compress, result) {
    const content = JSON.stringify(result);
    const data = compress ? yield gzip(content) : content;
    return yield writeFile(filename + (compress ? ".gz" : ""), data);
  });
  return function write(_x3, _x4, _x5) {
    return _ref2.apply(this, arguments);
  };
}();

/**
 * Build the filename for the cached file
 *
 * @params {String} source  File source code
 * @params {Object} options Options used
 *
 * @return {String}
 */
const filename = function (source, identifier, options) {
  const hash = crypto.createHash(hashType);
  const contents = JSON.stringify({
    source,
    options,
    identifier
  });
  hash.update(contents);
  return hash.digest("hex") + ".json";
};

/**
 * Handle the cache
 *
 * @params {String} directory
 * @params {Object} params
 */
const handleCache = /*#__PURE__*/function () {
  var _ref3 = _asyncToGenerator(function* (directory, params) {
    const {
      source,
      options = {},
      cacheIdentifier,
      cacheDirectory,
      cacheCompression
    } = params;
    const file = path.join(directory, filename(source, cacheIdentifier, options));
    try {
      // No errors mean that the file was previously cached
      // we just need to return it
      return yield read(file, cacheCompression);
    } catch (err) {}
    const fallback = typeof cacheDirectory !== "string" && directory !== os.tmpdir();

// Make sure the directory exists.
    try {
      yield makeDir(directory);
    } catch (err) {
      if (fallback) {
        return handleCache(os.tmpdir(), params);
      }
      throw err;
    }

// Otherwise just transform the file
    // return it to the user asap and write it in cache
    const result = yield transform(source, options);

// Do not cache if there are external dependencies,
    // since they might change and we cannot control it.
    if (!result.externalDependencies.length) {
      try {
        yield write(file, cacheCompression, result);
      } catch (err) {
        if (fallback) {
          // Fallback to tmpdir if node_modules folder not writable
          return handleCache(os.tmpdir(), params);
        }
        throw err;
      }
    }
    return result;
  });
  return function handleCache(_x6, _x7) {
    return _ref3.apply(this, arguments);
  };
}();

/**
 * Retrieve file from cache, or create a new one for future reads
 *
 * @async
 * @param  {Object}   params
 * @param  {String}   params.cacheDirectory   Directory to store cached files
 * @param  {String}   params.cacheIdentifier  Unique identifier to bust cache
 * @param  {Boolean}  params.cacheCompression Whether compressing cached files
 * @param  {String}   params.source   Original contents of the file to be cached
 * @param  {Object}   params.options  Options to be given to the transform fn
 *
 * @example
 *
 *   const result = await cache({
 *     cacheDirectory: '.tmp/cache',
 *     cacheIdentifier: 'babel-loader-cachefile',
 *     cacheCompression: false,
 *     source: *source code from file*,
 *     options: {
 *       experimental: true,
 *       runtime: true
 *     },
 *   });
 */

module.exports = /*#__PURE__*/function () {
  var _ref4 = _asyncToGenerator(function* (params) {
    let directory;
    if (typeof params.cacheDirectory === "string") {
      directory = params.cacheDirectory;
    } else {
      if (defaultCacheDirectory === null) {
        defaultCacheDirectory = findCacheDir({
          name: "babel-loader"
        }) || os.tmpdir();
      }
      directory = defaultCacheDirectory;
    }
    return yield handleCache(directory, params);
  });
  return function (_x8) {
    return _ref4.apply(this, arguments);
  };
}();

Back to Directory File Manager