0.17.2

• Add onDispose to the plugin API (#2140, #2205)

  If your plugin wants to perform some cleanup after it's no longer going to be used, you can now use the onDispose API to register a callback for cleanup-related tasks. For example, if a plugin starts a long-running child process then it may want to terminate that process when the plugin is discarded. Previously there was no way to do this. Here's an example:

  let examplePlugin = {
    name: 'example',
    setup(build) {
      build.onDispose(() => {
        console.log('This plugin is no longer used')
      })
    },
  }
  

  These onDispose callbacks will be called after every build() call regardless of whether the build failed or not as well as after the first dispose() call on a given build context.

0.17.1

• Make it possible to cancel a build (#2725)

  The context object introduced in version 0.17.0 has a new cancel() method. You can use it to cancel a long-running build so that you can start a new one without needing to wait for the previous one to finish. When this happens, the previous build should always have at least one error and have no output files (i.e. it will be a failed build).

  Using it might look something like this:

  • JS:

    let ctx = await esbuild.context({
      // ...
    })
    
    let rebuildWithTimeLimit = timeLimit => {
      let timeout = setTimeout(() => ctx.cancel(), timeLimit)
      return ctx.rebuild().finally(() => clearTimeout(timeout))
    }
    
    let build = await rebuildWithTimeLimit(500)
    

  • Go:

    ctx, err := api.Context(api.BuildOptions{
      // ...
    })
    if err != nil {
      return
    }
    
    rebuildWithTimeLimit := func(timeLimit time.Duration) api.BuildResult {
      t := time.NewTimer(timeLimit)
      go func() {
        <-t.C
        ctx.Cancel()
      }()
      result := ctx.Rebuild()
      t.Stop()
      return result
    }
    
    build := rebuildWithTimeLimit(500 * time.Millisecond)
    

  This API is a quick implementation and isn't maximally efficient, so the build may continue to do some work for a little bit before stopping. For example, I have added stop points between each top-level phase of the bundler and in the main module graph traversal loop, but I haven't added fine-grained stop points within the internals of the linker. How quickly esbuild stops can be improved in future releases. This means you'll want to wait for cancel() and/or the previous rebuild() to finish (i.e. await the returned promise in JavaScript) before starting a new build, otherwise rebuild() will give you the just-canceled build that still hasn't ended yet. Note that onEnd callbacks will still be run regardless of whether or not the build was canceled.

• Fix server-sent events without servedir (#2827)

  The server-sent events for live reload were incorrectly using servedir to calculate the path to modified output files. This means events couldn't be sent when servedir wasn't specified. This release uses the internal output directory (which is always present) instead of servedir (which might be omitted), so live reload should now work when servedir is not specified.

• Custom entry point output paths now work with the copy loader (#2828)

  Entry points can optionally provide custom output paths to change the path of the generated output file. For example, esbuild foo=abc.js bar=xyz.js --outdir=out generates the files out/foo.js and out/bar.js. However, this previously didn't work when using the copy loader due to an oversight. This bug has been fixed. For example, you can now do esbuild foo=abc.html bar=xyz.html --outdir=out --loader:.html=copy to generate the files out/foo.html and out/bar.html.

• The JS API can now take an array of objects (#2828)

  Previously it was not possible to specify two entry points with the same custom output path using the JS API, although it was possible to do this with the Go API and the CLI. This will not cause a collision if both entry points use different extensions (e.g. if one uses .js and the other uses .css). You can now pass the JS API an array of objects to work around this API limitation:

  // The previous API didn't let you specify duplicate output paths
  let result = await esbuild.build({
    entryPoints: {
      // This object literal contains a duplicate key, so one is ignored
      'dist': 'foo.js',
      'dist': 'bar.css',
    },
  })
  
  // You can now specify duplicate output paths as an array of objects
  let result = await esbuild.build({
    entryPoints: [
      { in: 'foo.js', out: 'dist' },
      { in: 'bar.css', out: 'dist' },
    ],
  })
  

0.16.17

• Fix additional comment-related regressions (#2814)

  This release fixes more edge cases where the new comment preservation behavior that was added in 0.16.14 could introduce syntax errors. Specifically:

  x = () => (/* comment */ {})
  for ((/* comment */ let).x of y) ;
  function *f() { yield (/* comment */class {}) }
  

  These cases caused esbuild to generate code with a syntax error in version 0.16.14 or above. These bugs have now been fixed.

0.16.13

• Publish a new bundle visualization tool

  While esbuild provides bundle metadata via the --metafile flag, previously esbuild left analysis of it completely up to third-party tools (well, outside of the rudimentary --analyze flag). However, the esbuild website now has a built-in bundle visualization tool:

  • https://esbuild.github.io/analyze/

  You can pass --metafile to esbuild to output bundle metadata, then upload that JSON file to this tool to visualize your bundle. This is helpful for answering questions such as:

  • Which packages are included in my bundle?
  • How did a specific file get included?
  • How small did a specific file compress to?
  • Was a specific file tree-shaken or not?

  I'm publishing this tool because I think esbuild should provide some answer to "how do I visualize my bundle" without requiring people to reach for third-party tools. At the moment the tool offers two types of visualizations: a radial "sunburst chart" and a linear "flame chart". They serve slightly different but overlapping use cases (e.g. the sunburst chart is more keyboard-accessible while the flame chart is easier with the mouse). This tool may continue to evolve over time.

• Fix --metafile and --mangle-cache with --watch (#1357)

  The CLI calls the Go API and then also writes out the metafile and/or mangle cache JSON files if those features are enabled. This extra step is necessary because these files are returned by the Go API as in-memory strings. However, this extra step accidentally didn't happen for all builds after the initial build when watch mode was enabled. This behavior used to work but it was broken in version 0.14.18 by the introduction of the mangle cache feature. This release fixes the combination of these features, so the metafile and mangle cache features should now work with watch mode. This behavior was only broken for the CLI, not for the JS or Go APIs.

• Add an original field to the metafile

  The metadata file JSON now has an additional field: each import in an input file now contains the pre-resolved path in the original field in addition to the post-resolved path in the path field. This means it's now possible to run certain additional analysis over your bundle. For example, you should be able to use this to detect when the same package subpath is represented multiple times in the bundle, either because multiple versions of a package were bundled or because a package is experiencing the dual-package hazard.

2022

All esbuild versions published in the year 2022 (versions 0.14.11 through 0.16.12) can be found in CHANGELOG-2022.md.

2021

All esbuild versions published in the year 2021 (versions 0.8.29 through 0.14.10) can be found in CHANGELOG-2021.md.

2020

All esbuild versions published in the year 2020 (versions 0.3.0 through 0.8.28) can be found in CHANGELOG-2020.md.