babel-loader

What is babel-loader?

The babel-loader npm package is a Webpack plugin that integrates Babel with Webpack. Babel is a JavaScript compiler that allows you to use next-generation JavaScript, today. It compiles ES6 and beyond into ES5 code that can run in current browser environments. babel-loader enables Webpack to process and bundle JavaScript files using Babel.

What are babel-loader's main functionalities?

Transpiling ES6+ to ES5

This feature allows developers to write modern JavaScript code without worrying about compatibility issues with older browsers. The code sample shows a Webpack configuration that uses babel-loader to process files ending in .js, excluding node_modules, and transpiles them using the preset '@babel/preset-env'.

module.exports = {
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: {
          loader: 'babel-loader',
          options: {
            presets: ['@babel/preset-env']
          }
        }
      }
    ]
  }
};

Using Babel plugins

babel-loader can be configured to use specific Babel plugins to enable experimental features or custom transformations. The code sample demonstrates how to include the '@babel/plugin-proposal-class-properties' plugin to allow the use of class properties syntax in JavaScript.

module.exports = {
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: {
          loader: 'babel-loader',
          options: {
            plugins: ['@babel/plugin-proposal-class-properties']
          }
        }
      }
    ]
  }
};

Source Maps support

babel-loader supports source maps, which help in debugging transpiled code by mapping the transformed code back to the original source code. The code sample shows how to enable source maps in the babel-loader options.

module.exports = {
  module: {
    rules: [
      {
        test: /\.js$/,
        use: {
          loader: 'babel-loader',
          options: {
            sourceMaps: true
          }
        }
      }
    ]
  }
};

Other packages similar to babel-loader

ts-loader

ts-loader is a Webpack loader for TypeScript, similar to how babel-loader works for JavaScript. It compiles TypeScript code to JavaScript, allowing developers to use TypeScript's static typing features. While babel-loader focuses on JavaScript and its newer syntax, ts-loader is specifically designed for TypeScript.

awesome-typescript-loader

awesome-typescript-loader is another Webpack loader for TypeScript, providing similar functionality to ts-loader. It also compiles TypeScript to JavaScript and offers features like Babel integration and type checking. It is known for being fast and providing a smoother integration with Babel compared to ts-loader.

esbuild-loader

esbuild-loader is a Webpack loader that uses the esbuild bundler. It is designed for extremely fast bundling and minifying of JavaScript and TypeScript code. Unlike babel-loader, which focuses on compatibility and syntax transformations, esbuild-loader emphasizes performance and speed.

README

Babel Loader

This package allows transpiling JavaScript files using Babel and webpack.

Notes: Issues with the output should be reported on the babel issue tracker;

Install

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)

yarn add babel-loader babel-core babel-preset-env webpack --dev

We recommend using yarn, but you can also still use npm:

npm install --save-dev babel-loader babel-core babel-preset-env webpack

Usage

Documentation: Using loaders

Within your webpack configuration object, you'll need to add the babel-loader to the list of modules, like so:

module: {
  rules: [
    {
      test: /\.js$/,
      exclude: /(node_modules|bower_components)/,
      use: {
        loader: 'babel-loader',
        options: {
          presets: ['env']
        }
      }
    }
  ]
}

Options

See the babel options.

You can pass options to the loader by using the options property:

module: {
  rules: [
    {
      test: /\.js$/,
      exclude: /(node_modules|bower_components)/,
      use: {
        loader: 'babel-loader',
        options: {
          presets: ['env'],
          plugins: [require('babel-plugin-transform-object-rest-spread')]
        }
      }
    }
  ]
}

This loader also supports the following loader-specific option:

• cacheDirectory: Default false. When set, the given directory will be used to cache the results of the loader. Future webpack builds will attempt to read from the cache to avoid needing to run the potentially expensive Babel recompilation process on each run. If the value is blank (loader: 'babel-loader?cacheDirectory') or true (loader: babel-loader?cacheDirectory=true) the loader will use the default cache directory in node_modules/.cache/babel-loader or fallback to the default OS temporary file directory if no node_modules folder could be found in any root directory.

• 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.

Note: The sourceMap option is ignored, instead sourceMaps are automatically enabled when webpack is configured to use them (via the devtool config option).

Troubleshooting

babel-loader is slow!

Make sure you are transforming as few files as possible. Because you are probably matching /\.js$/, you might be transforming the node_modules folder or other unwanted source.

To exclude node_modules, see the exclude option in the loaders config as documented above.

You can also speed up babel-loader by as much as 2x by using the cacheDirectory option. This will cache transformations to the filesystem.

babel is injecting helpers into each file and bloating my code!

babel uses very small helpers for common functions such as _extend. By default this will be added to every file that requires it.

You can instead require the babel runtime as a separate module to avoid the duplication.

The following configuration disables automatic per-file runtime injection in babel, instead requiring babel-plugin-transform-runtime and making all helper references use it.

See the docs 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.

rules: [
  // the 'transform-runtime' plugin tells babel to require the runtime
  // instead of inlining it.
  {
    test: /\.js$/,
    exclude: /(node_modules|bower_components)/,
    use: {
      loader: 'babel-loader',
      options: {
        presets: ['env'],
        plugins: ['transform-runtime']
      }
    }
  }
]

NOTE: transform-runtime & custom polyfills (e.g. Promise library)

Since babel-plugin-transform-runtime includes a polyfill that includes a custom regenerator runtime and core.js, the following usual shimming method using webpack.ProvidePlugin will not work:

// ...
        new webpack.ProvidePlugin({
            'Promise': 'bluebird'
        }),
// ...

The following approach will not work either:

require('babel-runtime/core-js/promise').default = require('bluebird');

var promise = new Promise;

which outputs to (using runtime):

'use strict';

var _Promise = require('babel-runtime/core-js/promise')['default'];

require('babel-runtime/core-js/promise')['default'] = require('bluebird');

var promise = new _Promise();

The previous Promise library is referenced and used before it is overridden.

One approach is to have a "bootstrap" step in your application that would first override the default globals before your application:

// bootstrap.js

require('babel-runtime/core-js/promise').default = require('bluebird');

// ...

require('./app');

The node API for babel has been moved to babel-core.

If you receive this message it means that you have the npm package babel installed and use the short notation of the loader in the webpack config (which is not valid anymore as of webpack 2.x):

  {
    test: /\.js$/,
    loader: 'babel',
  }

Webpack then tries to load the babel package instead of the babel-loader.

To fix this you should uninstall the npm package babel as it is deprecated in babel v6. (instead install babel-cli or babel-core) In the case one of your dependencies is installing babel and you cannot uninstall it yourself, use the complete name of the loader in the webpack config:

  {
    test: /\.js$/,
    loader: 'babel-loader',
  }

License