Next-generation ES module bundler

Last update: Jan 4, 2023

Related tags

Overview

Rollup

Overview

Rollup is a module bundler for JavaScript which compiles small pieces of code into something larger and more complex, such as a library or application. It uses the standardized ES module format for code, instead of previous idiosyncratic solutions such as CommonJS and AMD. ES modules let you freely and seamlessly combine the most useful individual functions from your favorite libraries. Rollup can optimize ES modules for faster native loading in modern browsers, or output a legacy module format allowing ES module workflows today.

Quick Start Guide

Install with npm install --global rollup. Rollup can be used either through a command line interface with an optional configuration file, or else through its JavaScript API. Run rollup --help to see the available options and parameters. The starter project templates, rollup-starter-lib and rollup-starter-app, demonstrate common configuration options, and more detailed instructions are available throughout the user guide.

Commands

These commands assume the entry point to your application is named main.js, and that you'd like all imports compiled into a single file named bundle.js.

For browsers:

# compile to a <script> containing a self-executing function
rollup main.js --format iife --name "myBundle" --file bundle.js

For Node.js:

# compile to a CommonJS module
rollup main.js --format cjs --file bundle.js

For both browsers and Node.js:

# UMD format requires a bundle name
rollup main.js --format umd --name "myBundle" --file bundle.js

Why

Developing software is usually easier if you break your project into smaller separate pieces, since that often removes unexpected interactions and dramatically reduces the complexity of the problems you'll need to solve, and simply writing smaller projects in the first place isn't necessarily the answer. Unfortunately, JavaScript has not historically included this capability as a core feature in the language.

This finally changed with ES modules support in JavaScript, which provides a syntax for importing and exporting functions and data so they can be shared between separate scripts. Most browsers and Node.js support ES modules. However, Node.js releases before 12.17 support ES modules only behind the --experimental-modules flag, and older browsers like Internet Explorer do not support ES modules at all. Rollup allows you to write your code using ES modules, and run your application even in environments that do not support ES modules natively. For environments that support them, Rollup can output optimized ES modules; for environments that don't, Rollup can compile your code to other formats such as CommonJS modules, AMD modules, and IIFE-style scripts. This means that you get to write future-proof code, and you also get the tremendous benefits of...

Tree Shaking

In addition to enabling the use of ES modules, Rollup also statically analyzes and optimizes the code you are importing, and will exclude anything that isn't actually used. This allows you to build on top of existing tools and modules without adding extra dependencies or bloating the size of your project.

For example, with CommonJS, the entire tool or library must be imported.

// import the entire utils object with CommonJS
var utils = require( 'utils' );
var query = 'Rollup';
// use the ajax method of the utils object
utils.ajax( 'https://api.example.com?search=' + query ).then( handleResponse );

But with ES modules, instead of importing the whole utils object, we can just import the one ajax function we need:

// import the ajax function with an ES import statement
import { ajax } from 'utils';
var query = 'Rollup';
// call the ajax function
ajax( 'https://api.example.com?search=' + query ).then( handleResponse );

Because Rollup includes the bare minimum, it results in lighter, faster, and less complicated libraries and applications. Since this approach is based on explicit import and export statements, it is vastly more effective than simply running an automated minifier to detect unused variables in the compiled output code.

Compatibility

Importing CommonJS

Rollup can import existing CommonJS modules through a plugin.

Publishing ES Modules

To make sure your ES modules are immediately usable by tools that work with CommonJS such as Node.js and webpack, you can use Rollup to compile to UMD or CommonJS format, and then point to that compiled version with the main property in your package.json file. If your package.json file also has a module field, ES-module-aware tools like Rollup and webpack will import the ES module version directly.

Contributors

This project exists thanks to all the people who contribute. [Contribute].

Backers

Thank you to all our backers! 🙏 [Become a backer]

License

MIT

Comments

Avoid lazy parsing by adding parens around factory

Most javascript engines do a lazy parsing optimization. For example if they see:

function X() {...}

They won't parse the contents of X until it is executed. However they often have to read the contents of X so that they can see if X uses any variables from the outer scope. Thus X ends up getting parsed twice.

Realizing that often one immediately executes a function, browser have optimized statements of the form:

(function X() {...})()

So that X is not parsed lazily. Traditionally this optimization looks for an open paren before the function. For example, here's the optimization in v8:

https://github.com/v8/v8/blob/203391bcc0e970d3cae27ba99afd337c1c5f6d42/src/parsing/parser.cc#L4256

Since the factory is immediately executed (at least in the commonJS and global export case), this change avoids the double parsing that comes with parsing the function lazily.
c¹ ⋅ discussion

opened by bmaurer 65
Code splitting
Previously: #120.

Probably not going to happen any time soon, but at some point it would be nice to add support for code-splitting, i.e. finding the common dependencies of a.js and b.js so that you can do this sort of thing...

 <script src='shared.js'></script> <script src='a.js'></script>  <script src='shared.js'></script> <script src='b.js'></script>

...and let visitors to b.html who have already been to a.html use a cached copy of shared.js (mutatis mutandis for client-side routing situations with an asynchronous module loader).

First hard question is what the API looks like – my initial thought is that if you specify x entry points you should get x+1 bundles back, where the +1 is the shared code. Very easy to grok and probably meets most use cases, but not as flexible as some other approaches.

Anyway I'll just leave this here for now.
t³ ✨ enhancement
opened by Rich-Harris 65
Tree shaking not work when static method in class was used
Link to Reproduce https://rollupjs.org/repl/?version=2.41.0&shareable=JTdCJTIybW9kdWxlcyUyMiUzQSU1QiU3QiUyMm5hbWUlMjIlM0ElMjJtYWluLmpzJTIyJTJDJTIyY29kZSUyMiUzQSUyMiUyRiolMjBUUkVFLVNIQUtJTkclMjAqJTJGJTVDbmV4cG9ydCUyMCU3QiUyMHRlc3QlMjAlN0QlMjBmcm9tJTIwJy4lMkZtb2R1bGUuanMnJTNCJTVDbiUyMiUyQyUyMmlzRW50cnklMjIlM0F0cnVlJTdEJTJDJTdCJTIybmFtZSUyMiUzQSUyMm1vZHVsZS5qcyUyMiUyQyUyMmNvZGUlMjIlM0ElMjJleHBvcnQlMjAlN0IlMjBGaWJlclRhc2tRdWV1ZSUyMCU3RCUyMGZyb20lMjAnLiUyRm1vZHVsZTIuanMnJTNCJTVDbmV4cG9ydCUyMCU3QiUyMHRlc3QlMjAlN0QlMjBmcm9tJTIwJy4lMkZtb2R1bGUzJyUzQiUyMiUyQyUyMmlzRW50cnklMjIlM0FmYWxzZSU3RCUyQyU3QiUyMm5hbWUlMjIlM0ElMjJtb2R1bGUyLmpzJTIyJTJDJTIyY29kZSUyMiUzQSUyMnZhciUyMEZpYmVyVGFza1F1ZXVlJTIwJTNEJTIwKGZ1bmN0aW9uJTIwKCklMjAlN0IlNUNuJTIwJTIwJTIwJTIwZnVuY3Rpb24lMjBGaWJlclRhc2tRdWV1ZSgpJTIwJTdCJTVDbiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHRoaXMudGFza1F1ZXVlJTIwJTNEJTIwJTVCJTVEJTNCJTVDbiUyMCUyMCUyMCUyMCU3RCU1Q24lNUN0JTVDbiU1Q3QlNUN0RmliZXJUYXNrUXVldWUuYWRkJTIwJTNEJTIwZnVuY3Rpb24lMjAoKSUyMCU3QiU1Q24lNUN0JTVDdCU3RCU1Q24lNUN0JTVDbiUyMCUyMCUyMCUyMEZpYmVyVGFza1F1ZXVlLnByb3RvdHlwZS5jbGVhciUyMCUzRCUyMGZ1bmN0aW9uJTIwKCklMjAlN0IlNUNuJTVDdCU1Q3QlNUN0JTIwJTIwRmliZXJUYXNrUXVldWUuYWRkKCklM0IlNUNuJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwdGhpcy50YXNrUXVldWUlMjAlM0QlMjAlNUIlNUQlM0IlNUNuJTIwJTIwJTIwJTIwJTdEJTNCJTVDbiUyMCUyMCUyMCUyMHJldHVybiUyMEZpYmVyVGFza1F1ZXVlJTNCJTVDbiU3RCgpKSUzQiU1Q24lNUNuZXhwb3J0JTIwJTdCJTIwRmliZXJUYXNrUXVldWUlMjAlN0QlM0IlMjIlN0QlMkMlN0IlMjJuYW1lJTIyJTNBJTIybW9kdWxlMy5qcyUyMiUyQyUyMmNvZGUlMjIlM0ElMjJleHBvcnQlMjBmdW5jdGlvbiUyMHRlc3QoKSUyMCU3QiU1Q24lNUN0cmV0dXJuJTIwJ2EnJTNCJTVDbiU3RCUyMiU3RCU1RCUyQyUyMm9wdGlvbnMlMjIlM0ElN0IlMjJmb3JtYXQlMjIlM0ElMjJlcyUyMiUyQyUyMm5hbWUlMjIlM0ElMjJteUJ1bmRsZSUyMiUyQyUyMmFtZCUyMiUzQSU3QiUyMmlkJTIyJTNBJTIyJTIyJTdEJTJDJTIyZ2xvYmFscyUyMiUzQSU3QiU3RCU3RCUyQyUyMmV4YW1wbGUlMjIlM0FudWxsJTdE

Expected Behavior

only have

function test() { return 'a'; } export { test };

Actual Behavior

not only test function but also class

if static method is replaced with instance method(or if static method in class was not used), it works right. Anybody knows why?
opened by QiuZhiFeng97 51
Integration with Angular2 / TypeScript

Rollup seems like a dream bundler for ng2 apps, but it is unclear how it can be integrated with typescript codebases.

What is the recommended way to rollup a typescript app, which uses es6 imports, and which depends on ng2 (which is also written in typescript and uses es6 imports exclusively)?
c⁵ ⋅ question

opened by flyingmutant 46
Can code splitting be done according to chunk size?

Similar to the maxSize configuration of webpack, can you split different chunks according to the chunk size in manualChunks? For example, the final total size is 500 KB, can it be automatically split into vendor1.js, vendor2.js, vendor3.js, and the size of each vendor does not exceed 200KB?

opened by sanyuan0704 44
Update to Chokidar v3 and bundle it as the default

I suggest to update to chokidar v3.

Chokidar v3 incorporates a lot of improvements. We've decreased RAM consumption on large directories by a huge amount; and reduced dependency count by a factor of 13. All releases are signed now. See my blog post: Chokidar 3: How to save 32TB of traffic every week with one NPM package

Chokidar v3 requires nodejs 8 and higher. Is it cool with Rollup?
t³ ✨ enhancement s² 🔥🔥 important

opened by paulmillr 44
painful to get started
This project needs some better tutorials or examples. Here's my use case:

I have code written in ES2015; I am using Babel to transpile

I am also using npm dependencies

These dependencies (mainly) use CommonJS instead of ES2015 modules

This is a test runner with a programmatic API

The resulting build(s) must be runnable in Node.js, a browser, and a CLI context

I've discovered the Babel plugin, the NPM plugin, and the CommonJS plugin. It's unclear:

In what order the plugins are supposed to run

If order actually matters (though I'm pretty sure it does)

Why the CommonJS plugin and NPM plugin are separated at all

How to configure the Babel plugin to work with the above two plugins

Why the Babel plugin is necessary

Where Babel's responsibilities end and Rollup's begin--don't you need Babel to use import statements anyway?

If/when Browserify or Webpack is necessary

How to configure Karma to make my tests run in a browser

How to explain to my users, in a README, how to include my library given a matrix of potential configurations (Node.js, browser, Babel, no-Babel, Rollup, etc)

When to use a config file or when and how to use a build script (import rollup from 'rollup')

I'm here asking these questions, there's probably 5 other people who had the same ones and didn't post an issue. Surely I'd like my questions addressed, but the real need is more documentation.

Thanks!
c¹ ⋅ discussion x¹ ⋅ abandoned
opened by boneskull 44
Improve circular dependency execution order
This PR contains:

[x] bugfix

[x] feature

[ ] refactor

[ ] documentation

[ ] other

Are tests included?

[x] yes (bugfixes and features will not be merged without tests)

[ ] no

Breaking Changes?

[ ] yes (breaking changes will not be merged unless absolutely necessary)

[x] no

List any relevant issue numbers: #3834

Description

As #3834 showed, our current way of sorting dependencies in chunks completely messes up execution order if there are circular dependencies between chunks, which can happen when preserving modules.

Before, we just sorted dependencies by their execution order. This PR instead changes the logic so that the order of dependencies is preserved from the modules. If we skip dependencies because they have no side-effects, the algorithm crawls transitive dependencies in the same order as regular dependency execution would happen to look for transitive side-effect dependencies instead.

When merging module dependencies into chunks, the process now has two parts

first we start with the last module in the chunk, get the dependencies of that module. If a dependency is part of the chunk, we replace it with the dependencies of THAT module recursively. This process creates a dependency block

then we move on to the second to last module in the chunk, iterating backwards over the modules. If a module has already been handled as it was a dependency of a previous module it is skipped, otherwise a new dependency block is created

last we add all dependency blocks as dependencies to the chunk, this time in regular order, though

This new algorithm will produce better execution order when

preserving modules

only chunks are created where all modules in the chunk would be executed top to bottom before bundling

The second is not enforced yet, though. This will be a larger feature to add sometime in the future.

Unfortunately, the execution order is not perfect when preserving modules as import shortening will still introduce new imports into modules/chunks that can trigger a cycle to be executed in a non-natural order. For this case, there has been a warning added. The infrastructure introduced to generate this warning can serve as a basis to fix this issue at least for ESM, CommonJS and possibly SystemJS in the future. AMD output cannot be made to support this easily as it does not have a dedicated concept of reexports. For CommonJS, the solution must be to hoist reexports from a module directly below the corresponding require statement in the reexporting module, i.e.

export { foo } from 'bar'; import 'baz';

should become

const bar = require('bar'); exports.foo = bar.foo; require('baz');

However, special care needs to be taken to properly support namespace reexports mixed with regular (re)exports as those will always override namespace reexports. Also, the logic should look different for reassigned exports.

Another point that was added in this PR that is not directly related to circular reexports is which reexporting modules are scanned for side-effects when moduleSideEffects are turned off. Basically the logic now goes like this:

// main.js import { foo } from './first'; console.log(foo); // first.js // This module will not be considered to add a side-effect as it does not touch the reexported binding export { foo } from './second'; // second.js // This module WILL be scanned for side-effects as it reexports its own import. import { foo } from './third'; export { foo }; // third.js // This module will NOT be scanned for side-effects as the reexport is separate from the import, even though it is the same binding export { foo } from './fourth'; import { foo } from './fourth';

So in short, a direct reexport (export ... from) is ignored when looking for side effects while a reexport using separate import/export statements is considered. The reasoning here is that when I import a binding and the export it again, I may be my intention to mutate this binding in between, e.g. add properties to an object. The commonjs plugin will rely on this feature.
opened by lukastaegert 43

Using Cheerio with Rollup: Duplicate export 'default'

Hi,

I am trying out Rollup for my project, and am having trouble importing cheerio. You can reproduce the issue in this repository I created.

Anyway, when I try to import cheerio with Rollup (via import cheerio from 'cheerio'), I receive the following error:

$ npm run build

> [email protected] build /Users/Caleb/Repositories/rollup-cheerio-error
> rollup -c


src/index.js → dist/index.js...
[!] Error: Duplicate export 'default'
node_modules/cheerio/lib/options.js (26:22)
24: export default options;
25: export { options as __moduleExports };
26: export { default_1 as default };
                          ^
27: export { flatten };

Here is my rollup config:

import commonjs from 'rollup-plugin-commonjs';
import resolve from 'rollup-plugin-node-resolve';
import json from 'rollup-plugin-json';

export default {
  input: 'src/index.js',
  output: {
    file: 'dist/index.js',
    format: 'iife',
  },
  name: 'yvs',
  plugins: [
    resolve({
      browser: true,
      preferBuiltins: true
    }),
    commonjs(),
    json()
  ]
};

Is there anything I can do about this? Any options I can set or plugins I can install? Or is this issue cheerio's responsibility?

Thanks, Caleb

opened by caleb531 40

[bug] Watch mode does not watch.

I just upgraded to 0.53.0 and Rollup no longer even tries to watch anything. Instead, it exits back to the command line right after the first build as if I ran rollup without the --watch option. However, it does enter the alternate buffer while building, but then returns back to the main buffer when the first build finishes.

opened by trusktr 38
Handling of circular dependencies

Can be seen here.

The problem is that the Child class cannot really inherit from the Parent, because they come out serialized in a wrong order. This is because a circular dependency on doStuff from ./lib.js exists in Parent, while doStuff depends on Child.

In this case, however, I believe that a proper solution exists: serialize lib.js first, then parent.js, then child.js (the parent-child order is necessary due to inheritance; the lib-child order can be switched as necessary, as doStuff needs the child to be present later (when executing).
t¹ 🐞 bug

opened by ondras 37
Update dependencies
This PR contains:

[ ] bugfix

[ ] feature

[ ] refactor

[ ] documentation

[x] other

Are tests included?

[ ] yes (bugfixes and features will not be merged without tests)

[x] no

Breaking Changes?

[ ] yes (breaking changes will not be merged unless absolutely necessary)

[ ] no

List any relevant issue numbers:

Description

In the previous dependency update, we left out

eslint-plugin-import, because it had a vulnerability

rollup, because @rollup/plugin-terser had some issues

Both of these have been resolved now, which finally allow us to update all remaining dependencies and add eslint-plugin-import again.
opened by lukastaegert 1
A bug with packaging results affecting browser caching policies

Rollup Version

"version": "2.79.1"

Operating System (or Browser)

browser

Node Version (if applicable)

v18.9.0

Link To Reproduction

https://github.com/meizilove258/vite-code-split2.git

Expected Behaviour

This is a vue project that uses vue and Vue-router. There are two pages for this project, about.vue and help.vue. Both about.vue and help.vue import useRoute and useRouter from the vue-router and use the two methods, respectively. In this project, vue and Vue-router are packaged into vendor.[contexthash].js. When the variable about.vue imported from the vute-router changed, it changed from useRoute and useRouter to useRoute. Changes in the vendor.[contexthash].js file were found during repackaging. The content found to change is the exported variable in vendor.[contexthash].js, among which the order of three variables has changed. In my opinion, modification based on the above behavior should not happen. If no useRouter is imported into the entire application, tree-shake will occur at this time, resulting in changes in the vendor.[contexthash].js file is normal.

Actual Behaviour

This is a vue project that uses vue and Vue-router. There are two pages for this project, about.vue and help.vue. Both about.vue and help.vue import useRoute and useRouter from the vue-router and use the two methods, respectively. In this project, vue and Vue-router are packaged into vendor.[contexthash].js. When the variable about.vue imported from the vute-router changed, it changed from useRoute and useRouter to useRoute. Changes in the vendor.[contexthash].js file were found during repackaging. The content found to change is the exported variable in vendor.[contexthash].js, among which the order of three variables has changed. In my opinion, modification based on the above behavior should not happen. If no useRouter is imported into the entire application, tree-shake will occur at this time, resulting in changes in the vendor.[contexthash].js file is normal.
t¹ 🐞 bug t⁸ ⋅ triage

opened by meizilove258 0
Support legal file names with a dollar notation like `$.js` or `a$.js`
This PR contains:

[ ] bugfix

[x] feature

[ ] refactor

[ ] documentation

[ ] other

Are tests included?

[ ] yes (bugfixes and features will not be merged without tests)

[x] no

Breaking Changes?

[ ] yes (breaking changes will not be merged unless absolutely necessary)

[x] no

List any relevant issue numbers:

Description

Hope not to sanitize file names like $.js, or a$.js which is legal in all OS systems.
opened by aleen42 5
RFC: plugin api version
Feature Use Case

I heard that rollup is considering to bump major versions a bit more frequently than in the past. Currently bumping major versions require plugins to update the peerDependencies field. This increases the cost of maintaining a plugin when major versions were released frequently.

Feature Proposal

Given that the plugin interface is quite stable, I guess not every major version will change the plugin interface. That means plugins would be compatible among some major versions without any changes. To take this advantage, I propose to introduce a concept of "Plugin API Version".

"Plugin API Version" is a version for the plugin api interface. Unless there aren't a breaking change to the plugin api interface, this version doesn't change even for new major versions. This eliminates the need for the plugin to maintain rollup version in peerDependencies.

An example implementation of this would be to add a compatiblePluginApiVersion hook. (I haven't considered other ways.) package.json

{ "name": "rollup-plugin-foo", "main": "index.mjs", "peerDependencies": { "rollup": ">=3.0.0 <10.0.0" // "< 10.0.0" is to avoid locking into this plugin compatibility strategy } }

index.mjs

export default function () { return { name: 'foo', compatiblePluginApiVersion() { return '^1.4' }, renderStart() { console.log('renderStart') } } }
t³ ✨ enhancement t⁸ ⋅ triage
opened by sapphi-red 2
feat: add `resolveBy` field to `ResolvedId`
This PR contains:

[ ] bugfix

[x] feature

[ ] refactor

[ ] documentation

[ ] other

Are tests included?

[x] yes (bugfixes and features will not be merged without tests)

[ ] no

Breaking Changes?

[ ] yes (breaking changes will not be merged unless absolutely necessary)

[x] no

List any relevant issue numbers: resolves #4773

Description
opened by TrickyPi 1

Releases(v3.9.1)

v3.9.1(Jan 2, 2023)
3.9.1

2023-01-02

Bug Fixes

Sort keys in generated dynamic namespace objects (#4780)

Do not consider Array.group to be side effect free as the specs have changed (#4779)

Pull Requests

#4777: Import from node:fs/promises (@dnalborczyk)

#4778: Bump deps (@dnalborczyk)

#4779: Remove array grouping (web compat issue) (@dnalborczyk)

#4780: Sort namespace object keys (@dnalborczyk)

#4781: Use Set and builtin-modules package (@dnalborczyk)

#4782: Use more restrictive types (@dnalborczyk)

Source code(tar.gz)
Source code(zip)
v3.9.0(Dec 28, 2022)
3.9.0

2022-12-28

Features

Support ES2022 arbitrary module namespace identifiers (#4770)

Add optional version property to plugin type (#4771)

Pull Requests

#4768: Fix small typo in 999-big-list-of-options.md (@ericmutta)

#4769: docs: add a instruction about how to run one test on your local computer (@TrickyPi)

#4770: Add support for arbitrary module namespace identifiers (@lukastaegert)

#4771: Add version property to Plugin type (@Septh)

Source code(tar.gz)
Source code(zip)
v3.8.1(Dec 23, 2022)
3.8.1

2022-12-23

Bug Fixes

Reduce memory footprint when explicitly passing cache: false (#4762)

Fix a crash when preserving modules and reexporting namespaces (#4766)

Pull Requests

#4762: Improve AST garbage collection (@bluwy)

#4766: Fix handling of namespace reexports when preserving modules (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.8.0(Dec 22, 2022)
3.8.0

2022-12-22

Features

Deduplicate ESM exports and reexports when preserving modules (#4759)

Bug Fixes

Handle files that are emitted as a side effect of the manualChunks option (#4759)

Pull Requests

#4759: feat: deduplicate reexports and renderedExports to simplify output (@TrickyPi)

#4761: Support emitting files via manualChunks in output (@lukastaegert)

#4763: docs: update outdated info (@TrickyPi)

Source code(tar.gz)
Source code(zip)
v3.7.5(Dec 17, 2022)
3.7.5

2022-12-17

Bug Fixes

Avoid name shadowing when default exporting a class that matches the name of another class (#4756)

Do not display the error message both in a separate line and in the stack trace in rollup CLI (#4749)

Make type of RollupWarning.cause compatible with Error.cause (#4757)

Do not swallow side effects when interacting with modules namespaces nested in another object (#4758)

Pull Requests

#4749: feat: simplify stack info in cli error (@TrickyPi)

#4756: Avoid name conflicts for default exported classes (@lukastaegert)

#4757: fix: RollupLog cause allow unknown (@Shinigami92)

#4758: Correctly handle side effects when a namespace is nested in an object (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.7.4(Dec 13, 2022)
3.7.4

2022-12-13

Bug Fixes

Do not remove calls to .exec and .test for included stateful regular expressions (#4742)

Pull Requests

#4742: fix: check whether RegExp have the global or sticky flags set (@TrickyPi)

Source code(tar.gz)
Source code(zip)
v3.7.3(Dec 11, 2022)
3.7.3

2022-12-11

Bug Fixes

Ensure this.getFileName no longer returns a placeholder as soon as hash placeholders have been resolved (#4747)

Pull Requests

#4747: provide hashed file name when using this.getFileName in generateBundle (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.7.2(Dec 10, 2022)
3.7.2

2022-12-10

Bug Fixes

Improve chunk generation performance when one module is dynamically imported by many other modules (#4736)

Pull Requests

#4736: Improve chunk assignment performance (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.7.1(Dec 9, 2022)
3.7.1

2022-12-09

Bug Fixes

Ad a hint to use @rollup/plugin-json when imports from a JSON file are not found (#4741)

Pull Requests

#4741: fix: provide json hint when importing a no export json file (@TrickyPi)

Source code(tar.gz)
Source code(zip)
v3.7.0(Dec 8, 2022)
3.7.0

2022-12-08

Features

Do not treat .test and .exec on regular expressions as side effects (#4737)

Pull Requests

#4737: feat: add sutiable RegExp prototype methods (@TrickyPi)

Source code(tar.gz)
Source code(zip)
v3.6.0(Dec 5, 2022)
3.6.0

2022-12-05

Features

extend this.getModuleInfo with information about exports (#4731)

Pull Requests

#4731: feat: add exports and exportedBindings to Module class (@TrickyPi)

Source code(tar.gz)
Source code(zip)
v3.5.1(Dec 1, 2022)
3.5.1

2022-12-01

Bug Fixes

Accept functions returning a config in defineConfig (#4728)

Pull Requests

#4728: Overload defineConfig to accept a RollupOptionsFunction parameter (@Septh)

Source code(tar.gz)
Source code(zip)
v3.5.0(Nov 27, 2022)
3.5.0

2022-11-27

Features

Add treeshake.manualPureFunctions to override static analysis for explicit function names (#4718)

Bug Fixes

Do not throw when a plugin uses this.load without awaiting its result (#4725)

Pull Requests

#4718: Add simple way to manually declare pure functions (@lukastaegert)

#4725: Fix isIncluded error when using rollup-plugin-typescript2 (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.4.0(Nov 22, 2022)
3.4.0

2022-11-22

Features

Do not keep unused Object.freeze calls on object literals (#4720)

Pull Requests

#4720: Only consider Object.freeze a side effect if the argument is used (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.3.0(Nov 12, 2022)
3.3.0

2022-11-12

Features

Add "experimentalMinChunkSize" option to merge smaller chunks into larger ones (#4705)

Automatically deduplicate assets again when the source is a Buffer (#4712)

Deduplicate Buffer with string assets (#4712)

Bug Fixes

Support plugins with object hooks when using perf: true (#4707)

Pull Requests

#4702: docs: add additional tips for heap out of memory (@benmccann)

#4705: Allow to define minimum chunk size limit (@lukastaegert)

#4707: Fix perf timers for object hooks (@lukastaegert)

#4710: Update terser docs (@nikolas)

#4712: feat: deduplicate assets with buffer source (@patak-dev)

Source code(tar.gz)
Source code(zip)
v3.2.5(Nov 1, 2022)
3.2.5

2022-11-01

Bug Fixes

We deconflicting classes, ensure the original class name still does not shadow variables (#4697)

Pull Requests

#4697: Prevent class ids from shadowing other variables (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.2.4(Oct 31, 2022)
3.2.4

2022-10-31

Bug Fixes

Always use forward slashes in chunk ids when preserving modules, even on Windows (#4693)

Escape problematic characters in ids when rewriting import.meta.url (#4693)

Pull Requests

#4685: update package-lock version (@jerry-lllman)

#4689: Update 07-tools.md (@cokert)

#4693: Use correct import.meta.url slashes on Windows (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.2.3(Oct 18, 2022)
3.2.3

2022-10-18

Bug Fixes

Fix an issue whre Rollup confused new.target with import.meta (#4679)

Ensure that Rollup does not make assumptions about the value of unknown namespace import members (#4684)

Pull Requests

#4679: Do not rewrite new.target (@lukastaegert)

#4683: Remove typo in resolveId documentation (@ChrispyChris)

#4684: Return correct values for unknown namespace members (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.2.2(Oct 16, 2022)
3.2.2

2022-10-16

Bug Fixes

Do not hang/crash on hashbang comments in input modules (#4676)

Pull Requests

#4675: refactor: improve & simplify types (@sxzz)

#4676: Ignore hashhbang comments (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.2.1(Oct 16, 2022)
3.2.1

2022-10-16

Bug Fixes

Rewrite class declarations to preserve their .name property if necessary (#4674)

Pull Requests

#4674: Preserve rendered class names (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v3.2.0(Oct 15, 2022)
3.2.0

2022-10-15

Features

Support providing Promises as plugins like Vite (#4671)

Pull Requests

#4666: Add unicorn plugin (@lukastaegert)

#4667: refactor: improve types (@sxzz)

#4668: fix: nested plugin in options stage (@sxzz)

#4669: refactor: merge duplicate imports (@c0dedance)

#4670: docs: fix minor typo in migration documentation (@ThisIsMissEm)

#4671: feat: support async plugins (@sxzz)

Source code(tar.gz)
Source code(zip)
v3.1.0(Oct 12, 2022)
3.1.0

2022-10-12

Features

Support using arrays of plugins as plugins like Vite (#4657)

Pull Requests

#4657: feat: support nested plugin (@sxzz)

Source code(tar.gz)
Source code(zip)
v3.0.1(Oct 12, 2022)
3.0.1

2022-10-12

Bug Fixes

Fix installation on Windows (#4662)

Avoid missing parameters that are only used in a destructuring initializer (#4663)

Pull Requests

#4661: Enforce type imports (@lukastaegert)

#4662: fix: missing "node" causes run script error (@c0dedance)

#4663: Ensure the initializer of a destructuring declaration is always included if the id is included (@lukastaegert)

#4664: fix: remove lint:js:nofix script redundancy options (@c0dedance)

Source code(tar.gz)
Source code(zip)
v3.0.0(Oct 11, 2022)
3.0.0

2022-10-11

Breaking Changes

General Changes

Rollup now requires at least Node 14.18.0 to run (#4548 and #4596)

The browser build has been split into a separate package @rollup/browser (#4593)

The node build uses the node: prefix for imports of builtin modules (#4596)

Some previously deprecated features have been removed (#4552):

Some plugin context functions have been removed:

this.emitAsset(): use this.emitFile()

this.emitChunk(): use this.emitFile()

this.getAssetFileName(): use this.getFileName()

this.getChunkFileName(): use this.getFileName()

this.isExternal(): use this.resolve()

this.resolveId(): use this.resolve()

The resolveAssetUrl plugin hook has been removed: use resolveFileUrl

Rollup no longer passes assetReferenceId or chunkReferenceId parameters to resolveFileUrl

The treeshake.pureExternalModules option has been removed: use treeshake.moduleSideEffects: 'no-external'

You may no longer use true or false for output.interop. As a replacement for true, you can use "compat"

Emitted assets no longer have an isAsset flag in the bundle

Rollup will no longer fix assets added directly to the bundle by adding the type: "asset" field

Some features that were previously marked for deprecation now show warnings when used (#4552):

Some options have been deprecated:

inlineDynamicImports as part of the input options: use output. inlineDynamicImports

manualChunks as part of the input options: use output. manualChunks

maxParallelFileReads: use `maxParallelFileOps

output.preferConst: use output.generatedCode.constBindings

output.dynamicImportFunction: use the renderDynamicImport plugin hook

output.namespaceToStringTag: use output.generatedCode.symbols

preserveModules as part of the input options: use output. preserveModules

You should no longer access this.moduleIds in plugins: use this.getModuleIds()

You should no longer access this.getModuleInfo(...).hasModuleSideEffects in plugins: use this.getModuleInfo(...).moduleSideEffects

Configuration files are only bundled if either the --configPlugin or the --bundleConfigAsCjs options are used. The configuration is bundled to an ES module unless the --bundleConfigAsCjs option is used. In all other cases, configuration is now loaded using Node's native mechanisms (#4574 and #4621)

The properties attached to some errors have been changed so that there are fewer different possible properties with consistent types (#4579)

Some errors have been replaced by others (ILLEGAL_NAMESPACE_REASSIGNMENT -> ILLEGAL_REASSIGNMENT, NON_EXISTENT_EXPORT -> MISSING_EXPORT) (#4579)

Files in rollup/dist/* can only be required using their file extension (#4581)

The loadConfigFile helper now has a named export of the same name instead of a default export (#4581)

When using the API and sourcemaps, sourcemap comments are contained in the emitted files and sourcemaps are emitted as regular assets (#4605)

Watch mode no longer uses Node's EventEmitter but a custom implementation that awaits Promises returned from event handlers (#4609)

Assets may only be deduplicated with previously emitted assets if their source is a string (#4644)

By default, Rollup will keep external dynamic imports as import(…) in commonjs output unless output.dynamicImportInCjs is set to false (#4647)

Changes to Rollup Options

As functions passed to output.banner/footer/intro/outro are now called per-chunk, they should be careful to avoid performance-heavy operations (#4543)

entryFileNames/chunkFileNames functions now longer have access to the rendered module information via modules, only to a list of included moduleIds (#4543)

The path of a module is no longer prepended to the corresponding chunk when preserving modules (#4565)

When preserving modules, the [name] placeholder (as well as the chunkInfo.name property when using a function) now includes the relative path of the chunk as well as optionally the file extension if the extension is not one of .js, .jsx, .mjs, .cjs, .ts, .tsx, .mts, or .cts (#4565)

The [ext], [extName] and [assetExtName] placeholders are no longer supported when preserving modules (#4565)

The perf option no longer collects timings for the asynchronous part of plugin hooks as the readings were wildly inaccurate and very misleading, and timings are adapted to the new hashing algorithm (#4566)

Change the default value of makeAbsoluteExternalsRelative to "ifRelativeSource" so that absolute external imports will no longer become relative imports in the output, while relative external imports will still be renormalized (#4567)

Change the default for output.generatedCode.reservedNamesAsProps to no longer quote properties like default by default (#4568)

Change the default for preserveEntrySignatures to "exports-only" so that by default, empty facades for entry chunks are no longer created (#4576)

Change the default for output.interop to "default" to better align with NodeJS interop (#4611)

Change the default for output.esModule to "if-default-prop", which only adds __esModule when the default export would be a property (#4611)

Change the default for output.systemNullSetters to true, which requires at least SystemJS 6.3.3 (#4649)

Plugin API Changes

Plugins that add/change/remove imports or exports in renderChunk should make sure to update ChunkInfo.imports/importedBindings/exports accordingly (#4543)

The order of plugin hooks when generating output has changed (#4543)

Chunk information passed to renderChunk now contains names with hash placeholders instead of final names, which will be replaced when used in the returned code or ChunkInfo.imports/importedBindings/exports (#4543 and #4631)

Hooks defined in output plugins will now run after hooks defined in input plugins (used to be the other way around) (#3846)

Features

Functions passed to output.banner/footer/intro/outro are now called per-chunk with some chunk information (#4543)

Plugins can access the entire chunk graph via an additional parameter in renderChunk (#4543)

Chunk hashes only depend on the actual content of the chunk and are otherwise stable against things like renamed/moved source files or changed module resolution order (#4543)

The length of generated file hashes can be customized both globally and per-chunk (#4543)

When preserving modules, the regular entryFileNames logic is used and the path is included in the [name] property. This finally gives full control over file names when preserving modules (#4565)

output.entryFileNames now also supports the [hash] placeholder when preserving modules (#4565)

The perf option will now collect (synchronous) timings for all plugin hooks, not just a small selection (#4566)

All errors thrown by Rollup have name: RollupError now to make clearer that those are custom error types (#4579)

Error properties that reference modules (such as id and ids) will now always contain the full ids. Only the error message will use shortened ids (#4579)

Errors that are thrown in response to other errors (e.g. parse errors thrown by acorn) will now use the standardized cause property to reference the original error (#4579)

If sourcemaps are enabled, files will contain the appropriate sourcemap comment in generateBundle and sourcemap files are available as regular assets (#4605)

Returning a Promise from an event handler attached to a RollupWatcher instance will make Rollup wait for the Promise to resolve (#4609)

There is a new value "compat" for output.interop that is similar to "auto" but uses duck-typing to determine if there is a default export (#4611)

There is a new value "if-default-prop" for esModule that only adds an __esModule marker to the bundle if there is a default export that is rendered as a property (#4611)

Rollup can statically resolve checks for foo[Symbol.toStringTag] to "Module" if foo is a namespace (#4611)

There is a new CLI option --bundleConfigAsCjs which will force the configuration to be bundled to CommonJS (#4621)

Import assertions for external imports that are present in the input files will be retained in ESM output (#4646)

Rollup will warn when a module is imported with conflicting import assertions (#4646)

Plugins can add, remove or change import assertions when resolving ids (#4646)

The output.externalImportAssertions option allows to turn off emission of import assertions (#4646)

Use output.dynamicImportInCjs to control if dynamic imports are emitted as import(…) or wrapped require(…) when generating commonjs output (#4647)

Bug Fixes

Chunk hashes take changes in renderChunk, e.g. minification, into account (#4543)

Hashes of referenced assets are properly reflected in the chunk hash (#4543)

No longer warn about implicitly using default export mode to not tempt users to switch to named export mode and break Node compatibility (#4624)

Avoid performance issues when emitting thousands of assets (#4644)

Pull Requests

#3846: [v3.0] Run output plugins last (@aleclarson)

#4543: [v3.0] New hashing algorithm that "fixes (nearly) everything" (@lukastaegert)

#4548: [v3.0] Deprecate Node 12 (@lukastaegert)

#4552: [v3.0] Remove actively deprecated features, show warnings for other deprecated features (@lukastaegert)

#4558: [v3.0] Convert build scripts to ESM, update dependencies (@lukastaegert)

#4565: [v3.0] Rework file name patterns when preserving modules (@lukastaegert)

#4566: [v3.0] Restructure timings (@lukastaegert)

#4567: [v3.0] Change default for makeAbsoluteExternalsRelative (@lukastaegert)

#4568: [v3.0] Change default for output.generatedCode.reservedNamesAsProps (@lukastaegert)

#4574: [v3.0] Better esm config file support (@lukastaegert)

#4575: [v3.0] Show deprecation warning for maxParallelFileReads (@lukastaegert)

#4576: [v3.0] Change default for preserveEntrySignatures to exports-only (@lukastaegert)

#4579: [v3.0] Refine errors and warnings (@lukastaegert)

#4581: [v3.0] Use named export for loadConfigFile (@lukastaegert)

#4592: [v3.0] Port doc changes from #4572 and #4583 to 3.0 (@berniegp)

#4593: [v3.0] Browser build (@lukastaegert)

#4596: [v3.0] Use "node:" prefix for imports of node builtins (@lukastaegert)

#4605: [v3.0] Better sourcemap emission (@lukastaegert)

#4609: [v3.0] Custom awaiting watch emitter (@lukastaegert)

#4611: [v3.0] Improve interop defaults (@lukastaegert)

#4621: [v3.0] Always try to load config files via Node if possible (@lukastaegert)

#4624: [v3.0] Remove warning when using implicit default export mode (@lukastaegert)

#4631: [v3.0] Use ASCII characters for hash placeholders (@lukastaegert)

#4644: [v3.0] Improve performance of asset emissions (@lukastaegert)

#4646: [v3.0] Basic support for import assertions (@lukastaegert)

#4647: [v3.0] Keep dynamic imports in CommonJS output (@lukastaegert)

#4649: [v3.0] Change default for systemNullSetters (@lukastaegert)

#4651: [v3.0] use compiler target ES2020 (@dnalborczyk)

Source code(tar.gz)
Source code(zip)
v2.79.1(Sep 22, 2022)
2022-09-22

Bug Fixes

Avoid massive performance degradation when creating thousands of chunks (#4643)

Pull Requests

#4639: fix: typo docs and contributors link in CONTRIBUTING.md (@takurinton)

#4641: Update type definition of resolveId (@ivanjonas)

#4643: Improve performance of chunk naming collision check (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v2.79.0(Aug 31, 2022)
2022-08-31

Features

Add amd.forceJsExtensionForImports to enforce using .js extensions for relative AMD imports (#4607)

Pull Requests

#4607: add option to keep extensions for amd (@wh1tevs)

Source code(tar.gz)
Source code(zip)
v2.78.1(Aug 19, 2022)
2022-08-19

Bug Fixes

Avoid inferring "arguments" as name for a default export placeholder variable (#4613)

Pull Requests

#4613: Prevent using arguments for generated variable names (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v2.78.0(Aug 14, 2022)
2022-08-14

Features

Support writing plugin hooks as objects with a "handler" property (#4600)

Allow changing execution order per plugin hook (#4600)

Add flag to execute plugins in async parallel hooks sequentially (#4600)

Pull Requests

#4600: Allow using objects as hooks to change execution order (@lukastaegert)

Source code(tar.gz)
Source code(zip)
v2.77.3(Aug 11, 2022)
2022-08-11

Bug Fixes

Correctly resolve preserveModulesRoot in Vite (#4591)

Pull Requests

#4591: resolve currentPath (@cleverpp)

Source code(tar.gz)
Source code(zip)
v2.77.2(Jul 27, 2022)
2022-07-27

Bug Fixes

Avoid a rendering failure when mixing outputs with inlined and non-inlined dynamic imports (#4589)

Pull Requests

#4589: Handle generating non-inlined imports after inlined ones (@lukastaegert)

Source code(tar.gz)
Source code(zip)