babel-loader 7.1.5 → 8.0.0-beta.3

package/README.md

@@ -1,3 +1,6 @@
+> This readme is for babel-loader v8 + Babel v7  
+> Check the [7.x branch](https://github.com/babel/babel-loader/tree/7.x) for docs with Babel v6
+
 [![NPM Status](https://img.shields.io/npm/v/babel-loader.svg?style=flat)](https://www.npmjs.com/package/babel-loader)
 [![Build Status](https://travis-ci.org/babel/babel-loader.svg?branch=master)](https://travis-ci.org/babel/babel-loader)
 [![Build Status](https://ci.appveyor.com/api/projects/status/vgtpr2i5bykgyuqo/branch/master?svg=true)](https://ci.appveyor.com/project/danez/babel-loader/branch/master)
@@ -19,20 +22,16 @@ __Notes:__ Issues with the output should be reported on the babel [issue tracker
 
 <h2 align="center">Install</h2>
 
-> webpack 1.x | babel-loader <= 6.x
->
-> webpack 2.x | babel-loader >= 7.x (recommended) (^6.2.10 will also work, but with deprecation warnings)
->
-> webpack 3.x | babel-loader >= 7.1
+> webpack 3.x | babel-loader 8.x | babel 7.x
 
 ```bash
-yarn add babel-loader babel-core babel-preset-env webpack --dev
+npm install "babel-loader@^8.0.0-beta" @babel/core @babel/preset-env webpack
 ```
 
-We recommend using yarn, but you can also still use npm:
+> webpack 3.x babel-loader 7.x | babel 6.x
 
 ```bash
-npm install --save-dev babel-loader babel-core babel-preset-env webpack
+npm install babel-loader babel-core babel-preset-env webpack
 ```
 
 <h2 align="center">Usage</h2>
@@ -50,7 +49,7 @@ module: {
       use: {
         loader: 'babel-loader',
         options: {
-          presets: ['env']
+          presets: ['@babel/preset-env']
         }
       }
     }
@@ -74,8 +73,8 @@ module: {
       use: {
         loader: 'babel-loader',
         options: {
-          presets: ['env'],
-          plugins: [require('babel-plugin-transform-object-rest-spread')]
+          presets: ['@babel/preset-env'],
+          plugins: [require('@babel/plugin-proposal-object-rest-spread')]
         }
       }
     }
@@ -89,7 +88,8 @@ This loader also supports the following loader-specific option:
 
 * `cacheIdentifier`: Default is a string composed by the babel-core's version, the babel-loader's version, the contents of .babelrc file if it exists and the value of the environment variable `BABEL_ENV` with a fallback to the `NODE_ENV` environment variable. This can be set to a custom value to force cache busting if the identifier changes.
 
-* `forceEnv`: Default will resolve BABEL_ENV then NODE_ENV. Allow you to override BABEL_ENV/NODE_ENV at the loader level. Useful for isomorphic applications with different babel configuration for client and server.
+* `babelrc`: Default `true`. When `false`, no options from `.babelrc` files will be used; only the options passed to
+`babel-loader` will be used.
 
 __Note:__ The `sourceMap` option is ignored, instead sourceMaps are automatically enabled when webpack is configured to use them (via the `devtool` config option).
 
@@ -118,7 +118,7 @@ requiring `babel-plugin-transform-runtime` and making all helper references use
 
 See the [docs](http://babeljs.io/docs/plugins/transform-runtime/) for more information.
 
-**NOTE:** You must run `npm install babel-plugin-transform-runtime --save-dev` to include this in your project and `babel-runtime` itself as a dependency with `npm install babel-runtime --save`.
+**NOTE:** You must run `npm install @babel/plugin-transform-runtime --save-dev` to include this in your project and `babel-runtime` itself as a dependency with `npm install @babel/runtime --save`.
 
 ```javascript
 rules: [
@@ -130,8 +130,8 @@ rules: [
     use: {
       loader: 'babel-loader',
       options: {
-        presets: ['env'],
-        plugins: ['transform-runtime']
+        presets: ['@babel/preset-env'],
+        plugins: ['@babel/plugin-transform-runtime']
       }
     }
   }
@@ -153,7 +153,7 @@ Since [babel-plugin-transform-runtime](https://github.com/babel/babel/tree/maste
 The following approach will not work either:
 
 ```javascript
-require('babel-runtime/core-js/promise').default = require('bluebird');
+require('@babel/runtime/core-js/promise').default = require('bluebird');
 
 var promise = new Promise;
 ```
@@ -163,9 +163,9 @@ which outputs to (using `runtime`):
 ```javascript
 'use strict';
 
-var _Promise = require('babel-runtime/core-js/promise')['default'];
+var _Promise = require('@babel/runtime/core-js/promise')['default'];
 
-require('babel-runtime/core-js/promise')['default'] = require('bluebird');
+require('@babel/runtime/core-js/promise')['default'] = require('bluebird');
 
 var promise = new _Promise();
 ```
@@ -177,7 +177,7 @@ One approach is to have a "bootstrap" step in your application that would first
 ```javascript
 // bootstrap.js
 
-require('babel-runtime/core-js/promise').default = require('bluebird');
+require('@babel/runtime/core-js/promise').default = require('bluebird');
 
 // ...
 
@@ -205,4 +205,80 @@ In the case one of your dependencies is installing `babel` and you cannot uninst
   }
 ```
 
+## Customized Loader
+
+`babel-loader` exposes a loader-builder utility that allows users to add custom handling
+of Babel's configuration for each file that it processes.
+
+`.custom` accepts a callback that will be called with the loader's instance of
+`babel` so that tooling can ensure that it using exactly the same `@babel/core`
+instance as the loader itself.
+
+### Example
+
+```js
+module.exports = require("babel-loader").custom(babel => {
+  function myPlugin() {
+    return {
+      visitor: {},
+    };
+  }
+
+  return {
+    // Passed the loader options.
+    customOptions({ opt1, opt2, ...loader }) {
+      return {
+        // Pull out any custom options that the loader might have.
+        custom: { opt1, opt2 },
+
+        // Pass the options back with the two custom options removed.
+        loader,
+      };
+    },
+
+    // Passed Babel's 'PartialConfig' object. 
+    config(cfg) {
+      if (cfg.hasFilesystemConfig()) {
+        // Use the normal config
+        return cfg.options;
+      }
+
+      return {
+        ...cfg.options,
+        plugins: [
+          ...(cfg.options.plugins || []),
+
+          // Include a custom plugin in the options.
+          myPlugin,
+        ],
+      };
+    },
+
+    result(result) {
+      return {
+        ...result,
+        code: result.code + "\n// Generated by some custom loader",
+      };
+    },
+  };
+});
+```
+
+### `customOptions(options: Object): { custom: Object, loader: Object }`
+
+Given the loader's options, split custom options out of `babel-loader`'s
+options.
+
+
+### `config(cfg: PartialConfig): Object`
+
+Given Babel's `PartialConfig` object, return the `options` object that should
+be passed to `babel.transform`.
+
+
+### `result(result: Result): Result`
+
+Given Babel's result object, allow loaders to make additional tweaks to it.
+
+
 ## [License](http://couto.mit-license.org/)

package/lib/Error.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const STRIP_FILENAME_RE = /^[^:]+: /;
+
+const format = err => {
+  if (err instanceof SyntaxError) {
+    err.name = "SyntaxError";
+    err.message = err.message.replace(STRIP_FILENAME_RE, "");
+    err.hideStack = true;
+  } else if (err instanceof TypeError) {
+    err.name = null;
+    err.message = err.message.replace(STRIP_FILENAME_RE, "");
+    err.hideStack = true;
+  }
+
+  return err;
+};
+
+class LoaderError extends Error {
+  constructor(err) {
+    super();
+    const {
+      name,
+      message,
+      codeFrame,
+      hideStack
+    } = format(err);
+    this.name = "BabelLoaderError";
+    this.message = `${name ? `${name}: ` : ""}${message}\n\n${codeFrame}\n`;
+    this.hideStack = hideStack;
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+}
+
+module.exports = LoaderError;

package/lib/cache.js

@@ -0,0 +1,218 @@
+"use strict";
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); 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 { Promise.resolve(value).then(_next, _throw); } } function _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+
+/**
+ * Filesystem Cache
+ *
+ * Given a file and a transform function, cache the result into files
+ * or retrieve the previously cached files if the given file is already known.
+ *
+ * @see https://github.com/babel/babel-loader/issues/34
+ * @see https://github.com/babel/babel-loader/pull/41
+ */
+const fs = require("fs");
+
+const os = require("os");
+
+const path = require("path");
+
+const zlib = require("zlib");
+
+const crypto = require("crypto");
+
+const mkdirpOrig = require("mkdirp");
+
+const findCacheDir = require("find-cache-dir");
+
+const promisify = require("util.promisify");
+
+const transform = require("./transform"); // Lazily instantiated when needed
+
+
+let defaultCacheDirectory = null;
+const readFile = promisify(fs.readFile);
+const writeFile = promisify(fs.writeFile);
+const gunzip = promisify(zlib.gunzip);
+const gzip = promisify(zlib.gzip);
+const mkdirp = promisify(mkdirpOrig);
+/**
+ * Read the contents from the compressed file.
+ *
+ * @async
+ * @params {String} filename
+ */
+
+const read =
+/*#__PURE__*/
+function () {
+  var _ref = _asyncToGenerator(function* (filename) {
+    const data = yield readFile(filename);
+    const content = yield gunzip(data);
+    return JSON.parse(content);
+  });
+
+  return function read(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Write contents into a compressed file.
+ *
+ * @async
+ * @params {String} filename
+ * @params {String} result
+ */
+
+
+const write =
+/*#__PURE__*/
+function () {
+  var _ref2 = _asyncToGenerator(function* (filename, result) {
+    const content = JSON.stringify(result);
+    const data = yield gzip(content);
+    return yield writeFile(filename, data);
+  });
+
+  return function write(_x2, _x3) {
+    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("SHA1");
+  const contents = JSON.stringify({
+    source,
+    options,
+    identifier
+  });
+  hash.end(contents);
+  return hash.read().toString("hex") + ".json.gz";
+};
+/**
+ * Handle the cache
+ *
+ * @params {String} directory
+ * @params {Object} params
+ */
+
+
+const handleCache =
+/*#__PURE__*/
+function () {
+  var _ref3 = _asyncToGenerator(function* (directory, params) {
+    const {
+      source,
+      options = {},
+      cacheIdentifier,
+      cacheDirectory
+    } = params;
+    const fallback = typeof cacheDirectory !== "string" && directory !== os.tmpdir(); // Make sure the directory exists.
+
+    try {
+      yield mkdirp(directory);
+    } catch (err) {
+      if (fallback) {
+        return handleCache(os.tmpdir(), params);
+      }
+
+      throw err;
+    }
+
+    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);
+    } catch (err) {} // Otherwise just transform the file
+    // return it to the user asap and write it in cache
+
+
+    const result = yield transform(source, options);
+
+    try {
+      yield write(file, 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(_x4, _x5) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Retrieve file from cache, or create a new one for future reads
+ *
+ * @async
+ * @param  {Object}   params
+ * @param  {String}   params.directory  Directory to store cached files
+ * @param  {String}   params.identifier Unique identifier to bust cache
+ * @param  {String}   params.source   Original contents of the file to be cached
+ * @param  {Object}   params.options  Options to be given to the transform fn
+ * @param  {Function} params.transform  Function that will transform the
+ *                                      original file and whose result will be
+ *                                      cached
+ *
+ * @example
+ *
+ *   cache({
+ *     directory: '.tmp/cache',
+ *     identifier: 'babel-loader-cachefile',
+ *     source: *source code from file*,
+ *     options: {
+ *       experimental: true,
+ *       runtime: true
+ *     },
+ *     transform: function(source, options) {
+ *       var content = *do what you need with the source*
+ *       return content;
+ *     }
+ *   }, function(err, result) {
+ *
+ *   });
+ */
+
+
+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 (_x6) {
+    return _ref4.apply(this, arguments);
+  };
+}();

package/lib/index.js

@@ -1,183 +1,149 @@
 "use strict";
 
-var babel = require("babel-core");
-var loaderUtils = require("loader-utils");
-var path = require("path");
-var cache = require("./fs-cache.js");
-var exists = require("./utils/exists");
-var relative = require("./utils/relative");
-var read = require("./utils/read");
-var resolveRc = require("./resolve-rc.js");
-var pkg = require("../package.json");
-var fs = require("fs");
-
-/**
- * Error thrown by Babel formatted to conform to Webpack reporting.
- */
-function BabelLoaderError(name, message, codeFrame, hideStack, error) {
-  Error.call(this);
-
-  this.name = "BabelLoaderError";
-  this.message = formatMessage(name, message, codeFrame);
-  this.hideStack = hideStack;
-  this.error = error;
-
-  Error.captureStackTrace(this, BabelLoaderError);
-}
-
-BabelLoaderError.prototype = Object.create(Error.prototype);
-BabelLoaderError.prototype.constructor = BabelLoaderError;
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); 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 { Promise.resolve(value).then(_next, _throw); } } function _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
 
-var STRIP_FILENAME_RE = /^[^:]+: /;
+const babel = require("@babel/core");
 
-var formatMessage = function formatMessage(name, message, codeFrame) {
-  return (name ? name + ": " : "") + message + "\n\n" + codeFrame + "\n";
-};
+const pkg = require("../package.json");
 
-var transpile = function transpile(source, options) {
-  var forceEnv = options.forceEnv;
-  var tmpEnv = void 0;
+const cache = require("./cache");
 
-  delete options.forceEnv;
+const transform = require("./transform");
 
-  if (forceEnv) {
-    tmpEnv = process.env.BABEL_ENV;
-    process.env.BABEL_ENV = forceEnv;
-  }
+const relative = require("./utils/relative");
 
-  var result = void 0;
-  try {
-    result = babel.transform(source, options);
-  } catch (error) {
-    if (forceEnv) restoreBabelEnv(tmpEnv);
-    if (error.message && error.codeFrame) {
-      var message = error.message;
-      var name = void 0;
-      var hideStack = void 0;
-      if (error instanceof SyntaxError) {
-        message = message.replace(STRIP_FILENAME_RE, "");
-        name = "SyntaxError";
-        hideStack = true;
-      } else if (error instanceof TypeError) {
-        message = message.replace(STRIP_FILENAME_RE, "");
-        hideStack = true;
-      }
-      throw new BabelLoaderError(name, message, error.codeFrame, hideStack, error);
-    } else {
-      throw error;
-    }
-  }
-  var code = result.code;
-  var map = result.map;
-  var metadata = result.metadata;
+const loaderUtils = require("loader-utils");
 
-  if (map && (!map.sourcesContent || !map.sourcesContent.length)) {
-    map.sourcesContent = [source];
+function subscribe(subscriber, metadata, context) {
+  if (context[subscriber]) {
+    context[subscriber](metadata);
   }
+}
 
-  if (forceEnv) restoreBabelEnv(tmpEnv);
+module.exports = makeLoader();
+module.exports.custom = makeLoader;
 
-  return {
-    code: code,
-    map: map,
-    metadata: metadata
+function makeLoader(callback) {
+  const overrides = callback ? callback(babel) : undefined;
+  return function (source, inputSourceMap) {
+    // Make the loader async
+    const callback = this.async();
+    loader.call(this, source, inputSourceMap, overrides).then(args => callback(null, ...args), err => callback(err));
   };
-};
-
-function restoreBabelEnv(prevValue) {
-  if (prevValue === undefined) {
-    delete process.env.BABEL_ENV;
-  } else {
-    process.env.BABEL_ENV = prevValue;
-  }
 }
 
-function passMetadata(s, context, metadata) {
-  if (context[s]) {
-    context[s](metadata);
-  }
+function loader(_x, _x2, _x3) {
+  return _loader.apply(this, arguments);
 }
 
-module.exports = function (source, inputSourceMap) {
-  var _this = this;
+function _loader() {
+  _loader = _asyncToGenerator(function* (source, inputSourceMap, overrides) {
+    const filename = this.resourcePath;
+    let loaderOptions = loaderUtils.getOptions(this) || {};
+    let customOptions;
 
-  var filename = this.resourcePath;
+    if (overrides && overrides.customOptions) {
+      const result = yield overrides.customOptions.call(this, loaderOptions);
+      customOptions = result.custom;
+      loaderOptions = result.loader;
+    } // Deprecation handling
 
-  // Handle options
-  var loaderOptions = loaderUtils.getOptions(this) || {};
-  var fileSystem = this.fs ? this.fs : fs;
-  var babelrcPath = null;
-  if (loaderOptions.babelrc !== false) {
-    babelrcPath = typeof loaderOptions.babelrc === "string" && exists(fileSystem, loaderOptions.babelrc) ? loaderOptions.babelrc : resolveRc(fileSystem, path.dirname(filename));
-  }
 
-  if (babelrcPath) {
-    this.addDependency(babelrcPath);
-  }
+    if ("forceEnv" in loaderOptions) {
+      console.warn("The option `forceEnv` has been removed in favor of `envName` in Babel 7.");
+    }
 
-  var defaultOptions = {
-    metadataSubscribers: [],
-    inputSourceMap: inputSourceMap,
-    sourceRoot: process.cwd(),
-    filename: filename,
-    cacheIdentifier: JSON.stringify({
-      "babel-loader": pkg.version,
-      "babel-core": babel.version,
-      babelrc: babelrcPath ? read(fileSystem, babelrcPath) : null,
-      env: loaderOptions.forceEnv || process.env.BABEL_ENV || process.env.NODE_ENV || "development"
-    })
-  };
+    if (typeof loaderOptions.babelrc === "string") {
+      console.warn("The option `babelrc` should not be set to a string anymore in the babel-loader config. " + "Please update your configuration and set `babelrc` to true or false.\n" + "If you want to specify a specific babel config file to inherit config from " + "please use the `extends` option.\nFor more information about this options see " + "https://babeljs.io/docs/core-packages/#options");
+    } // Set babel-loader's default options.
+
+
+    const {
+      sourceRoot = process.cwd(),
+      sourceMap = this.sourceMap,
+      sourceFileName = relative(sourceRoot, filename)
+    } = loaderOptions;
+    const programmaticOptions = Object.assign({}, loaderOptions, {
+      filename,
+      inputSourceMap: inputSourceMap || undefined,
+      sourceRoot,
+      sourceMap,
+      sourceFileName
+    }); // Remove loader related options
+
+    delete programmaticOptions.cacheDirectory;
+    delete programmaticOptions.cacheIdentifier;
+    delete programmaticOptions.metadataSubscribers;
+
+    if (!babel.loadPartialConfig) {
+      throw new Error(`babel-loader ^8.0.0-beta.3 requires @babel/core@7.0.0-beta.41, but ` + `you appear to be using "${babel.version}". Either update your ` + `@babel/core version, or pin you babel-loader version to 8.0.0-beta.2`);
+    }
 
-  var options = Object.assign({}, defaultOptions, loaderOptions);
+    const config = babel.loadPartialConfig(programmaticOptions);
 
-  if (loaderOptions.sourceMap === undefined) {
-    options.sourceMap = this.sourceMap;
-  }
+    if (config) {
+      let options = config.options;
 
-  if (options.sourceFileName === undefined) {
-    options.sourceFileName = relative(options.sourceRoot, options.filename);
-  }
+      if (overrides && overrides.config) {
+        options = yield overrides.config.call(this, config, {
+          source,
+          customOptions
+        });
+      }
 
-  var cacheDirectory = options.cacheDirectory;
-  var cacheIdentifier = options.cacheIdentifier;
-  var metadataSubscribers = options.metadataSubscribers;
-
-  delete options.cacheDirectory;
-  delete options.cacheIdentifier;
-  delete options.metadataSubscribers;
-
-  if (cacheDirectory) {
-    var callback = this.async();
-    return cache({
-      directory: cacheDirectory,
-      identifier: cacheIdentifier,
-      source: source,
-      options: options,
-      transform: transpile
-    }, function (err) {
-      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-          code = _ref.code,
-          map = _ref.map,
-          metadata = _ref.metadata;
-
-      if (err) return callback(err);
-
-      metadataSubscribers.forEach(function (s) {
-        return passMetadata(s, _this, metadata);
-      });
-
-      return callback(null, code, map);
-    });
-  }
+      const {
+        cacheDirectory = null,
+        cacheIdentifier = JSON.stringify({
+          options,
+          "@babel/core": transform.version,
+          "@babel/loader": pkg.version
+        }),
+        metadataSubscribers = []
+      } = loaderOptions;
+      let result;
+
+      if (cacheDirectory) {
+        result = yield cache({
+          source,
+          options,
+          transform,
+          cacheDirectory,
+          cacheIdentifier
+        });
+      } else {
+        result = yield transform(source, options);
+      } // TODO: Babel should really provide the full list of config files that
+      // were used so that this can also handle files loaded with 'extends'.
+
+
+      if (typeof config.babelrc === "string") {
+        this.addDependency(config.babelrc);
+      }
 
-  var _transpile = transpile(source, options),
-      code = _transpile.code,
-      map = _transpile.map,
-      metadata = _transpile.metadata;
+      if (result) {
+        if (overrides && overrides.result) {
+          result = yield overrides.result.call(this, result, {
+            source,
+            customOptions,
+            config,
+            options
+          });
+        }
+
+        const {
+          code,
+          map,
+          metadata
+        } = result;
+        metadataSubscribers.forEach(subscriber => {
+          subscribe(subscriber, metadata, this);
+        });
+        return [code, map];
+      }
+    } // If the file was ignored, pass through the original content.
 
-  metadataSubscribers.forEach(function (s) {
-    return passMetadata(s, _this, metadata);
-  });
 
-  this.callback(null, code, map);
-};
+    return [source, inputSourceMap];
+  });
+  return _loader.apply(this, arguments);
+}

package/lib/transform.js

@@ -0,0 +1,48 @@
+"use strict";
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); 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 { Promise.resolve(value).then(_next, _throw); } } function _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+
+const babel = require("@babel/core");
+
+const promisify = require("util.promisify");
+
+const LoaderError = require("./Error");
+
+const transform = promisify(babel.transform);
+
+module.exports =
+/*#__PURE__*/
+function () {
+  var _ref = _asyncToGenerator(function* (source, options) {
+    let result;
+
+    try {
+      result = yield transform(source, options);
+    } catch (err) {
+      throw err.message && err.codeFrame ? new LoaderError(err) : err;
+    }
+
+    if (!result) return null;
+    const {
+      code,
+      map,
+      metadata
+    } = result;
+
+    if (map && (!map.sourcesContent || !map.sourcesContent.length)) {
+      map.sourcesContent = [source];
+    }
+
+    return {
+      code,
+      map,
+      metadata
+    };
+  });
+
+  return function (_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+module.exports.version = babel.version;

package/lib/utils/relative.js

@@ -1,15 +1,15 @@
 "use strict";
 
-var path = require("path");
+const path = require("path");
 
-module.exports = function relative(sourceRoot, filename) {
-  var rootPath = sourceRoot.replace(/\\/g, "/").split("/")[1];
-  var fileRootPath = filename.replace(/\\/g, "/").split("/")[1];
+module.exports = function relative(root, file) {
+  const rootPath = root.replace(/\\/g, "/").split("/")[1];
+  const filePath = file.replace(/\\/g, "/").split("/")[1]; // If the file is in a completely different root folder
+  // use the absolute path of the file
 
-  // If the file is in a completely different root folder use the absolute path of file.
-  if (rootPath && rootPath !== fileRootPath) {
-    return filename;
+  if (rootPath && rootPath !== filePath) {
+    return file;
   }
 
-  return path.relative(sourceRoot, filename);
+  return path.relative(root, file);
 };

package/package.json

@@ -1,39 +1,39 @@
 {
   "name": "babel-loader",
-  "version": "7.1.5",
+  "version": "8.0.0-beta.3",
   "description": "babel module loader for webpack",
   "files": [
     "lib"
   ],
   "main": "lib/index.js",
   "engines": {
-    "node": ">=4"
+    "node": ">= 6.9"
   },
   "dependencies": {
     "find-cache-dir": "^1.0.0",
     "loader-utils": "^1.0.2",
-    "mkdirp": "^0.5.1"
+    "mkdirp": "^0.5.1",
+    "util.promisify": "^1.0.0"
   },
   "peerDependencies": {
-    "babel-core": "6",
-    "webpack": "2 || 3 || 4"
+    "@babel/core": "^7.0.0 || ^7.0.0-rc || ^7.0.0-beta.41",
+    "webpack": ">=2"
   },
   "devDependencies": {
-    "ava": "^0.23.0",
-    "babel-cli": "^6.18.0",
-    "babel-core": "^6.0.0",
+    "@babel/cli": "^7.0.0-beta.41",
+    "@babel/core": "^7.0.0-beta.41",
+    "@babel/preset-env": "^7.0.0-beta.41",
+    "ava": "0.25.0",
     "babel-eslint": "^8.0.0",
     "babel-plugin-istanbul": "^4.0.0",
     "babel-plugin-react-intl": "^2.1.3",
-    "babel-preset-env": "^1.2.0",
-    "babel-register": "^6.18.0",
     "cross-env": "^5.0.0",
     "eslint": "^4.1.0",
     "eslint-config-babel": "^7.0.0",
     "eslint-plugin-flowtype": "^2.25.0",
     "eslint-plugin-prettier": "^2.1.2",
     "husky": "^0.14.0",
-    "lint-staged": "^4.0.0",
+    "lint-staged": "^7.1.0",
     "nyc": "^11.0.1",
     "prettier": "^1.2.2",
     "react": "^16.0.0",
@@ -45,7 +45,7 @@
   "scripts": {
     "clean": "rimraf lib/",
     "build": "babel src/ --out-dir lib/",
-    "format": "prettier --write --trailing-comma all \"src/**/*.js\" \"test/**/*.test.js\" \"test/helpers/*.js\" && prettier --write --trailing-comma es5 \"scripts/*.js\"",
+    "format": "prettier --write --trailing-comma all 'src/**/*.js' 'test/**/*.test.js' 'test/helpers/*.js' && prettier --write --trailing-comma es5 'scripts/*.js'",
     "lint": "eslint src test",
     "precommit": "lint-staged",
     "prepublish": "yarn run clean && yarn run build",
@@ -80,9 +80,6 @@
       "text",
       "json"
     ],
-    "require": [
-      "babel-register"
-    ],
     "sourceMap": false,
     "instrument": false
   },
@@ -94,8 +91,7 @@
     ],
     "source": [
       "src/**/*.js"
-    ],
-    "babel": "inherit"
+    ]
   },
   "lint-staged": {
     "scripts/*.js": [

package/lib/fs-cache.js

@@ -1,180 +0,0 @@
-"use strict";
-
-/**
- * Filesystem cache
- *
- * Given a file and a transform function, cache the result into files
- * or retrieve the previously cached files if the given file is already known.
- *
- * @see https://github.com/babel/babel-loader/issues/34
- * @see https://github.com/babel/babel-loader/pull/41
- */
-var crypto = require("crypto");
-var mkdirp = require("mkdirp");
-var findCacheDir = require("find-cache-dir");
-var fs = require("fs");
-var os = require("os");
-var path = require("path");
-var zlib = require("zlib");
-
-var defaultCacheDirectory = null; // Lazily instantiated when needed
-
-/**
- * Read the contents from the compressed file.
- *
- * @async
- * @params {String} filename
- * @params {Function} callback
- */
-var read = function read(filename, callback) {
-  return fs.readFile(filename, function (err, data) {
-    if (err) return callback(err);
-
-    return zlib.gunzip(data, function (err, content) {
-      if (err) return callback(err);
-
-      var result = {};
-
-      try {
-        result = JSON.parse(content);
-      } catch (e) {
-        return callback(e);
-      }
-
-      return callback(null, result);
-    });
-  });
-};
-
-/**
- * Write contents into a compressed file.
- *
- * @async
- * @params {String} filename
- * @params {String} result
- * @params {Function} callback
- */
-var write = function write(filename, result, callback) {
-  var content = JSON.stringify(result);
-
-  return zlib.gzip(content, function (err, data) {
-    if (err) return callback(err);
-
-    return fs.writeFile(filename, data, callback);
-  });
-};
-
-/**
- * Build the filename for the cached file
- *
- * @params {String} source  File source code
- * @params {Object} options Options used
- *
- * @return {String}
- */
-var filename = function filename(source, identifier, options) {
-  var hash = crypto.createHash("md4");
-  var contents = JSON.stringify({
-    source: source,
-    options: options,
-    identifier: identifier
-  });
-
-  hash.update(contents);
-
-  return hash.digest("hex") + ".json.gz";
-};
-
-/**
- * Handle the cache
- *
- * @params {String} directory
- * @params {Object} params
- * @params {Function} callback
- */
-var handleCache = function handleCache(directory, params, callback) {
-  var source = params.source;
-  var options = params.options || {};
-  var transform = params.transform;
-  var identifier = params.identifier;
-  var shouldFallback = typeof params.directory !== "string" && directory !== os.tmpdir();
-
-  // Make sure the directory exists.
-  mkdirp(directory, function (err) {
-    // Fallback to tmpdir if node_modules folder not writable
-    if (err) return shouldFallback ? handleCache(os.tmpdir(), params, callback) : callback(err);
-
-    var file = path.join(directory, filename(source, identifier, options));
-
-    return read(file, function (err, content) {
-      var result = {};
-      // No errors mean that the file was previously cached
-      // we just need to return it
-      if (!err) return callback(null, content);
-
-      // Otherwise just transform the file
-      // return it to the user asap and write it in cache
-      try {
-        result = transform(source, options);
-      } catch (error) {
-        return callback(error);
-      }
-
-      return write(file, result, function (err) {
-        // Fallback to tmpdir if node_modules folder not writable
-        if (err) return shouldFallback ? handleCache(os.tmpdir(), params, callback) : callback(err);
-
-        callback(null, result);
-      });
-    });
-  });
-};
-
-/**
- * Retrieve file from cache, or create a new one for future reads
- *
- * @async
- * @param  {Object}   params
- * @param  {String}   params.directory  Directory to store cached files
- * @param  {String}   params.identifier Unique identifier to bust cache
- * @param  {String}   params.source   Original contents of the file to be cached
- * @param  {Object}   params.options  Options to be given to the transform fn
- * @param  {Function} params.transform  Function that will transform the
- *                                      original file and whose result will be
- *                                      cached
- *
- * @param  {Function<err, result>} callback
- *
- * @example
- *
- *   cache({
- *     directory: '.tmp/cache',
- *     identifier: 'babel-loader-cachefile',
- *     source: *source code from file*,
- *     options: {
- *       experimental: true,
- *       runtime: true
- *     },
- *     transform: function(source, options) {
- *       var content = *do what you need with the source*
- *       return content;
- *     }
- *   }, function(err, result) {
- *
- *   });
- */
-
-module.exports = function (params, callback) {
-  var directory = void 0;
-
-  if (typeof params.directory === "string") {
-    directory = params.directory;
-  } else {
-    if (defaultCacheDirectory === null) {
-      defaultCacheDirectory = findCacheDir({ name: "babel-loader" }) || os.tmpdir();
-    }
-    directory = defaultCacheDirectory;
-  }
-
-  handleCache(directory, params, callback);
-};

package/lib/resolve-rc.js

@@ -1,26 +0,0 @@
-"use strict";
-
-var path = require("path");
-var exists = require("./utils/exists");
-
-module.exports = function find(fileSystem, start) {
-  var _arr = [".babelrc", "package.json"];
-
-  for (var _i = 0; _i < _arr.length; _i++) {
-    var fileName = _arr[_i];
-    var file = path.join(start, fileName);
-
-    if (exists(fileSystem, file)) {
-      if (fileName !== "package.json" || typeof require(file).babel === "object") {
-        return file;
-      }
-    }
-  }
-
-  var up = path.dirname(start);
-
-  // Reached root
-  if (up !== start) {
-    return find(fileSystem, up);
-  }
-};

package/lib/utils/exists.js

@@ -1,13 +0,0 @@
-"use strict";
-
-module.exports = function (fileSystem, filename) {
-  var exists = false;
-
-  try {
-    exists = fileSystem.statSync(filename).isFile();
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-
-  return exists;
-};

package/lib/utils/read.js

@@ -1,14 +0,0 @@
-"use strict";
-
-var path = require("path");
-
-module.exports = function readBabelConfig(fileSystem, filename) {
-  if (path.basename(filename) === "package.json") {
-    var pkg = require(filename);
-
-    return JSON.stringify(pkg.babel);
-  }
-
-  // Webpack `fs` return Buffer
-  return fileSystem.readFileSync(filename).toString("utf8");
-};