renovate[bot] commented 2 years ago

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
esbuild	`0.14.42` -> `0.14.48`

Release Notes

evanw/esbuild

### [`v0.14.48`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#01448) [Compare Source](https://togithub.com/evanw/esbuild/compare/v0.14.47...v0.14.48) - Enable using esbuild in Deno via WebAssembly ([#2323](https://togithub.com/evanw/esbuild/issues/2323)) The native implementation of esbuild is much faster than the WebAssembly version, but some people don't want to give Deno the `--allow-run` permission necessary to run esbuild and are ok waiting longer for their builds to finish when using the WebAssembly backend. With this release, you can now use esbuild via WebAssembly in Deno. To do this you will need to import from `wasm.js` instead of `mod.js`: ```js import * as esbuild from 'https://deno.land/x/esbuild@v0.14.48/wasm.js' const ts = 'let test: boolean = true' const result = await esbuild.transform(ts, { loader: 'ts' }) console.log('result:', result) ``` Make sure you run Deno with `--allow-net` so esbuild can download the WebAssembly module. Using esbuild like this starts up a worker thread that runs esbuild in parallel (unless you call `esbuild.initialize({ worker: false })` to tell esbuild to run on the main thread). If you want to, you can call `esbuild.stop()` to terminate the worker if you won't be using esbuild anymore and you want to reclaim the memory. Note that Deno appears to have a bug where background WebAssembly optimization can prevent the process from exiting for many seconds. If you are trying to use Deno and WebAssembly to run esbuild quickly, you may need to manually call `Deno.exit(0)` after your code has finished running. - Add support for font file MIME types ([#2337](https://togithub.com/evanw/esbuild/issues/2337)) This release adds support for font file MIME types to esbuild, which means they are now recognized by the built-in local web server and they are now used when a font file is loaded using the `dataurl` loader. The full set of newly-added file extension MIME type mappings is as follows: - `.eot` => `application/vnd.ms-fontobject` - `.otf` => `font/otf` - `.sfnt` => `font/sfnt` - `.ttf` => `font/ttf` - `.woff` => `font/woff` - `.woff2` => `font/woff2` - Remove `"use strict";` when targeting ESM ([#2347](https://togithub.com/evanw/esbuild/issues/2347)) All ES module code is automatically in strict mode, so a `"use strict";` directive is unnecessary. With this release, esbuild will now remove the `"use strict";` directive if the output format is ESM. This change makes the generated output file a few bytes smaller: ```js // Original code 'use strict' export let foo = 123 // Old output (with --format=esm --minify) "use strict";let t=123;export{t as foo}; // New output (with --format=esm --minify) let t=123;export{t as foo}; ``` - Attempt to have esbuild work with Deno on FreeBSD ([#2356](https://togithub.com/evanw/esbuild/issues/2356)) Deno doesn't support FreeBSD, but it's possible to build Deno for FreeBSD with some additional patches on top. This release of esbuild changes esbuild's Deno installer to download esbuild's FreeBSD binary in this situation. This configuration is unsupported although in theory everything should work. - Add some more target JavaScript engines ([#2357](https://togithub.com/evanw/esbuild/issues/2357)) This release adds the [Rhino](https://togithub.com/mozilla/rhino) and [Hermes](https://hermesengine.dev/) JavaScript engines to the set of engine identifiers that can be passed to the `--target` flag. You can use this to restrict esbuild to only using JavaScript features that are supported on those engines in the output files that esbuild generates. ### [`v0.14.47`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#01447) [Compare Source](https://togithub.com/evanw/esbuild/compare/v0.14.46...v0.14.47) - Make global names more compact when `||=` is available ([#2331](https://togithub.com/evanw/esbuild/issues/2331)) With this release, the code esbuild generates for the `--global-name=` setting is now slightly shorter when you don't configure esbuild such that the `||=` operator is unsupported (e.g. with `--target=chrome80` or `--supported:logical-assignment=false`): ```js // Original code exports.foo = 123 // Old output (with --format=iife --global-name=foo.bar.baz --minify) var foo=foo||{};foo.bar=foo.bar||{};foo.bar.baz=(()=>{var b=(a,o)=>()=>(o||a((o={exports:{}}).exports,o),o.exports);var c=b(f=>{f.foo=123});return c();})(); // New output (with --format=iife --global-name=foo.bar.baz --minify) var foo;((foo||={}).bar||={}).baz=(()=>{var b=(a,o)=>()=>(o||a((o={exports:{}}).exports,o),o.exports);var c=b(f=>{f.foo=123});return c();})(); ``` - Fix `--mangle-quoted=false` with `--minify-syntax=true` If property mangling is active and `--mangle-quoted` is disabled, quoted properties are supposed to be preserved. However, there was a case when this didn't happen if `--minify-syntax` was enabled, since that internally transforms `x['y']` into `x.y` to reduce code size. This issue has been fixed: ```js // Original code x.foo = x['bar'] = { foo: y, 'bar': z } // Old output (with --mangle-props=. --mangle-quoted=false --minify-syntax=true) x.a = x.b = { a: y, bar: z }; // New output (with --mangle-props=. --mangle-quoted=false --minify-syntax=true) x.a = x.bar = { a: y, bar: z }; ``` Notice how the property `foo` is always used unquoted but the property `bar` is always used quoted, so `foo` should be consistently mangled while `bar` should be consistently not mangled. - Fix a minification bug regarding `this` and property initializers When minification is enabled, esbuild attempts to inline the initializers of variables that have only been used once into the start of the following expression to reduce code size. However, there was a bug where this transformation could change the value of `this` when the initializer is a property access and the start of the following expression is a call expression. This release fixes the bug: ```js // Original code function foo(obj) { let fn = obj.prop; fn(); } // Old output (with --minify) function foo(f){f.prop()} // New output (with --minify) function foo(o){let f=o.prop;f()} ``` ### [`v0.14.46`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#01446) [Compare Source](https://togithub.com/evanw/esbuild/compare/v0.14.45...v0.14.46) - Add the ability to override support for individual syntax features ([#2060](https://togithub.com/evanw/esbuild/issues/2060), [#2290](https://togithub.com/evanw/esbuild/issues/2290), [#2308](https://togithub.com/evanw/esbuild/issues/2308)) The `target` setting already lets you configure esbuild to restrict its output by only making use of syntax features that are known to be supported in the configured target environment. For example, setting `target` to `chrome50` causes esbuild to automatically transform optional chain expressions into the equivalent older JavaScript and prevents you from using BigInts, among many other things. However, sometimes you may want to customize this set of unsupported syntax features at the individual feature level. Some examples of why you might want to do this: - JavaScript runtimes often do a quick implementation of newer syntax features that is slower than the equivalent older JavaScript, and you can get a speedup by telling esbuild to pretend this syntax feature isn't supported. For example, V8 has a [long-standing performance bug regarding object spread](https://bugs.chromium.org/p/v8/issues/detail?id=11536) that can be avoided by manually copying properties instead of using object spread syntax. Right now esbuild hard-codes this optimization if you set `target` to a V8-based runtime. - There are many less-used JavaScript runtimes in addition to the ones present in browsers, and these runtimes sometimes just decide not to implement parts of the specification, which might make sense for runtimes intended for embedded environments. For example, the developers behind Facebook's JavaScript runtime [Hermes](https://hermesengine.dev/) have decided to not implement classes despite it being a major JavaScript feature that was added seven years ago and that is used in virtually every large JavaScript project. - You may be processing esbuild's output with another tool, and you may want esbuild to transform certain features and the other tool to transform certain other features. For example, if you are using esbuild to transform files individually to ES5 but you are then feeding the output into Webpack for bundling, you may want to preserve `import()` expressions even though they are a syntax error in ES5. With this release, you can now use `--supported:feature=false` to force `feature` to be unsupported. This will cause esbuild to either rewrite code that uses the feature into older code that doesn't use the feature (if esbuild is able to), or to emit a build error (if esbuild is unable to). For example, you can use `--supported:arrow=false` to turn arrow functions into function expressions and `--supported:bigint=false` to make it an error to use a BigInt literal. You can also use `--supported:feature=true` to force it to be supported, which means esbuild will pass it through without transforming it. Keep in mind that this is an advanced feature. For most use cases you will probably want to just use `target` instead of using this. The full set of currently-allowed features are as follows: **JavaScript:** - `arbitrary-module-namespace-names` - `array-spread` - `arrow` - `async-await` - `async-generator` - `bigint` - `class` - `class-field` - `class-private-accessor` - `class-private-brand-check` - `class-private-field` - `class-private-method` - `class-private-static-accessor` - `class-private-static-field` - `class-private-static-method` - `class-static-blocks` - `class-static-field` - `const-and-let` - `default-argument` - `destructuring` - `dynamic-import` - `exponent-operator` - `export-star-as` - `for-await` - `for-of` - `generator` - `hashbang` - `import-assertions` - `import-meta` - `logical-assignment` - `nested-rest-binding` - `new-target` - `node-colon-prefix-import` - `node-colon-prefix-require` - `nullish-coalescing` - `object-accessors` - `object-extensions` - `object-rest-spread` - `optional-catch-binding` - `optional-chain` - `regexp-dot-all-flag` - `regexp-lookbehind-assertions` - `regexp-match-indices` - `regexp-named-capture-groups` - `regexp-sticky-and-unicode-flags` - `regexp-unicode-property-escapes` - `rest-argument` - `template-literal` - `top-level-await` - `typeof-exotic-object-is-object` - `unicode-escapes` **CSS:** - `hex-rgba` - `rebecca-purple` - `modern-rgb-hsl` - `inset-property` - `nesting` Since you can now specify `--supported:object-rest-spread=false` yourself to work around the V8 performance issue mentioned above, esbuild will no longer automatically transform all instances of object spread when targeting a V8-based JavaScript runtime going forward. *Note that JavaScript feature transformation is very complex and allowing full customization of the set of supported syntax features could cause bugs in esbuild due to new interactions between multiple features that were never possible before. Consider this to be an experimental feature.* - Implement `extends` constraints on `infer` type variables ([#2330](https://togithub.com/evanw/esbuild/issues/2330)) TypeScript 4.7 introduced the ability to write an `extends` constraint after an `infer` type variable, which looks like this: ```ts type FirstIfString = T extends [infer S extends string, ...unknown[]] ? S : never; ``` You can read the blog post for more details: https://devblogs.microsoft.com/typescript/announcing-typescript-4-7/#extends-constraints-on-infer-type-variables. Previously this was a syntax error in esbuild but with this release, esbuild can now parse this syntax correctly. - Allow `define` to match optional chain expressions ([#2324](https://togithub.com/evanw/esbuild/issues/2324)) Previously esbuild's `define` feature only matched member expressions that did not use optional chaining. With this release, esbuild will now also match those that use optional chaining: ```js // Original code console.log(a.b, a?.b) // Old output (with --define:a.b=c) console.log(c, a?.b); // New output (with --define:a.b=c) console.log(c, c); ``` This is for compatibility with Webpack's [`DefinePlugin`](https://webpack.js.org/plugins/define-plugin/), which behaves the same way. ### [`v0.14.45`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#01445) [Compare Source](https://togithub.com/evanw/esbuild/compare/v0.14.44...v0.14.45) - Add a log message for ambiguous re-exports ([#2322](https://togithub.com/evanw/esbuild/issues/2322)) In JavaScript, you can re-export symbols from another file using `export * from './another-file'`. When you do this from multiple files that export different symbols with the same name, this creates an ambiguous export which is causes that name to not be exported. This is harmless if you don't plan on using the ambiguous export name, so esbuild doesn't have a warning for this. But if you do want a warning for this (or if you want to make it an error), you can now opt-in to seeing this log message with `--log-override:ambiguous-reexport=warning` or `--log-override:ambiguous-reexport=error`. The log message looks like this: ▲ [WARNING] Re-export of "common" in "example.js" is ambiguous and has been removed [ambiguous-reexport] One definition of "common" comes from "a.js" here: a.js:2:11: 2 │ export let common = 2 ╵ ~~~~~~ Another definition of "common" comes from "b.js" here: b.js:3:14: 3 │ export { b as common } ╵ ~~~~~~ - Optimize the output of the JSON loader ([#2161](https://togithub.com/evanw/esbuild/issues/2161)) The `json` loader (which is enabled by default for `.json` files) parses the file as JSON and generates a JavaScript file with the parsed expression as the `default` export. This behavior is standard and works in both node and the browser (well, as long as you use an [import assertion](https://v8.dev/features/import-assertions)). As an extension, esbuild also allows you to import additional top-level properties of the JSON object directly as a named export. This is beneficial for tree shaking. For example: ```js import { version } from 'esbuild/package.json' console.log(version) ``` If you bundle the above code with esbuild, you'll get something like the following: ```js // node_modules/esbuild/package.json var version = "0.14.44"; // example.js console.log(version); ``` Most of the `package.json` file is irrelevant and has been omitted from the output due to tree shaking. The way esbuild implements this is to have the JavaScript file that's generated from the JSON look something like this with a separate exported variable for each property on the top-level object: ```js // node_modules/esbuild/package.json export var name = "esbuild"; export var version = "0.14.44"; export var repository = "https://github.com/evanw/esbuild"; export var bin = { esbuild: "bin/esbuild" }; ... export default { name, version, repository, bin, ... }; ``` However, this means that if you import the `default` export instead of a named export, you will get non-optimal output. The `default` export references all top-level properties, leading to many unnecessary variables in the output. With this release esbuild will now optimize this case to only generate additional variables for top-level object properties that are actually imported: ```js // Original code import all, { bar } from 'data:application/json,{"foo":[1,2,3],"bar":[4,5,6]}' console.log(all, bar) // Old output (with --bundle --minify --format=esm) var a=[1,2,3],l=[4,5,6],r={foo:a,bar:l};console.log(r,l); // New output (with --bundle --minify --format=esm) var l=[4,5,6],r={foo:[1,2,3],bar:l};console.log(r,l); ``` Notice how there is no longer an unnecessary generated variable for `foo` since it's never imported. And if you only import the `default` export, esbuild will now reproduce the original JSON object in the output with all top-level properties compactly inline. - Add `id` to warnings returned from the API With this release, warnings returned from esbuild's API now have an `id` property. This identifies which kind of log message it is, which can be used to more easily filter out certain warnings. For example, reassigning a `const` variable will generate a message with an `id` of `"assign-to-constant"`. This also gives you the identifier you need to apply a log override for that kind of message: https://esbuild.github.io/api/#log-override. ### [`v0.14.44`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#01444) [Compare Source](https://togithub.com/evanw/esbuild/compare/v0.14.43...v0.14.44) - Add a `copy` loader ([#2255](https://togithub.com/evanw/esbuild/issues/2255)) You can configure the "loader" for a specific file extension in esbuild, which is a way of telling esbuild how it should treat that file. For example, the `text` loader means the file is imported as a string while the `binary` loader means the file is imported as a `Uint8Array`. If you want the imported file to stay a separate file, the only option was previously the `file` loader (which is intended to be similar to Webpack's [`file-loader`](https://v4.webpack.js.org/loaders/file-loader/) package). This loader copies the file to the output directory and imports the path to that output file as a string. This is useful for a web application because you can refer to resources such as `.png` images by importing them for their URL. However, it's not helpful if you need the imported file to stay a separate file but to still behave the way it normally would when the code is run without bundling. With this release, there is now a new loader called `copy` that copies the loaded file to the output directory and then rewrites the path of the import statement or `require()` call to point to the copied file instead of the original file. This will automatically add a content hash to the output name by default (which can be configured with the `--asset-names=` setting). You can use this by specifying `copy` for a specific file extension, such as with `--loader:.png=copy`. - Fix a regression in arrow function lowering ([#2302](https://togithub.com/evanw/esbuild/pull/2302)) This release fixes a regression with lowering arrow functions to function expressions in ES5. This feature was introduced in version 0.7.2 and regressed in version 0.14.30. In JavaScript, regular `function` expressions treat `this` as an implicit argument that is determined by how the function is called, but arrow functions treat `this` as a variable that is captured in the closure from the surrounding lexical scope. This is emulated in esbuild by storing the value of `this` in a variable before changing the arrow function into a function expression. However, the code that did this didn't treat `this` expressions as a usage of that generated variable. Version 0.14.30 began omitting unused generated variables, which caused the transformation of `this` to break. This regression happened due to missing test coverage. With this release, the problem has been fixed: ```js // Original code function foo() { return () => this } // Old output (with --target=es5) function foo() { return function() { return _this; }; } // New output (with --target=es5) function foo() { var _this = this; return function() { return _this; }; } ``` This fix was contributed by [@nkeynes](https://togithub.com/nkeynes). - Allow entity names as define values ([#2292](https://togithub.com/evanw/esbuild/issues/2292)) The "define" feature allows you to replace certain expressions with certain other expressions at compile time. For example, you might want to replace the global identifier `IS_PRODUCTION` with the boolean value `true` when building for production. Previously the only expressions you could substitute in were either identifier expressions or anything that is valid JSON syntax. This limitation exists because supporting more complex expressions is more complex (for example, substituting in a `require()` call could potentially pull in additional files, which would need to be handled). With this release, you can now also now define something as a member expression chain of the form `foo.abc.xyz`. - Implement package self-references ([#2312](https://togithub.com/evanw/esbuild/issues/2312)) This release implements a rarely-used feature in node where a package can import itself by name instead of using relative imports. You can read more about this feature here: https://nodejs.org/api/packages.html#self-referencing-a-package-using-its-name. For example, assuming the `package.json` in a given package looks like this: ```json // package.json { "name": "a-package", "exports": { ".": "./main.mjs", "./foo": "./foo.js" } } ``` Then any module in that package can reference an export in the package itself: ```js // ./a-module.mjs import { something } from 'a-package'; // Imports "something" from ./main.mjs. ``` Self-referencing is also available when using `require`, both in an ES module, and in a CommonJS one. For example, this code will also work: ```js // ./a-module.js const { something } = require('a-package/foo'); // Loads from ./foo.js. ``` - Add a warning for assigning to an import ([#2319](https://togithub.com/evanw/esbuild/issues/2319)) Import bindings are immutable in JavaScript, and assigning to them will throw an error. So instead of doing this: ```js import { foo } from 'foo' foo++ ``` You need to do something like this instead: ```js import { foo, setFoo } from 'foo' setFoo(foo + 1) ``` This is already an error if you try to bundle this code with esbuild. However, this was previously allowed silently when bundling is disabled, which can lead to confusion for people who don't know about this aspect of how JavaScript works. So with this release, there is now a warning when you do this: ▲ [WARNING] This assignment will throw because "foo" is an import [assign-to-import] example.js:2:0: 2 │ foo++ ╵ ~~~ Imports are immutable in JavaScript. To modify the value of this import, you must export a setter function in the imported file (e.g. "setFoo") and then import and call that function here instead. This new warning can be turned off with `--log-override:assign-to-import=silent` if you don't want to see it. - Implement `alwaysStrict` in `tsconfig.json` ([#2264](https://togithub.com/evanw/esbuild/issues/2264)) This release adds `alwaysStrict` to the set of TypeScript `tsconfig.json` configuration values that esbuild supports. When this is enabled, esbuild will forbid syntax that isn't allowed in strict mode and will automatically insert `"use strict";` at the top of generated output files. This matches the behavior of the TypeScript compiler: https://www.typescriptlang.org/tsconfig#alwaysStrict. ### [`v0.14.43`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#01443) [Compare Source](https://togithub.com/evanw/esbuild/compare/v0.14.42...v0.14.43) - Fix TypeScript parse error whe a generic function is the first type argument ([#2306](https://togithub.com/evanw/esbuild/issues/2306)) In TypeScript, the `<<` token may need to be split apart into two `<` tokens if it's present in a type argument context. This was already correctly handled for all type expressions and for identifier expressions such as in the following code: ```ts // These cases already worked in the previous release let foo: Array<() => T>; bar<() => T>; ``` However, normal expressions of the following form were previously incorrectly treated as syntax errors: ```ts // These cases were broken but have now been fixed foo.bar<() => T>; foo?.<() => T>(); ``` With this release, these cases now parsed correctly. - Fix minification regression with pure IIFEs ([#2279](https://togithub.com/evanw/esbuild/issues/2279)) An Immediately Invoked Function Expression (IIFE) is a function call to an anonymous function, and is a way of introducing a new function-level scope in JavaScript since JavaScript lacks a way to do this otherwise. And a pure function call is a function call with the special `/* @__PURE__ */` comment before it, which tells JavaScript build tools that the function call can be considered to have no side effects (and can be removed if it's unused). Version 0.14.9 of esbuild introduced a regression that changed esbuild's behavior when these two features were combined. If the IIFE body contains a single expression, the resulting output still contained that expression instead of being empty. This is a minor regression because you normally wouldn't write code like this, so this shouldn't come up in practice, and it doesn't cause any correctness issues (just larger-than-necessary output). It's unusual that you would tell esbuild "remove this if the result is unused" and then not store the result anywhere, since the result is unused by construction. But regardless, the issue has now been fixed. For example, the following code is a pure IIFE, which means it should be completely removed when minification is enabled. Previously it was replaced by the contents of the IIFE but it's now completely removed: ```js // Original code /* @__PURE__ */ (() => console.log(1))() // Old output (with --minify) console.log(1); // New output (with --minify) ``` - Add log messages for indirect `require` references ([#2231](https://togithub.com/evanw/esbuild/issues/2231)) A long time ago esbuild used to warn about indirect uses of `require` because they break esbuild's ability to analyze the dependencies of the code and cause dependencies to not be bundled, resulting in a potentially broken bundle. However, this warning was removed because many people wanted the warning to be removed. Some packages have code that uses `require` like this but on a code path that isn't used at run-time, so their code still happens to work even though the bundle is incomplete. For example, the following code will *not* bundle `bindings`: ```js // Prevent React Native packager from seeing modules required with this const nodeRequire = require; function getRealmConstructor(environment) { switch (environment) { case "node.js": case "electron": return nodeRequire("bindings")("realm.node").Realm; } } ``` Version 0.11.11 of esbuild removed this warning, which means people no longer have a way to know at compile time whether their bundle is broken in this way. Now that esbuild has custom log message levels, this warning can be added back in a way that should make both people happy. With this release, there is now a log message for this that defaults to the `debug` log level, which normally isn't visible. You can either do `--log-override:indirect-require=warning` to make this log message a warning (and therefore visible) or use `--log-level=debug` to see this and all other `debug` log messages.

Configuration

📅 Schedule: Branch creation - "before 3am on the first day of the month" (UTC), Automerge - At any time (no schedule defined).

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

[ ] If you want to rebase/retry this PR, click this checkbox.

This PR has been generated by Mend Renovate. View repository job log here.

gitpod-io[bot] commented 2 years ago

codecov[bot] commented 2 years ago

Codecov Report

Merging #142 (75d3df9) into develop (dd33727) will not change coverage. The diff coverage is n/a.

@@           Coverage Diff            @@
##           develop     #142   +/-   ##
========================================
  Coverage    82.89%   82.89%           
========================================
  Files           14       14           
  Lines          345      345           
  Branches        60       60           
========================================
  Hits           286      286           
  Misses          54       54           
  Partials         5        5

Continue to review full report at Codecov.

Legend - Click here to learn more Δ = absolute <relative> (impact), ø = not affected, ? = missing data Powered by Codecov. Last update dd33727...75d3df9. Read the comment docs.