@wxa/compiler-babel/dist/fs-cache.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = _default;

var _crypto = _interopRequireDefault(require("crypto"));

var _mkdirp = _interopRequireDefault(require("mkdirp"));

var _findCacheDir = _interopRequireDefault(require("find-cache-dir"));

var _fs = _interopRequireDefault(require("fs"));

var _os = _interopRequireDefault(require("os"));

var _path = _interopRequireDefault(require("path"));

var _zlib = _interopRequireDefault(require("zlib"));

var _debug = _interopRequireDefault(require("debug"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * https://github.com/babel/babel-loader/blob/master/src/fs-cache.js
 * fs-cache promise版本
 */
let $logger = (0, _debug.default)('fs-cache');

const read = filename => {
  return new Promise((resolve, reject) => {
    _fs.default.readFile(filename, (err, ret) => {
      if (err) reject(err);

      _zlib.default.gunzip(ret, (err, content) => {
        if (err) reject(err);
        let result = {};

        try {
          result = JSON.parse(content);
        } catch (e) {
          reject(e);
        }

        return resolve(result);
      });
    });
  });
};

const write = (filename, content) => {
  return new Promise((resolve, reject) => {
    let result;
    let tmp = [];
    result = JSON.stringify(content, (key, value) => {
      if (typeof value === 'object' && value !== null && tmp.indexOf(value) !== -1) return;
      tmp.push(value);
      return value;
    });

    _zlib.default.gzip(result, (err, data) => {
      if (err) reject(err);

      _fs.default.writeFile(filename, data, (err, data) => {
        if (err) reject(err);
        resolve();
      });
    });
  });
};

const filename = (source, identifier, options) => {
  const hash = _crypto.default.createHash('SHA1');

  const content = JSON.stringify({
    source,
    identifier,
    options
  });
  hash.end(content);
  return hash.read().toString('hex') + '.json.gz';
};

const handleCache = (directory, params) => {
  return new Promise((resolve, reject) => {
    const {
      source,
      options = {},
      transform,
      identifier
    } = params;

    const shouldFallback = typeof params.directory !== 'string' && directory !== _os.default.tmpdir();

    (0, _mkdirp.default)(directory, err => {
      if (err) shouldFallback ? handleCache(_os.default.tmpdir(), params) : reject(err);

      const file = _path.default.join(directory, filename(source, identifier, options));

      read(file).then(succ => {
        // cached file
        resolve(succ);
      }, fail => {
        // transform source
        try {
          params.transform(source, options).then(ret => {
            write(file, ret).then(succ => {
              resolve(ret);
            }, fail => {
              if (!shouldFallback) {
                reject(fail);
              } else {
                handleCache(_os.default.tmpdir(), params).then(resolve, reject);
              }
            });
          }, err => reject(err));
        } catch (e) {
          reject(e);
        }
      });
    });
  });
};

function _default(params) {
  let {
    directory
  } = params;

  if (typeof directory !== 'string') {
    directory = (0, _findCacheDir.default)({
      name: '@wxa/compiler-babel'
    }) || _os.default.tmpdir();
  }

  return handleCache(directory, params);
}