babel-plugin-defer

A Babel plugin that transpiles defer statements to JavaScript, bringing Go-like defer functionality to JavaScript/TypeScript applications.

Overview

babel-plugin-defer is a Babel transpiler plugin that enables developers to use defer statements in JavaScript and TypeScript, similar to the defer mechanism found in languages like Go and V. The plugin automatically transpiles defer calls into proper JavaScript code that executes cleanup functions at the end of the current scope.

1import { defer } from 'babel-plugin-defer/runtime'
2
3function processFile(filename) {
4    const file = fs.openSync(filename)
5    defer(() => fs.closeSync(file)) // Transpiled to proper cleanup
6    
7    // Process file...
8    // file.close() will be called automatically
9}

What is defer?

The defer statement is a powerful control flow mechanism that schedules a function call to be executed when the surrounding function returns. This pattern is commonly used for:

• Resource cleanup: Closing files, database connections, or network sockets
• Lock management: Releasing mutexes or semaphores
• Logging: Recording function exit points
• Error handling: Ensuring cleanup code runs even when errors occur

defer in other languages

Go:

1func processFile(filename string) error {
2    file, err := os.Open(filename)
3    if err != nil {
4        return err
5    }
6    defer file.Close() // Will be called when function returns
7    
8    // Process file...
9    return nil
10}

V:

1fn process_file(filename string) ! {
2    mut file := os.open(filename)!
3    defer { file.close() } // Cleanup guaranteed
4    
5    // Process file...
6}

Installation

Install the package and the peer dependency:

1npm install babel-plugin-defer
2npm install --save-dev @babel/core

Visit the examples folder for more examples.

Usage

Import the functions you need from the runtime package:

1import { defer } from 'babel-plugin-defer/runtime'
2
3function example() {
4  const resource = acquireResource()
5  defer(() => resource.cleanup()) // Will be transpiled to try/finally
6  
7  // Your code here...
8  // cleanup() will be called automatically when function exits
9}

[!NOTE] When using the Babel plugin, these function calls are transpiled at build time into optimized JavaScript code. The runtime functions serve as fallbacks for environments where Babel is not configured.

How it works

The plugin transforms defer statements during the build process:

Input:

1function processData() {
2  const conn = database.connect()
3  defer(() => conn.close()) // or simply defer(conn.close)
4
5  const file = filesystem.open('path/to/file.txt')
6  defer(() => file.close()) // or simply defer(file.close)
7  
8  const data = conn.query('SELECT * FROM users')
9  return data
10}

Output (transpiled):

1function processData() {
2  const _defers = [];
3  try {
4    const conn = database.connect();
5    _defers.push(() => conn.close());
6
7    const file = filesystem.open('path/to/file.txt');
8    _defers.push(() => file.close());
9
10    const data = conn.query('SELECT * FROM users');
11    return data;
12  } finally {
13    // Closes the resources in reverse order
14    for (let i = _defers.length - 1; i >= 0; i--) {
15      try {
16        _defers[i]();
17      } catch (e) {
18        console.log(e);
19      }
20    }
21  }
22}

API Reference

defer(fn: () => void): void

Schedules a function to be executed when the current function scope exits.

Parameters:

• fn: A function to be called during cleanup

Example:

1function handleRequest() {
2  const startTime = Date.now()
3  defer(() => console.log(`Request took ${Date.now() - startTime}ms`))
4  
5  // Handle request...
6}

TypeScript Support

The plugin includes full TypeScript support with global type declarations. The defer function is automatically available in your TypeScript files without additional imports.

Development

1# Clone the repository
2git clone https://github.com/your-username/babel-plugin-defer.git
3cd babel-plugin-defer
4
5# Install dependencies
6npm install
7
8# Build the plugin
9npm run build
10
11# Run tests
12npm test
13
14# Run with watch mode
15npm run test:watch
16
17# Lint code
18npm run lint
19
20# Prepare for publishing
21npm run prepublishOnly

Contributing

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

License

MIT © Your Name

Changelog

See CHANGELOG.md for a detailed history of changes.

Support

If this package is helpful to you, please consider:

• ⭐ Starring the repository
• 🐛 Reporting issues
• 💡 Suggesting new features
• 🔗 Sharing with others