The problem

Check out this guest post on the Babel.js blog for a complete write up on the problem, motivation, and solution.

Currently, each babel plugin in the babel ecosystem requires that you configure it individually. This is fine for things like language features, but can be frustrating overhead for libraries that allow for compile-time code transformation as an optimization.

This solution

babel-plugin-macros defines a standard interface for libraries that want to use compile-time code transformation without requiring the user to add a babel plugin to their build system (other than babel-plugin-macros, which is ideally already in place).

1const styles = css`
2  .red {
3    color: red;
4  }
5`

1console.log(styles) // { red: "1f-d34j8rn43y587t" }

1// Before running through babel:
2const styles = css`
3  .red {
4    color: red;
5  }
6`
7// After running through babel, with the library-specific plugin:
8const styles = {red: '1f-d34j8rn43y587t'}

Table of Contents

• Installation
• Usage
  • User docs
  • Author docs
  • Caveats
• FAQ
  • How do I find available macros?
  • What's the difference between babel plugins and macros?
  • In what order are macros executed?
  • Does it work with function calls only?
  • How about implicit optimizations at compile time?
• Inspiration
• Other Solutions
• Issues
  • 🐛 Bugs
  • 💡 Feature Requests
• Contributors ✨
• LICENSE

Installation

This module is distributed via npm which is bundled with node and should be installed as one of your project's devDependencies:

npm install --save-dev babel-plugin-macros

Usage

You may like to watch this YouTube video to get an idea of what macros is and how it can be used.

User docs

Are you trying to use babel-plugin-macros? Go to other/docs/user.md.

Author docs

Are you trying to make your own macros that works with babel-plugin-macros? Go to other/docs/author.md. (you should probably read the user docs too).

Caveats

Babel cache problem

Note: This issue is not present when used in Create React App.

Most of the time you'll probably be using this with the babel cache enabled in webpack to rebuild faster. If your macro function is not pure which gets different output with same code (e.g., IO side effects) it will cause recompile mechanism fail. Unfortunately you'll also experience this problem while developing your macro as well. If there's not a change to the source code that's being transpiled, then babel will use the cache rather than running your macro again.

For now, to force recompile the code you can simply add a cache busting comment in the file:

1import macro from 'non-pure.macro';
2
3-// Do some changes of your code or
4+// add a cache busting comment to force recompile.
5macro('parameters');

This problem is still being worked on and is not unique to babel-plugin-macros. For more details and workarounds, please check related issues below:

• babel-plugin-preval: How to force recompile? #19
• graphql.macro: Recompile problem (babel cache) #6
• twin.macro: Can't change taliwind config #37

FAQ

How do I find available macros?

You can write your own without publishing them to npm, but if you'd like to see existing macros you can add to your project, then take a look at the Awesome babel macros repository.

Please add any you don't see listed!

What's the difference between babel plugins and macros?

Let's use babel-plugin-console as an example.

If we used babel-plugin-console, it would look like this:

1. Add babel-plugin-console to .babelrc
2. Use it in a code:

1function add100(a) {
2  const oneHundred = 100
3  console.scope('Add 100 to another number')
4  return add(a, oneHundred)
5}
6
7function add(a, b) {
8  return a + b
9}

When that code is run, the scope function does some pretty nifty things:

Browser:

Node:

Instead, let's use the macro it's shipped with like this:

1. Add babel-plugin-macros to .babelrc (only once for all macros)
2. Use it in a code:

1import scope from 'babel-plugin-console/scope.macro'
2function add100(a) {
3  const oneHundred = 100
4  scope('Add 100 to another number')
5  return add(a, oneHundred)
6}
7
8function add(a, b) {
9  return a + b
10}

The result is exactly the same, but this approach has a few advantages:

Advantages:

• requires only one entry in .babelrc for all macros used in project. Add that once and you can use all the macros you want
• toolkits (like create-react-app) may already support babel-plugin-macros, so no configuration is needed at all
• it's explicit. With console.scope people may be fooled that it's just a normal console API when there's really a babel transpilation going on. When you import scope, it's obvious that it's macro and does something with the code at compile time. Some ESLint rules may also have issues with plugins that look for "global" variables
• macros are safer and easier to write, because they receive exactly the AST node to process
• If you misconfigure babel-plugin-console you wont find out until you run the code. If you misconfigure babel-plugin-macros you'll get a compile-time error.

Drawbacks:

• Cannot (should not) be used for implicit transpilations (like syntax plugins)
• Explicitness is more verbose. Which some people might consider a drawback...

In what order are macros executed?

This is another advantage of babel-plugin-macros over regular plugins. The user of the macro is in control of the ordering! The order of execution is the same order as imported. The order of execution is clear, explicit and in full control of the user:

1import preval from 'preval.macro'
2import idx from 'idx.macro'
3
4// preval macro is evaluated first, then idx

This differs from the current situation with babel plugins where it's prohibitively difficult to control the order plugins run in a particular file.

Does it work with function calls only?

No! Any AST node type is supported.

It can be tagged template literal:

1import eval from 'eval.macro'
2const val = eval`7 * 6`

A function:

1import eval from 'eval.macro'
2const val = eval('7 * 6')

JSX Element:

1import Eval from 'eval.macro'
2const val = <Eval>7 * 6</Eval>

Really, anything...

See the testing snapshot for more examples.

How about implicit optimizations at compile time?

All examples above were explicit - a macro was imported and then evaluated with a specific AST node.

Completely different story are implicit babel plugins, like transform-react-constant-elements, which process whole AST tree.

Explicit is often a better pattern than implicit because it requires others to understand how things are globally configured. This is in this spirit are babel-plugin-macros designed. However, some things do need to be implicit, and those kinds of babel plugins can't be turned into macros.

Inspiration

• threepointone/babel-plugin-macros
• facebookincubator/create-react-app#2730

Thank you to @phpnode for donating the npm package babel-plugin-macros.

Other Solutions

• sweetjs

Issues

Looking to contribute? Look for the Good First Issue label.

🐛 Bugs

Please file an issue for bugs, missing documentation, or unexpected behavior.

See Bugs

💡 Feature Requests

Please file an issue to suggest new features. Vote on feature requests by adding a 👍. This helps maintainers prioritize what to work on.

See Feature Requests

Contributors ✨

Thanks goes to these people (emoji key):

Kent C. Dodds 💻 📖 🚇 ⚠️	Sunil Pai 🤔	Lily Scott 💬 📖	Michiel Dral 🤔	Kye Hohenberger 🤔	Mitchell Hamilton 💻 ⚠️	Justin Hall 📖
Brian Pedersen 💻 📖	Andrew Palm 💻	Michael Hsu 📖 🔌	Bo Lingen 💻	Tyler Haas 📖	FWeinb 💻	Tomáš Ehrlich 🐛 💻
Jonas Gierer 📖	Loïc Padier 💻	Paul Sherman 💻	Conrad Buck 💻 ⚠️ 📖	InvictusMB ⚠️	Eric Berry 🔍	Futago-za Ryuu 💻 ⚠️
Luc 💻	Victor Vincent 💻	я котик пур-пур 📖	Armando Sosa 📖	Matthias 💻	Jovi De Croock 💻 ⚠️	Victor Arowo 📖
Alex Chan 📖	Evan Jacobs 💻

This project follows the all-contributors specification. Contributions of any kind welcome!

LICENSE

MIT