@esbuild/android-arm
Advanced tools
Changelog
0.19.12
The "preserve" JSX mode now preserves JSX text verbatim (#3605)
The JSX specification deliberately doesn't specify how JSX text is supposed to be interpreted and there is no canonical way to interpret JSX text. Two most popular interpretations are Babel and TypeScript. Yes they are different (esbuild deliberately follows TypeScript by the way).
Previously esbuild normalized text to the TypeScript interpretation when the "preserve" JSX mode is active. However, "preserve" should arguably reproduce the original JSX text verbatim so that whatever JSX transform runs after esbuild is free to interpret it however it wants. So with this release, esbuild will now pass JSX text through unmodified:
// Original code
let el =
<a href={'/'} title=''"'> some text
{foo}
more text </a>
// Old output (with --loader=jsx --jsx=preserve)
let el = <a href="/" title={`'"`}>
{" some text"}
{foo}
{"more text "}
</a>;
// New output (with --loader=jsx --jsx=preserve)
let el = <a href={"/"} title=''"'> some text
{foo}
more text </a>;
Allow JSX elements as JSX attribute values
JSX has an obscure feature where you can use JSX elements in attribute position without surrounding them with {...}
. It looks like this:
let el = <div data-ab=<><a/><b/></>/>;
I think I originally didn't implement it even though it's part of the JSX specification because it previously didn't work in TypeScript (and potentially also in Babel?). However, support for it was silently added in TypeScript 4.8 without me noticing and Babel has also since fixed their bugs regarding this feature. So I'm adding it to esbuild too now that I know it's widely supported.
Keep in mind that there is some ongoing discussion about removing this feature from JSX. I agree that the syntax seems out of place (it does away with the elegance of "JSX is basically just XML with {...}
escapes" for something arguably harder to read, which doesn't seem like a good trade-off), but it's in the specification and TypeScript and Babel both implement it so I'm going to have esbuild implement it too. However, I reserve the right to remove it from esbuild if it's ever removed from the specification in the future. So use it with caution.
Fix a bug with TypeScript type parsing (#3574)
This release fixes a bug with esbuild's TypeScript parser where a conditional type containing a union type that ends with an infer type that ends with a constraint could fail to parse. This was caused by the "don't parse a conditional type" flag not getting passed through the union type parser. Here's an example of valid TypeScript code that previously failed to parse correctly:
type InferUnion<T> = T extends { a: infer U extends number } | infer U extends number ? U : never
All esbuild versions published in the year 2022 (versions 0.16.13 through 0.19.11) can be found in CHANGELOG-2023.md.
All esbuild versions published in the year 2022 (versions 0.14.11 through 0.16.12) can be found in CHANGELOG-2022.md.
All esbuild versions published in the year 2021 (versions 0.8.29 through 0.14.10) can be found in CHANGELOG-2021.md.
All esbuild versions published in the year 2020 (versions 0.3.0 through 0.8.28) can be found in CHANGELOG-2020.md.
Changelog
0.18.20
Support advanced CSS @import
rules (#953, #3137)
CSS @import
statements have been extended to allow additional trailing tokens after the import path. These tokens sort of make the imported file behave as if it were wrapped in a @layer
, @supports
, and/or @media
rule. Here are some examples:
@import url(foo.css);
@import url(foo.css) layer;
@import url(foo.css) layer(bar);
@import url(foo.css) layer(bar) supports(display: flex);
@import url(foo.css) layer(bar) supports(display: flex) print;
@import url(foo.css) layer(bar) print;
@import url(foo.css) supports(display: flex);
@import url(foo.css) supports(display: flex) print;
@import url(foo.css) print;
You can read more about this advanced syntax here. With this release, esbuild will now bundle @import
rules with these trailing tokens and will wrap the imported files in the corresponding rules. Note that this now means a given imported file can potentially appear in multiple places in the bundle. However, esbuild will still only load it once (e.g. on-load plugins will only run once per file, not once per import).
Changelog
0.18.14
Implement local CSS names (#20)
This release introduces two new loaders called global-css
and local-css
and two new pseudo-class selectors :local()
and :global()
. This is a partial implementation of the popular CSS modules approach for avoiding unintentional name collisions in CSS. I'm not calling this feature "CSS modules" because although some people in the community call it that, other people in the community have started using "CSS modules" to refer to something completely different and now CSS modules is an overloaded term.
Here's how this new local CSS name feature works with esbuild:
Identifiers that look like .className
and #idName
are global with the global-css
loader and local with the local-css
loader. Global identifiers are the same across all files (the way CSS normally works) but local identifiers are different between different files. If two separate CSS files use the same local identifier .button
, esbuild will automatically rename one of them so that they don't collide. This is analogous to how esbuild automatically renames JS local variables with the same name in separate JS files to avoid name collisions.
It only makes sense to use local CSS names with esbuild when you are also using esbuild's bundler to bundle JS files that import CSS files. When you do that, esbuild will generate one export for each local name in the CSS file. The JS code can import these names and use them when constructing HTML DOM. For example:
// app.js
import { outerShell } from './app.css'
const div = document.createElement('div')
div.className = outerShell
document.body.appendChild(div)
/* app.css */
.outerShell {
position: absolute;
inset: 0;
}
When you bundle this with esbuild app.js --bundle --loader:.css=local-css --outdir=out
you'll now get this (notice how the local CSS name outerShell
has been renamed):
// out/app.js
(() => {
// app.css
var outerShell = "app_outerShell";
// app.js
var div = document.createElement("div");
div.className = outerShell;
document.body.appendChild(div);
})();
/* out/app.css */
.app_outerShell {
position: absolute;
inset: 0;
}
This feature only makes sense to use when bundling is enabled both because your code needs to import
the renamed local names so that it can use them, and because esbuild needs to be able to process all CSS files containing local names in a single bundling operation so that it can successfully rename conflicting local names to avoid collisions.
If you are in a global CSS file (with the global-css
loader) you can create a local name using :local()
, and if you are in a local CSS file (with the local-css
loader) you can create a global name with :global()
. So the choice of the global-css
loader vs. the local-css
loader just sets the default behavior for identifiers, but you can override it on a case-by-case basis as necessary. For example:
:local(.button) {
color: red;
}
:global(.button) {
color: blue;
}
Processing this CSS file with esbuild with either the global-css
or local-css
loader will result in something like this:
.stdin_button {
color: red;
}
.button {
color: blue;
}
The names that esbuild generates for local CSS names are an implementation detail and are not intended to be hard-coded anywhere. The only way you should be referencing the local CSS names in your JS or HTML is with an import
statement in JS that is bundled with esbuild, as demonstrated above. For example, when --minify
is enabled esbuild will use a different name generation algorithm which generates names that are as short as possible (analogous to how esbuild minifies local identifiers in JS).
You can easily use both global CSS files and local CSS files simultaneously if you give them different file extensions. For example, you could pass --loader:.css=global-css
and --loader:.module.css=local-css
to esbuild so that .css
files still use global names by default but .module.css
files use local names by default.
Keep in mind that the css
loader is different than the global-css
loader. The :local
and :global
annotations are not enabled with the css
loader and will be passed through unchanged. This allows you to have the option of using esbuild to process CSS containing while preserving these annotations. It also means that local CSS names are disabled by default for now (since the css
loader is currently the default for CSS files). The :local
and :global
syntax may be enabled by default in a future release.
Note that esbuild's implementation does not currently have feature parity with other implementations of modular CSS in similar tools. This is only a preliminary release with a partial implementation that includes some basic behavior to get the process started. Additional behavior may be added in future releases. In particular, this release does not implement:
composes
pragma@container
, @counter-style
, etc.Issue #20 (the issue for this feature) is esbuild's most-upvoted issue! While this release still leaves that issue open, it's an important first step in that direction.
Parse :is
, :has
, :not
, and :where
in CSS
With this release, esbuild will now parse the contents of these pseudo-class selectors as a selector list. This means you will now get syntax warnings within these selectors for invalid selector syntax. It also means that esbuild's CSS nesting transform behaves slightly differently than before because esbuild is now operating on an AST instead of a token stream. For example:
/* Original code */
div {
:where(.foo&) {
color: red;
}
}
/* Old output (with --target=chrome90) */
:where(.foo:is(div)) {
color: red;
}
/* New output (with --target=chrome90) */
:where(div.foo) {
color: red;
}
Changelog
0.18.13
Add the --drop-labels=
option (#2398)
If you want to conditionally disable some development-only code and have it not be present in the final production bundle, right now the most straightforward way of doing this is to use the --define:
flag along with a specially-named global variable. For example, consider the following code:
function main() {
DEV && doAnExpensiveCheck()
}
You can build this for development and production like this:
esbuild --define:DEV=true
esbuild --define:DEV=false
One drawback of this approach is that the resulting code crashes if you don't provide a value for DEV
with --define:
. In practice this isn't that big of a problem, and there are also various ways to work around this.
However, another approach that avoids this drawback is to use JavaScript label statements instead. That's what the --drop-labels=
flag implements. For example, consider the following code:
function main() {
DEV: doAnExpensiveCheck()
}
With this release, you can now build this for development and production like this:
esbuild
esbuild --drop-labels=DEV
This means that code containing optional development-only checks can now be written such that it's safe to run without any additional configuration. The --drop-labels=
flag takes comma-separated list of multiple label names to drop.
Avoid causing unhandledRejection
during shutdown (#3219)
All pending esbuild JavaScript API calls are supposed to fail if esbuild's underlying child process is unexpectedly terminated. This can happen if SIGINT
is sent to the parent node
process with Ctrl+C, for example. Previously doing this could also cause an unhandled promise rejection when esbuild attempted to communicate this failure to its own child process that no longer exists. This release now swallows this communication failure, which should prevent this internal unhandled promise rejection. This change means that you can now use esbuild's JavaScript API with a custom SIGINT
handler that extends the lifetime of the node
process without esbuild's internals causing an early exit due to an unhandled promise rejection.
Update browser compatibility table scripts
The scripts that esbuild uses to compile its internal browser compatibility table have been overhauled. Briefly:
caniuse-lite
and @mdn/browser-compat-data
as new data sources (replacing manually-copied information)This change means it's now much easier to keep esbuild's internal compatibility tables up to date. You can review the table changes here if you need to debug something about this change: