Next-generation ES module bundler

Related tags

Bundlers rollup
Overview

Rollup

npm version install size code coverage backers sponsors license dependency status Join the chat at https://is.gd/rollup_chat

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]

Sponsors

Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [Become a sponsor]

License

MIT

Comments
  • Avoid lazy parsing by adding parens around factory

    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

    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...

    <!-- a.html -->
    <script src='shared.js'></script>
    <script src='a.js'></script>
    
    <!-- b.html -->
    <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

    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

    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?

    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

    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

    painful to get started

    This project needs some better tutorials or examples. Here's my use case:

    1. I have code written in ES2015; I am using Babel to transpile
    2. I am also using npm dependencies
    3. These dependencies (mainly) use CommonJS instead of ES2015 modules
    4. This is a test runner with a programmatic API
    5. 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:

    1. In what order the plugins are supposed to run
    2. If order actually matters (though I'm pretty sure it does)
    3. Why the CommonJS plugin and NPM plugin are separated at all
    4. How to configure the Babel plugin to work with the above two plugins
    5. Why the Babel plugin is necessary
    6. Where Babel's responsibilities end and Rollup's begin--don't you need Babel to use import statements anyway?
    7. If/when Browserify or Webpack is necessary
    8. How to configure Karma to make my tests run in a browser
    9. 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)
    10. 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

    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'

    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.

    [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

    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

    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

    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`

    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

    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`

    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)

  • 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)

  • 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)
Owner
Rollup
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.
Rollup
📦🚀 Blazing fast, zero configuration web application bundler

Features ?? Blazing fast bundle times - multicore compilation, and a filesystem cache for fast rebuilds even after a restart. ?? Out of the box suppor

Parcel 41.8k Jan 4, 2023
📦 Zero-configuration bundler for tiny modules.

Microbundle The zero-configuration bundler for tiny modules, powered by Rollup. Guide → Setup ✯ Formats ✯ Modern Mode ✯ Usage & Configuration ✯ All Op

Jason Miller 7.4k Dec 28, 2022
A blazing fast js bundler/loader with a comprehensive API :fire:

A bundler that does it right FuseBox on slack FUSEBOX v4 is out! Install: npm install fuse-box --save-dev import { fusebox } from 'fuse-box'; fusebox

null 4k Dec 30, 2022
Next-generation ES module bundler

Rollup Overview Rollup is a module bundler for JavaScript which compiles small pieces of code into something larger and more complex, such as a librar

Rollup 22.7k Jan 4, 2023
on-demand module bundler thingy

lurantis An HTTP server that bundles and serves packages from NPM; "bundler as a service." Usage Run the server: npx lurantis --port 8080 Then, send G

Lily Scott 6 Feb 21, 2022
Webpack is an open-source JavaScript module bundler. This includes basic setup files to help me not redo all the setups for webpack when starting a new project.

Webpack Setup Webpack is an open-source JavaScript module bundler. It is made primarily for JavaScript, but it can transform front-end assets such as

Nemwel Boniface 14 Jun 23, 2022
An npm package for demonstration purposes using TypeScript to build for both the ECMAScript Module format (i.e. ESM or ES Module) and CommonJS Module format. It can be used in Node.js and browser applications.

An npm package for demonstration purposes using TypeScript to build for both the ECMAScript Module format (i.e. ESM or ES Module) and CommonJS Module format. It can be used in Node.js and browser applications.

Snyk Labs 57 Dec 28, 2022
A next-generation package manager for the front-end

Duo is a next-generation package manager that blends the best ideas from Component, Browserify and Go to make organizing and writing front-end code qu

Duo 3.4k Dec 28, 2022
Next-generation DOM manipulation

Ractive.js - Next-generation DOM manipulation Have any questions or just want to chat? Join us on GitHub Discussions! What is Ractive.js? It's a JavaS

Ractive.js 5.9k Jan 3, 2023
Next generation frontend tooling. It's fast!

Vite ⚡ Next Generation Frontend Tooling ?? Instant Server Start ⚡️ Lightning Fast HMR ??️ Rich Features ?? Optimized Build ?? Universal Plugin Interfa

vite 51.2k Jan 5, 2023
The next generation Javascript WYSIWYG HTML Editor.

Froala Editor V3 Froala WYSIWYG HTML Editor is one of the most powerful JavaScript rich text editors ever. Slim - only add the plugins that you need (

Froala 5k Jan 1, 2023
🐠 Babel is a compiler for writing next generation JavaScript.

The compiler for writing next generation JavaScript. Supporting Babel Babel (pronounced "babble") is a community-driven project used by many companies

Babel 41.8k Jan 9, 2023
Next-generation DOM manipulation

Ractive.js - Next-generation DOM manipulation Have any questions or just want to chat? Join us on GitHub Discussions! What is Ractive.js? It's a JavaS

Ractive.js 5.9k Jan 4, 2023
A next-generation code testing stack for JavaScript.

Intern Software testing for humans ⚠️ This documentation is for the development version of Intern. For the current release version, go here. Intern is

Intern: next-gen JavaScript testing 4.4k Jan 7, 2023
ğŸŽ‰ Next Generation API-first CMS for developers. Generate an API-first CMS from a GraphQL schema with offline prototyping and an inline editor

Tipe Next Generation API-first CMS Design your content Shape and design content for any project you and your team are working on. Create your content

Tipe 2.2k Oct 22, 2021
Next-generation ORM for Node.js & TypeScript | PostgreSQL, MySQL, MariaDB, SQL Server & SQLite

Prisma Quickstart • Website • Docs • Examples • Blog • Slack • Twitter • Prisma 1 What is Prisma? Prisma is a next-generation ORM that consists of the

Prisma 28k Jan 2, 2023
🐠 Babel is a compiler for writing next generation JavaScript.

The compiler for writing next generation JavaScript. Supporting Babel Babel (pronounced "babble") is a community-driven project used by many companies

Babel 41.8k Jan 8, 2023
hell.js 🚀 🚀 A JavaScript framework for the 🔥 next 🔥 generation. 🚀

hell.js ?? ?? A JavaScript framework for the ?? next ?? generation. ??

null 31 Oct 3, 2022
A Next + TypeScript Starter. Featuring Styled-Components, ESLint, Prettier, Axe a11y monitoring, Fathom analytics, sitemap generation, and more!

Next + TypeScript Starter A Next + TypeScript Starter by Justin Juno. Featuring Styled-Components, ESLint, Prettier, Axe a11y monitoring, Fathom analy

Justin Juno 11 Dec 13, 2022