rollup/plugins

Features

• Bundling Pipeline Extensions - Provides a collection of official plugins to extend and customize the Rollup bundling pipeline.
• JavaScript Module Format Converters - Transforms legacy CommonJS and non-JavaScript formats into standard ES modules for consistent processing.
• AST-Based Source Transformations - Provides tools for modifying source code by replacing abstract syntax tree nodes during the bundling process.
• JavaScript AST Transformations - Transforms TypeScript, JSX, and GraphQL into standard JavaScript for cross-environment compatibility.
• JavaScript Compatibility Transformations - Transforms TypeScript, Flow, and JSX into standard JavaScript to ensure compatibility across different environments.
• Rollup-Compatible Plugin Integrations - Offers a suite of official plugins for transforming, resolving, and optimizing modules within the Rollup ecosystem.
• Bundle Size Optimization - Minifies code and removes debugging statements to reduce the final asset size for faster web loading.
• Module Resolution Aliases - Maps custom identifiers to file system paths to simplify import statements through module resolution aliases.
• Module Dependency Classification - Locates third-party libraries and manages module path resolution to ensure dependencies are correctly bundled.
• Module Resolution Algorithms - Locates third-party modules within dependency folders by applying standard resolution algorithms to import statements.
• Module Resolution Utilities - Provides utilities for mapping import paths to physical files via aliases during the build process.
• CommonJS-to-ES6 Converters - Transforms CommonJS modules and legacy scripts into standard ES6 modules for consistent processing.
• Import Map Configurations - Redirects import paths to different file locations using mapping configurations to simplify maintenance.
• TypeScript Transpilers - Converts modern TypeScript and JavaScript into a compatible version using a high-performance compiler.
• Import Path Resolution - Maps import strings to physical file locations using patterns and aliases to simplify dependency management.
• JavaScript Module Resolution - Customizes the module resolution process through aliases and entry point globs to locate files efficiently.
• JavaScript Optimizers and Minifiers - Reduces JavaScript bundle sizes through minification and the removal of production-irrelevant code.
• Source-to-JavaScript Transpilers - Integrates a compiler into the build process to convert type-annotated TypeScript code into standard JavaScript.
• Non-JavaScript Asset Imports - Loads non-JS assets like JSON, YAML, GraphQL, CSV, and images as first-class modules.
• Babel Transformations - Integrates the Babel compiler to apply JavaScript transformations and polyfills within the build pipeline.
• Package Import Resolvers - Determines the correct file to load by resolving package entry points defined in exports, imports, or main fields.
• Source Code Transformation Engines - Converts TypeScript, JavaScript, JSX, and Flow into compatible versions using transformation engines.
• Source-To-Source Transpilers - Translates modern JavaScript, TypeScript, Flow, and JSX into compatible versions using external compilers.
• Hook-Based Plugin Systems - Implements a hook-based system allowing plugins to intercept and modify the bundling process at specific lifecycle events.
• Bundle Optimizers - Optimizes the final bundle size by minifying code and removing debugging statements for production.
• JavaScript Bundlers - Acts as a comprehensive utility suite for compiling and packaging JavaScript modules for web deployment.
• Modern Web Syntax Transpilation - Converts modern TypeScript, JSX, and Flow syntax into compatible JavaScript versions for browser execution.
• Bundled Code Transformations - Applies code transformations to final bundled chunks to handle auto-generated code or target compatibility levels.
• GraphQL Module Transformation - Transforms GraphQL schema files into modules and supports fragment imports to allow modular definitions.
• Build Pipeline Orchestration - Orchestrates the build sequence by generating HTML wrappers and integrating linting into the pipeline.
• Build-Time Code Stripping - Strips debugger statements and logging functions from source code to clean up production builds.
• Bundle Runtime Execution - Launches generated bundles as child processes and restarts them automatically after every rebuild.
• Frontend Development Environments - Automates the generation of HTML wrappers and restarts bundles in a runtime environment for active development.
• Glob Pattern Resolvers - Identifies input files using glob patterns and inclusion rules to automate the selection of entry points.
• Static Code Linting - Analyzes source code for style violations and programming mistakes using static code linting.
• Build Tool Integrations - Integrates external tools like linters and system alerts into the build task automation pipeline.
• Virtual Modules - Serves virtual modules directly from memory to enable the creation of files that do not exist on disk.
• Bundle Entry Point Combination - Merges multiple source files into one bundle by combining named exports into a single output file.
• WebAssembly - Imports and bundles binary WebAssembly modules into the final JavaScript output.
• JSON Module Imports - Transforms JSON data files into modules so their content can be imported directly into source code.
• Runtime Built-in Module Handling - Identifies native runtime modules to mark them as external or replace them with compatible polyfills.
• Dynamic Imports - Resolves import statements containing variables to ensure dynamic dependencies are correctly bundled.
• TypeScript Source Transformers - Executes custom transformation logic during TypeScript compilation to modify generated code or declaration files.
• String Pattern Replacements - Swaps text patterns with values to inject environment variables and constants during bundling.
• Binary-to-ESM Encodings - Converts non-text assets like images and WebAssembly into base64 strings or modules for direct bundle inclusion.
• Virtual Module Injection - Serves synthetic modules directly from memory to register services without requiring physical source files.
• CommonJS Compatibility - Provides a compatibility layer by replacing CommonJS global variables with equivalents in ES Module bundles.
• JavaScript Minification - Compresses JavaScript code to reduce bundle size using a minification engine.
• In-Memory Loading - Serves virtual modules directly from memory, allowing the creation of files that do not exist on the physical disk.
• Plugin Development Utilities - Provides a set of standardized helper functions to simplify the creation of custom bundling extensions.
• Code Quality Checks - Runs automated linting checks on entry points and imported files to verify code quality during bundling.
• WebAssembly Module Loaders - Inlines WebAssembly files as strings and provides a loader function for runtime instantiation.
• CommonJS Compatibility Layers - Configures the transpilation process to support importing legacy module formats within type-annotated files.
• HTML Entry Point Generators - Generates HTML files that serve as entry points and link to bundled JavaScript assets.
• Data File Loaders - Includes loaders that transform JSON, YAML, and CSV files into usable JavaScript objects.

Star-Verlauf