size-limit

What is size-limit?

Size Limit is a performance monitoring tool for JavaScript projects. It helps you keep your project within a specific size limit by analyzing the size of your JavaScript bundles and providing warnings when the size exceeds the specified limit.

What are size-limit's main functionalities?

Bundle Size Analysis

This feature allows you to specify the path to your JavaScript bundle and set a size limit. Size Limit will analyze the bundle and ensure it does not exceed the specified limit.

module.exports = [
  {
    path: 'dist/bundle.js',
    limit: '500 KB'
  }
];

Custom Configurations

You can customize the analysis by enabling gzip compression or disabling the running of the bundle. This provides more flexibility in how you measure the size of your bundles.

module.exports = [
  {
    path: 'dist/bundle.js',
    limit: '500 KB',
    gzip: true,
    running: false
  }
];

Multiple Bundles

Size Limit supports analyzing multiple bundles in a single configuration. This is useful for projects with multiple entry points or output files.

module.exports = [
  {
    path: 'dist/bundle1.js',
    limit: '300 KB'
  },
  {
    path: 'dist/bundle2.js',
    limit: '200 KB'
  }
];

Other packages similar to size-limit

webpack-bundle-analyzer

Webpack Bundle Analyzer is a tool that visualizes the size of webpack output files with an interactive zoomable treemap. It provides a detailed breakdown of the bundle contents, making it easier to identify large modules and optimize the bundle size. Unlike Size Limit, it focuses more on visualization and detailed analysis rather than enforcing size limits.

bundlesize

Bundlesize is a tool that lets you set size limits for your JavaScript bundles and reports the size of the bundles in your CI/CD pipeline. It is similar to Size Limit in that it enforces size limits, but it integrates more tightly with CI/CD workflows and provides a simpler configuration.

source-map-explorer

Source Map Explorer analyzes JavaScript bundles using source maps to determine which files contribute to the bundle size. It provides a detailed breakdown of the bundle contents, similar to Webpack Bundle Analyzer, but it relies on source maps for its analysis. This makes it useful for understanding the impact of individual source files on the final bundle size.

README

Size Limit

Size Limit is a tool to prevent JavaScript libraries bloat. With it, you know exactly for how many kilobytes your JS library increases the user bundle.

You can add Size Limit to your continuous integration service (such as Travis CI) and set the limit. If you accidentally add a massive dependency, Size Limit will throw an error.

Size Limit could tell you not only library size. With --why argument it can tell you why your library has this size and show real cost of all your internal dependencies.

To be really accurate, Size Limit create empty webpack project in memory. Then it adds your library as dependency to this project and calculate real cost of your libraries including all dependencies and webpack’s polyfills for process, etc.

Who Uses Size Limit

• Autoprefixer
• PostCSS
• MobX
• JSS
• Logux

Usage

First, install size-limit:

$ npm install --save-dev size-limit

Here's how you can get the size for your current project:

$ ./node_modules/bin/size-limit

  Package size: 8.46 KB
  With all dependencies, minified and gzipped

If your project size starts to look bloated, run Webpack Bundle Analyzer for analysis:

./node_modules/bin/size-limit --why

Now, let's set the limit. Determine the current size of your library, add just a little bit (a kilobyte, maybe) and use that as a limit when adding the script to package.json:

  "scripts": {
    "test": "jest && eslint .",
+    "size": "size-limit 9KB"
  }

Add the size script to your test suite:

  "scripts": {
-    "test": "jest && eslint .",
+    "test": "jest && eslint . && npm run size",
    "size": "size-limit 9KB"
  }

If you don't have a continuous integration service running, don’t forget to add one — start with Travis CI.

JavaScript API

const getSize = require('size-limit')

const index = path.join(__dirname, 'index.js')
const extra = path.join(__dirname, 'extra.js')

getSize([index, extra]).then(size => {
  if (size > 1 * 1024 * 1024) {
    console.error('Project is now larger than 1MB!')
  }
})

Comparison with bundlesize

Main difference between Size Limit and bundlesize, that Size Limit uses webpack to build bundle. It has more accurate result and can show you what and why causes the bloat.

1. Size Limit has the --why mode to run Webpack Bundle Analyzer — this way, you can see what went wrong in a nice graphical representation.
2. Instead of bundlesize, Size Limit prevents the most popular source of libraries bloat — unexpected huge dependency.
3. Also Size Limit prevents increasing library size because of wrong process or path usage, when webpack will add big unnecessary polyfill.
4. Size Limit runs only on first CI job, so it is more respectful to CI resources.