@rollup/plugin-terser

@rollup/plugin-terser is a Rollup plugin that provides JavaScript code minification using the Terser minifier. It integrates seamlessly with Rollup's build pipeline to generate optimized, minified bundles with optional multi-threading support for improved build performance.

Package Information

• Package Name: @rollup/plugin-terser
• Package Type: npm
• Language: TypeScript
• Installation: npm install @rollup/plugin-terser --save-dev

Core Imports

import terser from '@rollup/plugin-terser';

For CommonJS:

const terser = require('@rollup/plugin-terser');

Basic Usage

import terser from '@rollup/plugin-terser';

export default {
  input: 'src/index.js',
  output: {
    dir: 'output',
    format: 'cjs'
  },
  plugins: [terser()]
};

With configuration options:

import terser from '@rollup/plugin-terser';

export default {
  input: 'src/index.js',
  output: {
    dir: 'output',
    format: 'cjs'
  },
  plugins: [
    terser({
      compress: {
        drop_console: true
      },
      mangle: {
        reserved: ['MyClass']
      },
      maxWorkers: 4,
      nameCache: {}
    })
  ]
};

Architecture

The plugin is built around several key components:

• Main Plugin Function: Factory function that returns a Rollup plugin instance
• Worker Pool System: Optional multi-threading using Node.js worker threads for parallel processing
• Terser Integration: Direct integration with the Terser minification library
• Source Map Support: Automatic source map generation based on Rollup output configuration
• Name Cache Management: Consistent variable naming across multiple chunks

Capabilities

Plugin Factory Function

Creates a Rollup plugin instance configured for JavaScript minification.

// External type imports (from rollup and terser packages)
import type { Plugin, RenderedChunk, NormalizedOutputOptions } from 'rollup';
import type { MinifyOptions } from 'terser';

/**
 * A Rollup plugin to generate a minified output bundle.
 *
 * @param options - Plugin options extending Terser's MinifyOptions
 * @returns Plugin instance
 */
export default function terser(options?: Options): Plugin;

Plugin Options

Configuration interface extending Terser's standard minification options.

interface Options extends MinifyOptions {
  /** Name cache for consistent variable naming across chunks */
  nameCache?: Record<string, any>;
  /** Maximum number of worker threads to use for parallel processing */
  maxWorkers?: number;
}

The Options interface extends Terser's MinifyOptions, which includes all standard Terser configuration options such as:

• compress: Compression options for dead code elimination
• mangle: Variable name mangling options
• output: Output formatting options
• sourceMap: Source map generation settings
• toplevel: Top-level scope mangling
• module: ES module-specific optimizations

Plugin Instance Properties

The returned plugin instance includes:

interface TerserPlugin {
  /** Plugin identifier */
  name: 'terser';
  /** Processes each chunk through the minifier */
  renderChunk(
    code: string, 
    chunk: RenderedChunk, 
    outputOptions: NormalizedOutputOptions
  ): Promise<string | { code: string; map: any }>;
  /** Returns number of workers used in the last operation */
  readonly numOfWorkersUsed: number;
}

Plugin Behavior

Automatic Configuration

The plugin automatically applies format-specific optimizations:

• ES Modules: Sets module: true for ES module optimizations
• CommonJS: Sets toplevel: true for top-level scope minification
• Source Maps: Automatically generates source maps when Rollup output specifies sourcemap: true

Multi-threading Support

When maxWorkers is specified or multiple chunks are processed:

• Creates worker pool with specified number of workers (defaults to CPU count)
• Distributes minification tasks across workers for parallel processing
• Automatically manages worker lifecycle and cleanup
• Maintains thread-safe name cache synchronization

Name Cache Management

The nameCache option enables consistent variable naming across chunks:

• Shared cache maintains variable mappings between processing sessions
• Automatically merges cache updates from worker threads
• Preserves naming consistency in multi-chunk builds

Error Handling

The plugin handles errors gracefully:

• Worker thread errors are propagated to the main thread
• Failed workers are automatically replaced with new instances
• Proper cleanup ensures no hanging processes

Usage Examples

Basic Minification

import terser from '@rollup/plugin-terser';

export default {
  input: 'src/index.js',
  output: { file: 'dist/bundle.min.js', format: 'iife' },
  plugins: [terser()]
};

Advanced Configuration

import terser from '@rollup/plugin-terser';

export default {
  input: 'src/index.js',
  output: { 
    file: 'dist/bundle.min.js', 
    format: 'iife',
    sourcemap: true
  },
  plugins: [
    terser({
      compress: {
        drop_console: true,
        drop_debugger: true,
        pure_funcs: ['console.log']
      },
      mangle: {
        reserved: ['MyLibrary', 'API']
      },
      output: {
        comments: false
      },
      maxWorkers: 4
    })
  ]
};

Multi-Chunk Builds with Name Cache

import terser from '@rollup/plugin-terser';

const nameCache = {};

export default {
  input: ['src/main.js', 'src/worker.js'],
  output: {
    dir: 'dist',
    format: 'es'
  },
  plugins: [
    terser({
      nameCache,
      mangle: true,
      maxWorkers: 2
    })
  ]
};