Hello JavaScript Enthusiasts!
Welcome to a new edition of “This Week in JavaScript“!
This week, we’ll be lookin into Biome’s game-changing v2 release, celebrate the baseline availability of JSON modules across modern browsers, explore Astro’s move toward dynamic content, and review some exciting tool releases from Hono, MockRTC, and more.
Biome v2 is coming for ESLint and Prettier
Biome v2, codenamed Biotype, is officially out and it’s big news. For the first time, a JavaScript and TypeScript linter can offer type-aware rules without relying on the TypeScript compiler. This reduces the need for TypeScript as a dependency, improving performance while preserving advanced linting capabilities.
One standout feature is the noFloatingPromises rule, which already detects 75% of the issues caught by typescript-eslint, but at a fraction of the performance cost. This is powered by Biome’s newly introduced multi-file analysis and custom type inference engine.
Biome 2.0 also introduces Assist actions, such as import organization and attribute sorting, without diagnostics. Support for monorepos is now significantly better with nested config files, and a new HTML formatter (still experimental) can now handle .html files, bringing Biome closer to supporting Vue and Svelte templates in the future.
Migrating is simple with a built-in migrate command:
npm install --save-dev --save-exact @biomejs/biome
npx @biomejs/biome migrate --write
With Vercel backing the type inference work, Biome is signaling its intent to compete seriously with ESLint and Prettier.
JSON Module Scripts Are Now Baseline in All Major Browsers
The long-requested feature to import JSON as a module is now finally supported across all modern browsers, enabled via import attributes. This marks a big step for standard module behavior on the web, making it easier than ever to work with structured data directly inside JavaScript.
Instead of fetching and parsing JSON manually, you can now write:
import data from ‘./foo.json’ with { type: ‘json’ };
This feature comes from the Import Attributes proposal, which enables passing metadata alongside imports to tell the JavaScript engine how to treat the file. It was split from the original proposal into a separate track to speed up adoption, and now JSON modules are the first to become baseline.
Security concerns around MIME type mismatches led to this explicit declaration approach, ensuring that modules like JSON or CSS don’t execute arbitrary code. Future extensions may include support for CSS and HTML modules using the same mechanism. Dynamic imports and re-exports also support the new syntax:
import("./config.json", { with: { type: "json" } })
This change enhances interoperability and simplifies frontend workflows by aligning the module system more closely with what developers expect from modern toolchains like Vite and Webpack.
9 New JavaScript Features in ES2025
ES2025 introduces nine powerful JavaScript features that streamline data manipulation, regular expressions, module imports, and numerical operations. Here’s a quick breakdown of what’s coming:
1. RegExp.escape() – A new static method to safely escape user-inputted strings for use inside regular expressions.
const escaped = RegExp.escape("Hello.");
const re = new RegExp(escaped, 'g');
2. Float16Array – A new typed array that enables 16-bit floating-point operations. Perfect for GPU work, color processing, and memory-sensitive applications.
3. Promise.try() – A more ergonomic way to safely wrap sync or async functions and handle errors immediately.
Promise.try(() => mightThrow()).then(...).catch(...);
4. Iterator Helpers – Additions like .map(), .filter(), .reduce(), .toArray() on native iterators make them much more powerful and array-like.
5. JSON Modules – Now standardized and handled via import attributes, allowing JSON imports to behave predictably and securely.
6. Import Attributes – A syntax improvement to pass metadata along with module imports, like the type of file being imported.
import data from "./file.json" with { type: "json" };
7. RegExp Pattern Modifiers – Support for enabling or disabling regex flags inline within subpatterns.
const re = /^(?i:[a-z])[a-z]$/;
8. New Set Methods – Mathematical operations like .union(), .intersection(), .difference(), and .isSubsetOf() bring power-user capabilities to sets.
9. Duplicate Named Capturing Groups – JavaScript will now support using the same named capture group in multiple parts of a pattern without throwing an error.
These improvements make JavaScript more powerful and expressive for data-heavy, UI-rich, and performance-sensitive applications.
Astro 5.10: Live Content Collections and Stable Responsive Images
Astro 5.10 ships with an exciting new experimental feature: live content collections. Unlike static content that gets compiled at build time, live collections fetch data at runtime. This means your content can now reflect real-time updates, user preferences, or dynamic filters.
This feature is ideal for sites where data changes frequently or is user-specific. Instead of rebuilding your site for every change, live collections let you serve fresh content on demand, improving flexibility without sacrificing performance when static data is sufficient.
Also now stable are Astro’s responsive images. These automatically generate optimized image variants and srcsets, helping you reduce layout shifts and improve Core Web Vitals. This is especially useful for performance-focused builds and image-heavy layouts.
Additional updates include CSP improvements, a customizable Cloudflare Workers entrypoint, and enhanced error handling for live content collections using predictable result objects.
Bun v1.2.16: File Routing and Memory Leak Fixes
Bun 1.2.16 introduces support for returning files directly in route handlers using Bun.serve. This allows developers to easily serve static files without manually reading or buffering them.
The update includes 73 bugfixes, memory leak patches, and over 100 additional Node.js compatibility tests. Notably, memory leaks in N-API handle scopes and piped stdio from Bun.spawn have been fixed, improving stability in long-running processes. A new hashing API, Bun.hash.rapidhash, also debuts, promising faster hash computations.
Additional updates include support for vm.SyntheticModule, HTTPParser bindings, and improvements to the bun outdated command, making Bun more versatile for modern web app workflows.
Tools & Releases You Should Know About
LogTape: Structured Logging Across All Runtimes
LogTape is a zero-dependency logging library that works seamlessly in Node, Deno, Bun, browsers, and edge runtimes. It supports structured logging, redaction of sensitive data, template literals for log formatting, and a hierarchical category system for fine-grained log levels.
Its standout feature is the ease of extending it with custom sinks, allowing you to ship logs wherever you want. Whether building a logging solution for a library or a full-stack application, LogTape provides a flexible and consistent API.
Hono: A Lightning-Fast Web Framework That Runs Anywhere
Hono is a tiny and ultrafast web framework built on Web Standards. It works everywhere – Cloudflare Workers, Deno, Vercel, Node, Bun, and more.
With first-class TypeScript support, Hono offers batteries-included middleware, blazing-fast RegExp routing (no linear scans), and a delightful developer experience. Its hono/tiny preset weighs in at under 12kB, making it one of the most lightweight full-featured frameworks out there. If you’re building edge-native apps or APIs, Hono is definitely worth a look.
MockRTC: Mock and Test WebRTC Like a Pro
MockRTC gives developers the power to intercept and mock WebRTC connections for testing, debugging, or simulating failure conditions. It can capture traffic, inject behaviors, and even hook into live WebRTC sessions without modifying production code.
You can simulate real peers, automate tests, or create proxy layers for transformation or monitoring. MockRTC’s hook functions make integration seamless, and its assertion capabilities help verify edge-case behaviors with confidence. It’s a must-have for teams working on real-time communication platforms.
And that’s it for the fortieth issue of “This Week in JavaScript.“
Feel free to share this newsletter with a fellow developer, and make sure you’re subscribed to get notified about the next issue.
Until next time, happy coding!
