UNPKG

168 kBMarkdownView Raw
1# `react-router`
2
3## v8.5.2
4
5### Patch Changes
6
7- Keep navigation metadata consistent after a submission action throws an error ([#15621](https://github.com/remix-run/react-router/pull/15621))
8 - Use the committed history action for loader `dataStrategy` navigation types and loading navigation history actions
9- Cancel the discarded response body for `HEAD` requests, so a resource route streaming a file no longer leaks its file descriptor ([#15634](https://github.com/remix-run/react-router/pull/15634))
10 - Keep observing nested deferred promise rejections after cancelling a data response so they cannot crash the server
11- Preserve streamed `<Suspense>` boundaries during hydration in development ([#15382](https://github.com/remix-run/react-router/pull/15382))
12 - Wrap the critical CSS reset in `React.startTransition` to prevent React 19 from silently discarding the server HTML and rendering the boundary on the client
13- Fix submissions to root form actions containing search parameters or a hash when a `basename` is configured ([#15725](https://github.com/remix-run/react-router/pull/15725))
14- Fix `href()` to throw for `null` required parameters and omit `null` splat parameters without a trailing slash, matching the behavior for `undefined` and the defined types ([#15754](https://github.com/remix-run/react-router/pull/15754))
15- Fix generated `MetaArgs.matches` types to stop at the current route instead of appending an unknown, possibly undefined tail ([#15697](https://github.com/remix-run/react-router/pull/15697))
16- Improve path generation and URL validation across `href()`, `generatePath()`, links, forms, fetchers, and redirects ([#15785](https://github.com/remix-run/react-router/pull/15785))
17- Stop `redirect()`, `redirectDocument()` and `replace()` from setting `status: 302` on the `ResponseInit` passed to them ([#15753](https://github.com/remix-run/react-router/pull/15753))
18 - Later responses created from the same init object no longer get status 302, and a frozen init no longer throws
19- Clear an `<Await>` render error when it receives a new `resolve` value, so the error element no longer stays on screen after navigating to a route whose data renders fine ([#15695](https://github.com/remix-run/react-router/pull/15695))
20- Run `clientMiddleware` during RSC client navigations and preserve it when route components update via HMR ([#15763](https://github.com/remix-run/react-router/pull/15763))
21- Handle `HEAD` resource responses consistently in RSC Framework and RSC Data modes ([#15783](https://github.com/remix-run/react-router/pull/15783))
22- Fix initial rendering of RSC routes with a `clientLoader` and no `HydrateFallback` ([#15763](https://github.com/remix-run/react-router/pull/15763))
23- Fix `<ScrollRestoration>` throwing an uncaught error before hydration when `sessionStorage` is unavailable ([#15566](https://github.com/remix-run/react-router/pull/15566))
24 - The inline restore script already logged the storage error, but its cleanup call accessed `sessionStorage` again and threw (e.g. Chrome with "Block all cookies", sandboxed cross-origin iframes)
25 - The error is still logged with `console.error`; only the second, uncaught throw is removed
26- Fix `useBlocker` leaving behind a stale blocker that keeps blocking navigation after its component is hidden and shown again with `<Activity>`, or after the router is recreated ([#15710](https://github.com/remix-run/react-router/pull/15710))
27
28## v8.5.1
29
30### Patch Changes
31
32- Fix `URIError: URI malformed` when an `ssr: false` dev server receives a URL path with a malformed percent-encoding ([#15649](https://github.com/remix-run/react-router/pull/15649))
33- Bound server route manifest processing for paths with expensive route expansion ([#15703](https://github.com/remix-run/react-router/pull/15703))
34 - Fall back to initial route discovery during server rendering and RSC document/data requests
35 - Account for the number and depth of candidate branches when using regex matching
36- Encode commas within paths sent to the lazy route discovery manifest endpoint so routes with commas in their paths are discovered correctly ([#15640](https://github.com/remix-run/react-router/pull/15640))
37- Fix fetcher revalidation errors bubbling to the root error boundary instead of the nearest boundary above the route that owns the fetcher ([#15676](https://github.com/remix-run/react-router/pull/15676))
38- Avoid duplicate history entries when posting a `<Form>` to the current URL with an encoded `action` ([#15679](https://github.com/remix-run/react-router/pull/15679))
39 - Replace the current history entry when the `action` contains characters that get percent-encoded, such as spaces or non-ASCII characters
40- Fix an unhandled promise rejection when the browser skips a `viewTransition` navigation, for example in a hidden tab ([#15582](https://github.com/remix-run/react-router/pull/15582))
41- Bubble rejected `lazy.Component` imports on loader-less routes to the nearest error boundary ([#15658](https://github.com/remix-run/react-router/pull/15658))
42 - Render the error boundary instead of a blank page
43- Preserve pending fetcher mutation revalidation when an older navigation or background reload completes to prevent stale loader data ([#15686](https://github.com/remix-run/react-router/pull/15686))
44 - Keep newer fetcher loads cancellable and preserve them when earlier revalidations finish or abort, preventing older responses from overwriting fresh fetcher data
45- Retry rejected `lazy` route imports instead of caching failures permanently ([#15689](https://github.com/remix-run/react-router/pull/15689))
46- Revalidate loader data when a fetcher action redirect is not followed ([#15557](https://github.com/remix-run/react-router/pull/15557))
47 - Revalidate when an action redirect is ignored because a newer navigation started or the fetcher unmounted while the action was running
48 - Include shared parent loaders when another navigation completed while the action was running
49 - Continue to respect `shouldRevalidate`
50 - Return fetchers to `idle` when a revalidation completes a pending navigation started by another fetcher's redirect
51- Avoid adding an incompatible `document.startViewTransition()` overload to the global `Document` type ([#15680](https://github.com/remix-run/react-router/pull/15680))
52 - Allow transition results to be assigned to the DOM `ViewTransition` type
53- Skip `deleteData` in `destroySession` when the session has no ID ([#15639](https://github.com/remix-run/react-router/pull/15639))
54 - Avoid failures when destroying a session without a cookie on storage that rejects an empty key
55- Surface the host's 404 response when a SPA fallback route has no prerendered data ([#15646](https://github.com/remix-run/react-router/pull/15646))
56 - Request single-fetch `.data` files for hydrating routes with a server `loader` in an `ssr: false` app with a `prerender` config
57 - Avoid the internal "No result found for routeId" error for non-prerendered parameterized paths served via the SPA fallback
58- Improve turbo-stream decoding validation and object property handling ([18e1fbd](https://github.com/remix-run/react-router/commit/18e1fbd))
59
60### Unstable Changes
61
62⚠️ _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
63
64- Add an opt-in `<Await unstable_promise={promise}>` implementation based on React's `use()` API ([#15678](https://github.com/remix-run/react-router/pull/15678))
65 - Use `React.use` instead of React Router's internal promise tracking
66 - Accept promise-like values and retain `errorElement`, `useAsyncValue`, and `useAsyncError` support
67 - Handle only promise rejections with `errorElement` when using `unstable_promise`, allowing child render errors to bubble to the nearest React error boundary
68 - Track streamed promises during decoding so settled server content stays visible during hydration updates with either Await API or direct `React.use()`
69- Fix `URIError: URI malformed` when an API-only (`ssr: "unstable_api-only"`) server receives a URL path with a malformed percent-encoding ([#15649](https://github.com/remix-run/react-router/pull/15649))
70- Fix duplicate headers when throwing a redirect from an RSC server function ([#15667](https://github.com/remix-run/react-router/pull/15667))
71
72## v8.5.0
73
74### Minor Changes
75
76- Deprecate React Router's view transition APIs in favor of React's `<ViewTransition>` component, available in React 19.3 and later ([#15493](https://github.com/remix-run/react-router/pull/15493))
77 - Deprecate the `viewTransition` props/options, `useViewTransitionState`, and `NavLink`'s `isTransitioning` render prop and `transitioning` class
78 - Preserve existing behavior, including support for older React versions
79 - See the [migration guide](https://reactrouter.com/how-to/view-transitions) for a navigation example and compatibility considerations
80
81### Patch Changes
82
83- Fix `<Await>` failing to server render promises decoded from an RSC payload, which caused the Suspense boundary to switch to client rendering ([#15597](https://github.com/remix-run/react-router/pull/15597))
84- Declare `@types/react` and `@types/react-dom` as optional peer dependencies so the shipped type definitions resolve React types under strict (non-hoisted) node_modules layouts ([#15528](https://github.com/remix-run/react-router/pull/15528))
85- Fix the `unstable_useRouterState` documentation example to call the imported alias ([#15535](https://github.com/remix-run/react-router/pull/15535))
86- Render the `HydrateFallback` of a route discovered through `patchRoutesOnNavigation` during initial hydration ([#15537](https://github.com/remix-run/react-router/pull/15537))
87 - Routes discovered during initial hydration are now exposed in `state.matches` while their loaders run, so `<RouterProvider>` renders down to the discovered route's `HydrateFallback` instead of rendering nothing
88- Fix router state recovery when updates occur before `RouterProvider` subscribes, including when other subscribers are already attached, and report current client errors once without replaying server errors during hydration ([#15637](https://github.com/remix-run/react-router/pull/15637))
89- Fix `matchPath` not treating a static segment as optional when it contains characters outside `[\w-]` ([#15425](https://github.com/remix-run/react-router/pull/15425))
90- Fix an RSC server crash when a client aborts a document request while the HTML stream waits for the RSC payload ([#15612](https://github.com/remix-run/react-router/pull/15612))
91- Stop revalidating a fetcher after `fetcher.reset()`, so its cleared data no longer comes back on the next revalidation ([#15633](https://github.com/remix-run/react-router/pull/15633))
92
93### Unstable Changes
94
95⚠️ _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
96
97- Add an `unstable_fetch` prop to `<HydratedRouter>` to customize JavaScript-issued manifest and server data requests in conventional Framework Mode ([#15586](https://github.com/remix-run/react-router/pull/15586))
98 - The function receives the intended request as well as context identifying the type of request
99 - Data request context includes `navigationType` (`"PUSH"`, `"REPLACE"`, or `"POP"` for navigation-initiated requests, including reloaded fetchers; `null` otherwise)
100 - Data strategies receive equivalent metadata through `unstable_initiator` and `unstable_navigationType`
101 - The custom fetch context is a discriminated union, so narrowing `type` to `"navigation"` guarantees a non-null `navigationType`, while other data requests have a `null` `navigationType`
102 - Fetchers reloaded after an initialization redirect retain the `"initialization"` type and include their fetcher key
103 - Like other router initialization options, the implementation is captured when the singleton router is created and thus subsequent prop changes are ignored
104 - Browser-managed data prefetches from `<Link prefetch>` use native `<link rel="prefetch">` elements and do not call the custom implementation
105 - Use the callback for custom fetch options, custom headers, safe request retries, or response header inspection
106 - Return response bodies unchanged so React Router can decode its manifest and Turbo Stream data protocols
107- Support API-only Framework Mode with runtime server data loading, actions, revalidation, and lazy route discovery ([#15601](https://github.com/remix-run/react-router/pull/15601))
108 - Hydrate prerendered pages from build-time data and fetch server loader data when hydrating a SPA fallback
109 - Preserve normal loader revalidation and server-action support for eagerly loaded and lazily discovered routes, and honor loader opt-outs when making server data requests
110- Add `unstable_useRouteDiscovery` for application-controlled route discovery in conventional Framework Mode ([#15602](https://github.com/remix-run/react-router/pull/15602))
111 - Discover selected destinations or load the running client's full route manifest without loading route modules
112 - Compose manifest-mismatch handlers, with shared recovery and cancellation that preserves application state
113 - Keep full-manifest failures catchable without rendering error boundaries, whether mismatch handlers use the hook or event's `loadAllRoutes()`
114 - Cancel pending revalidation alongside a canceled navigation, retaining existing data and settling interrupted fetchers before restoring Back/Forward history
115 - Enable `future.unstable_customRouteDiscovery` to opt in
116 - Apps without the flag retain existing discovery behavior
117 - Call `event.defaultBehavior()` from a custom mismatch handler to explicitly run built-in recovery
118- Return middleware short-circuit responses as-is for document requests in RSC modes, including resource routes, instead of decoding non-RSC bodies as Flight ([#15628](https://github.com/remix-run/react-router/pull/15628))
119 - Include server middleware in both eager and lazy RSC route configuration types
120 - Preserve HTML rendering for cached Flight responses returned by middleware, and pass through raw responses that replace the result of `next()`
121
122## v8.4.0
123
124### Minor Changes
125
126- Deprecate the `createStaticRouter({ branches })` option ([#15297](https://github.com/remix-run/react-router/pull/15297))
127 - `createStaticRouter` now caches route branches internally, ignores `branches`, and logs a deprecation warning when the option is provided
128 - The deprecated `EntryContext.branches` property remains available for compatibility but is always an empty array
129
130### Patch Changes
131
132- Prevent stale route discovery during manifest version-mismatch recovery ([#15489](https://github.com/remix-run/react-router/pull/15489))
133 - Keep concurrent manifest responses pending while a document reload is in progress
134 - Report a discovery error when a previous reload failed to resolve a version mismatch instead of loading a stale route or reloading repeatedly
135 - Fail pending requests if a document reload does not complete within five seconds or the document is restored from the back-forward cache, allowing subsequent requests to recover
136- Preserve lazy route module import errors during SPA navigations instead of replacing them with a missing `dataStrategy` result error ([#15464](https://github.com/remix-run/react-router/pull/15464))
137- Switch to more granular internal router contexts to avoid unnecessary route component re-renders when unrelated data router state changes ([#15376](https://github.com/remix-run/react-router/pull/15376))
138 - ⚠️ This contains some breaking changes to exported `UNSAFE_` contexts, so please review carefully if you are using those unsafe exports
139- Correctly escape streamed RSC redirect locations in meta tag attributes ([#15491](https://github.com/remix-run/react-router/pull/15491))
140- Avoid unintended `document.startViewTransition` calls during initial hydration and `router.revalidate()` calls ([#15484](https://github.com/remix-run/react-router/pull/15484))
141- Fix `SingleFetchNoResultError` thrown when a fetcher revalidates against a splat route during lazy route discovery ([#15395](https://github.com/remix-run/react-router/pull/15395))
142 - Track discovery per fetcher load so revalidation waits for the current load's discovery, even when the fetcher key is reused, while still restarting interrupted loaders after discovery completes
143- Preserve the underlying decode failure as the `cause` of the `Unable to decode turbo-stream response` error ([#15450](https://github.com/remix-run/react-router/pull/15450))
144
145### Unstable Changes
146
147⚠️ _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
148
149- Add a Data Mode `future.unstable_routePatternMatching` flag for more efficient route matching powered by `@remix-run/route-pattern` ([#15298](https://github.com/remix-run/react-router/pull/15298))
150 - Add an `unstable_validateParams` route field to reject invalid parameter values and continue matching
151- Document access control requirements for RSC Server Functions ([#15490](https://github.com/remix-run/react-router/pull/15490))
152 - Treat every Server Function as a public endpoint that must perform all of its own access control checks
153 - Recommend route actions when access control should be provided by route middleware
154
155## v8.3.1
156
157### Patch Changes
158
159- Fix `Expected fetcher: <key>` error thrown on navigation when a fetcher is aborted during its post-action revalidation ([#15365](https://github.com/remix-run/react-router/pull/15365))
160- Fix lazy route discovery caching a path as discovered when the triggering navigation was aborted after the manifest response settled but before the route tree was patched, which permanently (for the session) shadowed the real route behind a catch-all or produced 404s on every subsequent visit ([#15399](https://github.com/remix-run/react-router/pull/15399))
161- Improve route matching performance for long paths ([#15417](https://github.com/remix-run/react-router/pull/15417))
162- Improve validation of action request origins ([#15419](https://github.com/remix-run/react-router/pull/15419))
163- Fix `<ScrollRestoration>` leaving `history.scrollRestoration` set to `"auto"` after a bfcache restore, which let the browser restore scroll on subsequent history traversals before the destination route had rendered ([#15397](https://github.com/remix-run/react-router/pull/15397))
164- Properly respect the `relative` option in `useSubmit`/`fetcher.submit` when resolivng the `action` path ([#15400](https://github.com/remix-run/react-router/pull/15400))
165- Add additional URL validation on client side navigations/redirects ([#15445](https://github.com/remix-run/react-router/pull/15445))
166
167## v8.3.0
168
169### Patch Changes
170
171- Encode path params in `href`/`generatePath` per RFC 3986 path-segment rules instead of `encodeURIComponent` ([#15310](https://github.com/remix-run/react-router/pull/15310))
172 - Characters that are valid literally in a path segment (`$ & + , ; = : @` — RFC 3986 `pchar`) are no longer percent-encoded, so values like a semver build `1.0.0+1` interpolate unchanged instead of becoming `1.0.0%2B1`
173 - Structural/unsafe characters (`/ ? # %`, whitespace, non-ASCII) are still escaped exactly as before
174- Use `crypto.randomUUID()` for `createMemorySessionStorage` session ids ([#15302](https://github.com/remix-run/react-router/pull/15302))
175 - `createMemorySessionStorage` is only intended for local development and testing - sessions are lost when the server restarts
176- Fix `NavLink` not applying its `pending` state when `to` has a trailing slash ([#15300](https://github.com/remix-run/react-router/pull/15300))
177- Preserve RSC route component metadata so routes with a `clientLoader` can skip unnecessary server requests once their components have rendered while still fetching missing server-rendered elements ([#15323](https://github.com/remix-run/react-router/pull/15323))
178- Harden RSC CSRF code paths ([#15311](https://github.com/remix-run/react-router/pull/15311))
179- Fix server crash (`TypeError: Invalid state: Unable to enqueue`) when a request is aborted while the RSC HTML stream has a pending flush ([#15286](https://github.com/remix-run/react-router/pull/15286))
180 - Handle cancellation of the `injectRSCPayload` readable side, clear the pending flush, and cancel the underlying RSC payload stream
181
182### Unstable Changes
183
184⚠️ _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
185
186- Detect stale RSC clients during lazy route discovery and reload the destination document ([#15318](https://github.com/remix-run/react-router/pull/15318))
187
188 #### Migration
189
190 Apps using the default RSC Framework entry do not need to make any changes. Apps with a custom `entry.rsc.tsx` should import the generated client version and pass it to `unstable_matchRSCServerRequest`:
191
192 ```tsx
193 import clientVersion from "virtual:react-router/unstable_rsc/client-version";
194
195 return unstable_matchRSCServerRequest({
196 // ...
197 clientVersion,
198 });
199 ```
200
201- Add CSP nonce support to RSC document rendering ([#15320](https://github.com/remix-run/react-router/pull/15320))
202 - Add `nonce` options to `unstable_routeRSCServerRequest` and `unstable_RSCStaticRouter`
203 - Forward the nonce to the HTML renderer and apply it to injected RSC payload scripts and nonce-aware framework components
204
205 To adopt nonce-based CSP, update your `entry.ssr.tsx` (run `react-router reveal entry.ssr` first in RSC Framework Mode) to generate a fresh nonce for each request. Pass it to `routeRSCServerRequest`, spread the `renderHTML` options into React's HTML renderer, pass `options.nonce` to `RSCStaticRouter`, and use the same nonce in the `Content-Security-Policy` response header:
206
207 ```tsx
208 const nonce = crypto.randomUUID();
209 const response = await routeRSCServerRequest({
210 request,
211 serverResponse,
212 createFromReadableStream,
213 nonce,
214 async renderHTML(getPayload, options) {
215 const payload = getPayload();
216 return renderHTMLToReadableStream(
217 <RSCStaticRouter getPayload={getPayload} nonce={options.nonce} />,
218 {
219 ...options,
220 bootstrapScriptContent,
221 formState: await payload.formState,
222 signal: request.signal,
223 },
224 );
225 },
226 });
227 response.headers.set(
228 "Content-Security-Policy",
229 `script-src 'self' 'nonce-${nonce}'`,
230 );
231 ```
232
233## v8.2.0
234
235### Patch Changes
236
237- Fix `href()` to properly stringify and URL-encode param values, matching `generatePath()` ([#15277](https://github.com/remix-run/react-router/pull/15277))
238 - splat params preserve path separators while encoding each segment individually
239- Fix dynamic param extraction for routes with optional static segments ([#15200](https://github.com/remix-run/react-router/pull/15200))
240 - When a route path contains optional static segments (e.g. `/school?/user/:id`), the internal regex's incorrectly shifted parameter indices resulting in incorrect parameter extraction
241 - Consecutive optional static segments (e.g. `/one?/two?`) were only partially handled
242- Preserve navigation blocker state through a revalidation ([#15246](https://github.com/remix-run/react-router/pull/15246))
243- Fix route ranking for dynamic parameters with static extension suffixes ([#15273](https://github.com/remix-run/react-router/pull/15273))
244 - These were not being detected as dynamic param segments and instead got incorrectly scored higher as a static segment
245 - This meant they could potentially tie truly static routes like `/sitemap.xml` and outrank them based on definition order
246 - These are now correctly identified as dynamic parameter segments and scored correctly
247- Use ReactFormState types instead of unknown ([#15263](https://github.com/remix-run/react-router/pull/15263))
248
249## v8.1.0
250
251### Minor Changes
252
253- Return route metadata from server request, client navigation, and client fetcher instrumentations ([#15235](https://github.com/remix-run/react-router/pull/15235))
254 - Adds result metadata after instrumented calls complete, including the URL, matched route pattern, and params
255 - Adds known HTTP status codes to server request handler instrumentation results
256
257## v8.0.1
258
259### Patch Changes
260
261- Remove the obsolete `AppLoadContext` type export accidentally left over from v7 now that middleware is always enabled and server request context is provided through `RouterContextProvider`. ([#15207](https://github.com/remix-run/react-router/pull/15207))
262
263## v8.0.0
264
265### Major Changes
266
267- Remove the `future.v8_trailingSlashAwareDataRequests` flag ([#15100](https://github.com/remix-run/react-router/pull/15100))
268 - Trailing slash-aware data request URLs are now the default behavior.
269- Update `tsconfig.json` `target`/`lib` from `ES2020 -> ES2022` ([591853e](https://github.com/remix-run/react-router/commit/591853e))
270- Switch the published packages in `packages/` to ESM-only. ([#14895](https://github.com/remix-run/react-router/pull/14895)) ([59ebcf1](https://github.com/remix-run/react-router/commit/59ebcf1))
271- Remove deprecated `data` parameter in favor of `loaderData` for `meta` APIs (to align with `Route.ComponentProps`) ([#14931](https://github.com/remix-run/react-router/pull/14931))
272 - `Route.MetaArgs`, `Route.MetaMatch`, `MetaArgs`, `MetaMatch`, `Route.ComponentProps.matches`, `UIMatch`
273- Remove `future.v8_passThroughRequests` flag - the raw incoming `request` is now always passed through to `loader`/`action`. Use `url` for the normalized URL without React Router-specific implementation details (`.data` suffixes, `index`/`_routes` search params). ([#15079](https://github.com/remix-run/react-router/pull/15079))
274- Remove internal `hasErrorBoundary` field added to `router.routes` when using a data router ([#15074](https://github.com/remix-run/react-router/pull/15074))
275 - This should not impact user-facing code since this was an internal prop and was computed based on the presence of `ErrorBoundary` or `errorElement` on your route
276 - `hasErrorBoundary` is no longer accepted on `RouteObject` (`IndexRouteObject`/`NonIndexRouteObject`), `DataRouteObject`, `<Route>` JSX props, or as a key in `lazy` route definitions.
277 - The `MapRoutePropertiesFunction` signature no longer requires returning `hasErrorBoundary`; the router infers it directly.
278- Remove `react-router-dom` package ([#15076](https://github.com/remix-run/react-router/pull/15076))
279 - In v7 everything DOM-specific was collapsed into `react-router/dom`
280 - `react-router-dom` was kept around as a convenience so existing v6 app imports would still work
281 - For v8, you will need to swap `react-router-dom` imports:
282 - `RouterProvider`/`HydratedRouter` should be imported from `react-router/dom`
283 - Everything else should be imported from `react-router`
284- Remove `future.v8_middleware` flag — middleware is always enabled in v8 ([#15078](https://github.com/remix-run/react-router/pull/15078))
285 - The `future.v8_middleware` flag has been removed; middleware is now always enabled
286 - The `context` parameter passed to `loader`, `action`, and `middleware` functions is always a `RouterContextProvider` instance
287 - `getLoadContext` functions in custom servers must return a `RouterContextProvider` — returning a plain object is no longer supported
288 - The `MiddlewareEnabled` type (previously exported as `UNSAFE_MiddlewareEnabled`) has been removed since the conditional it gated is now unconditional
289 - The `Future` module augmentation pattern (`interface Future { v8_middleware: true }`) is no longer needed to type `context` in Data Mode
290- Update minimum Node version to 22.22.0 ([#14928](https://github.com/remix-run/react-router/pull/14928))
291- Update minimum React version to 19.2.7 ([#15062](https://github.com/remix-run/react-router/pull/15062))
292
293### Minor Changes
294
295- Bump dependencies ([#15080](https://github.com/remix-run/react-router/pull/15080))
296 - Bumped `cookie` from `^1.0.1` to `^1.1.1`
297 - Bumped `set-cookie-parser` from `^2.6.0` to `^3.1.0`
298
299### Patch Changes
300
301- Ensure client middleware errors load lazy route error boundaries before bubbling ([#15086](https://github.com/remix-run/react-router/pull/15086))
302- Remove explicit `onSubmit` type override from `SharedFormProps` to fix deprecation warning with `@types/react@19.x` ([#14932](https://github.com/remix-run/react-router/pull/14932)) ([59ebcf1](https://github.com/remix-run/react-router/commit/59ebcf1))
303- Update package builds to preserve individual module files in published artifacts. Public APIs and documented import paths are unchanged. ([#15092](https://github.com/remix-run/react-router/pull/15092))
304 - Updated package TypeScript configs to support modern module syntax used by the build configuration.
305- Migrate package builds from `tsup` to `tsdown`. Published package entry points and public APIs are unchanged. ([#15092](https://github.com/remix-run/react-router/pull/15092))
306- Upgrade React Router's TypeScript tooling to TypeScript 6. Runtime behavior and public APIs are unchanged. ([#15092](https://github.com/remix-run/react-router/pull/15092))
307
308## v7.18.0
309
310### Patch Changes
311
312- Fix server handler prerender responses when using `ssr: false` and `future.v8_trailingSlashAwareDataRequests: true`. Avoids false positive "SPA Mode" detection when serving prerendered paths ([#15173](https://github.com/remix-run/react-router/pull/15173))
313- Use the `ServerRouter` nonce for nonce-aware SSR components when they don't provide their own value so strict CSP pages can load them. ([#15170](https://github.com/remix-run/react-router/pull/15170))
314- Use `turbo-stream` to serialize and deserialize Framework Mode hydration errors ([#15175](https://github.com/remix-run/react-router/pull/15175))
315- Precompute route branch matchers to avoid recompiling route path regexes during matching ([#15186](https://github.com/remix-run/react-router/pull/15186))
316- Use the constructed request URL host when validating action request origins. ([#15185](https://github.com/remix-run/react-router/pull/15185))
317- Remove the un-documented custom error serialization logic from Data Mode SSR built-in hydration flows ([#15175](https://github.com/remix-run/react-router/pull/15175))
318- Validate protocols in RSC render redirects ([#15177](https://github.com/remix-run/react-router/pull/15177))
319- Consolidate url normalization logic and better handle mixed slashes ([#15176](https://github.com/remix-run/react-router/pull/15176))
320
321## v7.17.0
322
323### Minor Changes
324
325- Ship a subset of the official documentation inside the `react-router` package ([#15121](https://github.com/remix-run/react-router/pull/15121))
326 - Markdown docs are now available in `node_modules/react-router/docs`, letting AI coding agents and the React Router agent skills read official docs locally
327 - Excludes auto-generated API docs (`api/`), `community/` content, and tutorials (`tutorials/`)
328
329## v7.16.0
330
331### Minor Changes
332
333- Stabilize `future.unstable_trailingSlashAwareDataRequests` as `future.v8_trailingSlashAwareDataRequests` ([#15098](https://github.com/remix-run/react-router/pull/15098))
334
335### Patch Changes
336
337- Disable manifest path when lazy route dicovery is disabled ([#15068](https://github.com/remix-run/react-router/pull/15068))
338
339- Fix browser URL creation to use the configured history window instead of the global window. ([#15066](https://github.com/remix-run/react-router/pull/15066))
340 - Pass the history/router window through to `createBrowserURLImpl` so custom window contexts keep the correct URL origin.
341
342- Fix `useNavigation()` return type to preserve discriminated union across navigation states ([#15095](https://github.com/remix-run/react-router/pull/15095))
343
344- Widen `MetaDescriptor` `script:ld+json` type from `LdJsonObject` to `LdJsonObject | LdJsonObject[]` to permit multiple JSON-LD schemas in a single `<script type="application/ld+json">` tag emitted by `<Meta />` ([#15082](https://github.com/remix-run/react-router/pull/15082))
345
346## v7.15.1
347
348### Patch Changes
349
350- Update router to operate on fetcher Maps in an immutable manner to avoid delayed React renders from potentially reading an updated but not yet committed Map. This could result in brief flickers in some fetcher-driven optimistic UI scenarios. ([#15028](https://github.com/remix-run/react-router/pull/15028))
351- Fix `serverLoader()` returning stale SSR data when a client navigation aborts pending hydration before the hydration `clientLoader` resolves ([#15022](https://github.com/remix-run/react-router/pull/15022))
352- Fix `RouterProvider` `onError` callback not being called for synchronous initial loader errors in SPA mode ([#15039](https://github.com/remix-run/react-router/pull/15039)) ([#14942](https://github.com/remix-run/react-router/pull/14942))
353- Memoize `useFetchers` to return a stable identity and only change if fetchers changed ([#15028](https://github.com/remix-run/react-router/pull/15028))
354- Internal refactor to consolidate mutation request detection through shared utility ([#15033](https://github.com/remix-run/react-router/pull/15033))
355
356### Unstable Changes
357
358⚠️ _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
359
360- Add a new `unstable_useRouterState()` hook that consolidates access to active and pending router states (RFC: #12358) ([#15017](https://github.com/remix-run/react-router/pull/15017))
361 - Data/Framework/RSC only — throws when used without a data router
362 - This should allow you to consolidate usages of the following hooks which will likely be deprecated and removed in a future major version
363 - `useLocation`
364 - `useSearchParams`
365 - `useParams`
366 - `useMatches`
367 - `useNavigationType`
368 - `useNavigation`
369
370 ```ts
371 let { active, pending } = unstable_useRouterState();
372
373 // Active is always populated with the current location
374 active.location; // replaces `useLocation()`
375 active.searchParams; // replaces `useSearchParams()[0]`
376 active.params; // replaces `useParams()`
377 active.matches; // replaces `useMatches()`
378 active.type; // replaces `useNavigationType()`
379
380 // Pending is only populated during a navigation
381 pending.location; // replaces `useNavigation().location`
382 pending.searchParams; // equivalent to `new URLSearchParams(useNavigation().search)`
383 pending.params; // Not directly accessible today
384 pending.matches; // Not directly accessible today
385 pending.type; // Not directly accessible today
386 pending.state; // replaces `useNavigation().state`
387 pending.formMethod; // replaces useNavigation().formMethod
388 pending.formAction; // replaces useNavigation().formAction
389 pending.formEncType; // replaces useNavigation().formEncType
390 pending.formData; // replaces useNavigation().formData
391 pending.json; // replaces useNavigation().json
392 pending.text; // replaces useNavigation().text
393 ```
394
395## v7.15.0
396
397### Minor Changes
398
399- Stabilize `unstable_defaultShouldRevalidate` as `defaultShouldRevalidate` on `<Link>`, `<Form>`, `useLinkClickHandler`, `useSubmit`, `fetcher.submit`, and `setSearchParams` ([a993f09](https://github.com/remix-run/react-router/commit/a993f09))
400 - ⚠️ This is a breaking change if you have already opted into the unstable version - you will need to update your code accordingly
401
402- Stabilize the instrumentation APIs. `unstable_instrumentations` is now `instrumentations` and `unstable_pattern` is now `pattern` ([a993f09](https://github.com/remix-run/react-router/commit/a993f09))
403 - The `unstable_ServerInstrumentation`, `unstable_ClientInstrumentation`, `unstable_InstrumentRequestHandlerFunction`, `unstable_InstrumentRouterFunction`, `unstable_InstrumentRouteFunction`, and `unstable_InstrumentationHandlerResult` types have had their `unstable_` prefixes removed
404 - ⚠️ This is a breaking change if you have already opted into the unstable version - you will need to update your code accordingly
405
406- Stabilize `unstable_mask` as `mask` on `<Link>`, `useLinkClickHandler`, and `useNavigate`, and rename the corresponding `Location.unstable_mask` field to `Location.mask` ([a993f09](https://github.com/remix-run/react-router/commit/a993f09))
407 - ⚠️ This is a breaking change if you have already opted into the unstable version - you will need to update your code accordingly
408
409- Stabilize the `unstable_normalizePath` option on `staticHandler.query` and `staticHandler.queryRoute` as `normalizePath` ([a993f09](https://github.com/remix-run/react-router/commit/a993f09))
410 - ⚠️ This is a breaking change if you have already opted into the unstable version - you will need to update your code accordingly
411
412- Stabilize `future.unstable_passThroughRequests` as `future.v8_passThroughRequests` ([a993f09](https://github.com/remix-run/react-router/commit/a993f09))
413 - ⚠️ This is a breaking change if you have already opted into the unstable version - you will need to update your code accordingly
414
415- Remove `unstable_subResourceIntegrity` from the runtime `FutureConfig` type; the flag is now controlled by the top-level `subResourceIntegrity` option in `react-router.config.ts` ([a993f09](https://github.com/remix-run/react-router/commit/a993f09))
416 - ⚠️ This is a breaking change if you have already opted into the unstable version - you will need to update your code accordingly
417
418- Stabilize `unstable_url` as `url` on `loader`, `action`, and `middleware` function args ([a993f09](https://github.com/remix-run/react-router/commit/a993f09))
419 - ⚠️ This is a breaking change if you have already opted into the unstable version - you will need to update your code accordingly
420
421- Stabilize `unstable_useTransitions` as `useTransitions` on `<BrowserRouter>`, `<HashRouter>`, `<HistoryRouter>`, `<MemoryRouter>`, `<Router>`, `<RouterProvider>`, `<HydratedRouter>`, and `useLinkClickHandler` ([a993f09](https://github.com/remix-run/react-router/commit/a993f09))
422 - ⚠️ This is a breaking change if you have already opted into the unstable version - you will need to update your code accordingly
423
424### Patch Changes
425
426- Add `nonce` to `<Scripts>` `<link rel="modulepreload">` elements (if provided) ([af5d49b](https://github.com/remix-run/react-router/commit/af5d49b))
427
428- Fix a bug with `unstable_defaultShouldRevalidate={false}` where parent routes that did not export a `shouldRevalidate` function could be incorrectly included in the single fetch call for new child route data ([#15012](https://github.com/remix-run/react-router/pull/15012))
429
430- Improve server-side route matching performance by pre-computing flattened/cached route branches ([#14967](https://github.com/remix-run/react-router/pull/14967)) ([af5d49b](https://github.com/remix-run/react-router/commit/af5d49b))
431 - Performance benchmarks showed roughly a 10-15% improvement in server-side request handling performance
432
433- Mark `mask` as an optional field in `Location` for easier mocking in unit tests ([#14999](https://github.com/remix-run/react-router/pull/14999))
434
435- Cache flattened/ranked route branches to optimize server-side route matching ([#14967](https://github.com/remix-run/react-router/pull/14967))
436
437- Improve route matching performance in Framework/Data Mode ([#14971](https://github.com/remix-run/react-router/pull/14971)) ([af5d49b](https://github.com/remix-run/react-router/commit/af5d49b))
438 - Avoiding unnecessary calls to `matchRoutes` in data router scenarios
439 - This includes adding back the optimization that was removed in `7.6.0` ([#13562](https://github.com/remix-run/react-router/pull/13562))
440 - The issues that prompted the revert have been addressed by using the available router `matches` but always updating `match.route` to the latest route in the `manifest`
441 - Leverage pre-computed pre-computing flattened/cached route branches during client side route matching
442 - Performance benchmarks showed roughly a 15-30% improvement in server-side request handling performance
443
444## v7.14.2
445
446### Patch Changes
447
448- Remove the un-documented custom error serialization logic from the internal turbo-stream implementation. React Router only automatically handles serialization of `Error` and it's standard subtypes (`SyntaxError`, `TypeError`, etc.). ([[aabf4a1](https://github.com/remix-run/react-router/commit/aabf4a1))
449
450- Properly handle parent middleware redirects during `fetcher.load` ([[aabf4a1](https://github.com/remix-run/react-router/commit/aabf4a1))
451
452- Remove redundant `Omit<RouterProviderProps, "flushSync">` from `react-router/dom` `RouterProvider` ([[aabf4a1](https://github.com/remix-run/react-router/commit/aabf4a1))
453
454- Improved types for `generatePath`'s `param` arg ([[aabf4a1](https://github.com/remix-run/react-router/commit/aabf4a1))
455
456 Type errors when required params are omitted:
457
458 ```ts
459 // Before
460 // Passes type checks, but throws at runtime 💥
461 generatePath(":required", { required: null });
462
463 // After
464 generatePath(":required", { required: null });
465 // ^^^^^^^^ Type 'null' is not assignable to type 'string'.ts(2322)
466 ```
467
468 Allow omission of optional params:
469
470 ```ts
471 // Before
472 generatePath(":optional?", {});
473 // ^^ Property 'optional' is missing in type '{}' but required in type '{ optional: string | null | undefined; }'.ts(2741)
474
475 // After
476 generatePath(":optional?", {});
477 ```
478
479 Allows extra keys:
480
481 ```ts
482 // Before
483 generatePath(":a", { a: "1", b: "2" });
484 // ^ Object literal may only specify known properties, and 'b' does not exist in type '{ a: string; }'.ts(2353)
485
486 // After
487 generatePath(":a", { a: "1", b: "2" });
488 ```
489
490## v7.14.1
491
492### Patch Changes
493
494- Fix a potential race condition that can occur when rendering a `HydrateFallback` and initial loaders land before the `router.subscribe` call happens in the `RouterProvider` layout effect
495- Normalize double-slashes in redirect paths
496
497## 7.14.0
498
499### Patch Changes
500
501- UNSTABLE RSC FRAMEWORK MODE BREAKING CHANGE - Existing route module exports remain unchanged from stable v7 non-RSC mode, but new exports are added for RSC mode. If you want to use RSC features, you will need to update your route modules to export the new annotations. ([#14901](https://github.com/remix-run/react-router/pull/14901))
502
503 If you are using RSC framework mode currently, you will need to update your route modules to the new conventions. The following route module components have their own mutually exclusive server component counterparts:
504
505 | Server Component Export | Client Component |
506 | ----------------------- | ----------------- |
507 | `ServerComponent` | `default` |
508 | `ServerErrorBoundary` | `ErrorBoundary` |
509 | `ServerLayout` | `Layout` |
510 | `ServerHydrateFallback` | `HydrateFallback` |
511
512 If you were previously exporting a `ServerComponent`, your `ErrorBoundary`, `Layout`, and `HydrateFallback` were also server components. If you want to keep those as server components, you can rename them and prefix them with `Server`. If you were previously importing the implementations of those components from a client module, you can simply inline them.
513
514 Example:
515
516 Before
517
518 ```tsx
519 import { ErrorBoundary as ClientErrorBoundary } from "./client";
520
521 export function ServerComponent() {
522 // ...
523 }
524
525 export function ErrorBoundary() {
526 return <ClientErrorBoundary />;
527 }
528
529 export function Layout() {
530 // ...
531 }
532
533 export function HydrateFallback() {
534 // ...
535 }
536 ```
537
538 After
539
540 ```tsx
541 export function ServerComponent() {
542 // ...
543 }
544
545 export function ErrorBoundary() {
546 // previous implementation of ClientErrorBoundary, this is now a client component
547 }
548
549 export function ServerLayout() {
550 // rename previous Layout export to ServerLayout to make it a server component
551 }
552
553 export function ServerHydrateFallback() {
554 // rename previous HydrateFallback export to ServerHydrateFallback to make it a server component
555 }
556 ```
557
558- rsc Link prefetch ([#14902](https://github.com/remix-run/react-router/pull/14902))
559
560- Remove recursion from turbo-stream v2 allowing for encoding / decoding of massive payloads. ([#14838](https://github.com/remix-run/react-router/pull/14838))
561
562- encodeViaTurboStream leaked memory via unremoved AbortSignal listener ([#14900](https://github.com/remix-run/react-router/pull/14900))
563
564## 7.13.2
565
566### Patch Changes
567
568- Fix clientLoader.hydrate when an ancestor route is also hydrating a clientLoader ([#14835](https://github.com/remix-run/react-router/pull/14835))
569
570- Fix type error when passing Framework Mode route components using `Route.ComponentProps` to `createRoutesStub` ([#14892](https://github.com/remix-run/react-router/pull/14892))
571
572- Fix percent encoding in relative path navigation ([#14786](https://github.com/remix-run/react-router/pull/14786))
573
574- Add `future.unstable_passThroughRequests` flag ([#14775](https://github.com/remix-run/react-router/pull/14775))
575
576 By default, React Router normalizes the `request.url` passed to your `loader`, `action`, and `middleware` functions by removing React Router's internal implementation details (`.data` suffixes, `index` + `_routes` query params).
577
578 Enabling this flag removes that normalization and passes the raw HTTP `request` instance to your handlers. This provides a few benefits:
579 - Reduces server-side overhead by eliminating multiple `new Request()` calls on the critical path
580 - Allows you to distinguish document from data requests in your handlers base don the presence of a `.data` suffix (useful for observability purposes)
581
582 If you were previously relying on the normalization of `request.url`, you can switch to use the new sibling `unstable_url` parameter which contains a `URL` instance representing the normalized location:
583
584 ```tsx
585 // ❌ Before: you could assume there was no `.data` suffix in `request.url`
586 export async function loader({ request }: Route.LoaderArgs) {
587 let url = new URL(request.url);
588 if (url.pathname === "/path") {
589 // This check will fail with the flag enabled because the `.data` suffix will
590 // exist on data requests
591 }
592 }
593
594 // ✅ After: use `unstable_url` for normalized routing logic and `request.url`
595 // for raw routing logic
596 export async function loader({ request, unstable_url }: Route.LoaderArgs) {
597 if (unstable_url.pathname === "/path") {
598 // This will always have the `.data` suffix stripped
599 }
600
601 // And now you can distinguish between document versus data requests
602 let isDataRequest = new URL(request.url).pathname.endsWith(".data");
603 }
604 ```
605
606- Internal refactor to consolidate framework-agnostic/React-specific route type layers - no public API changes ([#14765](https://github.com/remix-run/react-router/pull/14765))
607
608- Sync protocol validation to rsc flows ([#14882](https://github.com/remix-run/react-router/pull/14882))
609
610- Add a new `unstable_url: URL` parameter to route handler methods (`loader`, `action`, `middleware`, etc.) representing the normalized URL the application is navigating to or fetching, with React Router implementation details removed (`.data`suffix, `index`/`_routes` query params) ([#14775](https://github.com/remix-run/react-router/pull/14775))
611
612 This is being added alongside the new `future.unstable_passthroughRequests` future flag so that users still have a way to access the normalized URL when that flag is enabled and non-normalized `request`'s are being passed to your handlers. When adopting this flag, you will only need to start leveraging this new parameter if you are relying on the normalization of `request.url` in your application code.
613
614 If you don't have the flag enabled, then `unstable_url` will match `request.url`.
615
616## 7.13.1
617
618### Patch Changes
619
620- fix null reference exception in bad codepath leading to invalid route tree comparisons ([#14780](https://github.com/remix-run/react-router/pull/14780))
621
622- fix: clear timeout when turbo-stream encoding completes ([#14810](https://github.com/remix-run/react-router/pull/14810))
623
624- Improve error message when Origin header is invalid ([#14743](https://github.com/remix-run/react-router/pull/14743))
625
626- Fix matchPath optional params matching without a "/" separator. ([#14689](https://github.com/remix-run/react-router/pull/14689))
627 - matchPath("/users/:id?", "/usersblah") now returns null.
628 - matchPath("/test_route/:part?", "/test_route_more") now returns null.
629
630- add RSC unstable_getRequest ([#14758](https://github.com/remix-run/react-router/pull/14758))
631
632- Fix `HydrateFallback` rendering during initial lazy route discovery with matching splat route ([#14740](https://github.com/remix-run/react-router/pull/14740))
633
634- \[UNSTABLE] Add support for `<Link unstable_mask>` in Data Mode which allows users to navigate to a URL in the router but "mask" the URL displayed in the browser. This is useful for contextual routing usages such as displaying an image in a model on top of a gallery, but displaying a browser URL directly to the image that can be shared and loaded without the contextual gallery in the background. ([#14716](https://github.com/remix-run/react-router/pull/14716))
635
636 ```tsx
637 // routes/gallery.tsx
638 export function clientLoader({ request }: Route.LoaderArgs) {
639 let sp = new URL(request.url).searchParams;
640 return {
641 images: getImages(),
642 // When the router location has the image param, load the modal data
643 modalImage: sp.has("image") ? getImage(sp.get("image")!) : null,
644 };
645 }
646
647 export default function Gallery({ loaderData }: Route.ComponentProps) {
648 return (
649 <>
650 <GalleryGrid>
651 {loaderData.images.map((image) => (
652 <Link
653 key={image.id}
654 {/* Navigate the router to /galley?image=N */}}
655 to={`/gallery?image=${image.id}`}
656 {/* But display /images/N in the URL bar */}}
657 unstable_mask={`/images/${image.id}`}
658 >
659 <img src={image.url} alt={image.alt} />
660 </Link>
661 ))}
662 </GalleryGrid>
663
664 {/* When the modal data exists, display the modal */}
665 {data.modalImage ? (
666 <dialog open>
667 <img src={data.modalImage.url} alt={data.modalImage.alt} />
668 </dialog>
669 ) : null}
670 </>
671 );
672 }
673 ```
674
675 Notes:
676 - The masked location, if present, will be available on `useLocation().unstable_mask` so you can detect whether you are currently masked or not.
677 - Masked URLs only work for SPA use cases, and will be removed from `history.state` during SSR.
678 - This provides a first-class API to mask URLs in Data Mode to achieve the same behavior you could do in Declarative Mode via [manual `backgroundLocation` management](https://github.com/remix-run/react-router/tree/main/examples/modal).
679
680- RSC: Update failed origin checks to return a 400 status and appropriate UI instead of a generic 500 ([#14755](https://github.com/remix-run/react-router/pull/14755))
681
682- Preserve query parameters and hash on manifest version mismatch reload ([#14813](https://github.com/remix-run/react-router/pull/14813))
683
684## 7.13.0
685
686### Minor Changes
687
688- Add `crossOrigin` prop to `Links` component ([#14687](https://github.com/remix-run/react-router/pull/14687))
689
690### Patch Changes
691
692- Fix double slash normalization for useNavigate colon urls ([#14718](https://github.com/remix-run/react-router/pull/14718))
693- Update failed origin checks to return a 400 status instead of a 500 ([#14737](https://github.com/remix-run/react-router/pull/14737))
694- Bugfix #14666: Inline criticalCss is missing nonce ([#14691](https://github.com/remix-run/react-router/pull/14691))
695- Loosen `allowedActionOrigins` glob check so `**` matches all domains ([#14722](https://github.com/remix-run/react-router/pull/14722))
696
697## 7.12.0
698
699### Minor Changes
700
701- Add additional layer of CSRF protection by rejecting submissions to UI routes from external origins. If you need to permit access to specific external origins, you can specify them in the `react-router.config.ts` config `allowedActionOrigins` field. ([#14708](https://github.com/remix-run/react-router/pull/14708))
702
703### Patch Changes
704
705- Fix `generatePath` when used with suffixed params (i.e., "/books/:id.json") ([#14269](https://github.com/remix-run/react-router/pull/14269))
706
707- Export `UNSAFE_createMemoryHistory` and `UNSAFE_createHashHistory` alongside `UNSAFE_createBrowserHistory` for consistency. These are not intended to be used for new apps but intended to help apps usiong `unstable_HistoryRouter` migrate from v6->v7 so they can adopt the newer APIs. ([#14663](https://github.com/remix-run/react-router/pull/14663))
708
709- Escape HTML in scroll restoration keys ([#14705](https://github.com/remix-run/react-router/pull/14705))
710
711- Validate redirect locations ([#14706](https://github.com/remix-run/react-router/pull/14706))
712
713- \[UNSTABLE] Pass `<Scripts nonce>` value through to the underlying `importmap` `script` tag when using `future.unstable_subResourceIntegrity` ([#14675](https://github.com/remix-run/react-router/pull/14675))
714
715- \[UNSTABLE] Add a new `future.unstable_trailingSlashAwareDataRequests` flag to provide consistent behavior of `request.pathname` inside `middleware`, `loader`, and `action` functions on document and data requests when a trailing slash is present in the browser URL. ([#14644](https://github.com/remix-run/react-router/pull/14644))
716
717 Currently, your HTTP and `request` pathnames would be as follows for `/a/b/c` and `/a/b/c/`
718
719 | URL `/a/b/c` | **HTTP pathname** | **`request` pathname\`** |
720 | ------------ | ----------------- | ------------------------ |
721 | **Document** | `/a/b/c` | `/a/b/c` ✅ |
722 | **Data** | `/a/b/c.data` | `/a/b/c` ✅ |
723
724 | URL `/a/b/c/` | **HTTP pathname** | **`request` pathname\`** |
725 | ------------- | ----------------- | ------------------------ |
726 | **Document** | `/a/b/c/` | `/a/b/c/` ✅ |
727 | **Data** | `/a/b/c.data` | `/a/b/c` ⚠️ |
728
729 With this flag enabled, these pathnames will be made consistent though a new `_.data` format for client-side `.data` requests:
730
731 | URL `/a/b/c` | **HTTP pathname** | **`request` pathname\`** |
732 | ------------ | ----------------- | ------------------------ |
733 | **Document** | `/a/b/c` | `/a/b/c` ✅ |
734 | **Data** | `/a/b/c.data` | `/a/b/c` ✅ |
735
736 | URL `/a/b/c/` | **HTTP pathname** | **`request` pathname\`** |
737 | ------------- | ------------------ | ------------------------ |
738 | **Document** | `/a/b/c/` | `/a/b/c/` ✅ |
739 | **Data** | `/a/b/c/_.data` ⬅️ | `/a/b/c/` ✅ |
740
741 This a bug fix but we are putting it behind an opt-in flag because it has the potential to be a "breaking bug fix" if you are relying on the URL format for any other application or caching logic.
742
743 Enabling this flag also changes the format of client side `.data` requests from `/_root.data` to `/_.data` when navigating to `/` to align with the new format. This does not impact the `request` pathname which is still `/` in all cases.
744
745- Preserve `clientLoader.hydrate=true` when using `<HydratedRouter unstable_instrumentations>` ([#14674](https://github.com/remix-run/react-router/pull/14674))
746
747## 7.11.0
748
749### Minor Changes
750
751- Stabilize `<HydratedRouter onError>`/`<RouterProvider onError>` ([#14546](https://github.com/remix-run/react-router/pull/14546))
752
753### Patch Changes
754
755- add support for throwing redirect Response's at RSC render time ([#14596](https://github.com/remix-run/react-router/pull/14596))
756
757- Support for throwing `data()` and Response from server component render phase. Response body is not serialized as async work is not allowed as error encoding phase. If you wish to transmit data to the boundary, throw `data()` instead. ([#14632](https://github.com/remix-run/react-router/pull/14632))
758
759- Fix `unstable_useTransitions` prop on `<Router>` component to permit omission for backewards compatibility ([#14646](https://github.com/remix-run/react-router/pull/14646))
760
761- `routeRSCServerRequest` replace `fetchServer` with `serverResponse` ([#14597](https://github.com/remix-run/react-router/pull/14597))
762
763- \[UNSTABLE] Add a new `unstable_defaultShouldRevalidate` flag to various APIs to allow opt-ing out of standard revalidation behaviors. ([#14542](https://github.com/remix-run/react-router/pull/14542))
764
765 If active routes include a `shouldRevalidate` function, then your value will be passed as `defaultShouldRevalidate` in those function so that the route always has the final revalidation determination.
766 - `<Form method="post" unstable_defaultShouldRevalidate={false}>`
767 - `submit(data, { method: "post", unstable_defaultShouldRevalidate: false })`
768 - `<fetcher.Form method="post" unstable_defaultShouldRevalidate={false}>`
769 - `fetcher.submit(data, { method: "post", unstable_defaultShouldRevalidate: false })`
770
771 This is also available on non-submission APIs that may trigger revalidations due to changing search params:
772 - `<Link to="/" unstable_defaultShouldRevalidate={false}>`
773 - `navigate("/?foo=bar", { unstable_defaultShouldRevalidate: false })`
774 - `setSearchParams(params, { unstable_defaultShouldRevalidate: false })`
775
776- Allow redirects to be returned from client side middleware ([#14598](https://github.com/remix-run/react-router/pull/14598))
777
778- Handle `dataStrategy` implementations that return insufficient result sets by adding errors for routes without any available result ([#14627](https://github.com/remix-run/react-router/pull/14627))
779
780## 7.10.1
781
782### Patch Changes
783
784- Update the `useOptimistic` stub we provide for React 18 users to use a stable setter function to avoid potential `useEffect` loops - specifically when using `<Link viewTransition>` ([#14628](https://github.com/remix-run/react-router/pull/14628))
785
786## 7.10.0
787
788### Minor Changes
789
790- Stabilize `fetcher.reset()` ([#14545](https://github.com/remix-run/react-router/pull/14545))
791 - ⚠️ This is a breaking change if you have begun using `fetcher.unstable_reset()`
792
793- Stabilize the `dataStrategy` `match.shouldRevalidateArgs`/`match.shouldCallHandler()` APIs. ([#14592](https://github.com/remix-run/react-router/pull/14592))
794 - The `match.shouldLoad` API is now marked deprecated in favor of these more powerful alternatives
795
796 - If you're using this API in a custom `dataStrategy` today, you can swap to the new API at your convenience:
797
798 ```tsx
799 // Before
800 const matchesToLoad = matches.filter((m) => m.shouldLoad);
801
802 // After
803 const matchesToLoad = matches.filter((m) => m.shouldCallHandler());
804 ```
805
806 - `match.shouldRevalidateArgs` is the argument that will be passed to the route `shouldRevaliate` function
807
808 - Combined with the parameter accepted by `match.shouldCallHandler`, you can define a custom revalidation behavior for your `dataStrategy`:
809
810 ```tsx
811 const matchesToLoad = matches.filter((m) => {
812 const defaultShouldRevalidate = customRevalidationBehavior(
813 match.shouldRevalidateArgs,
814 );
815 return m.shouldCallHandler(defaultShouldRevalidate);
816 // The argument here will override the internal `defaultShouldRevalidate` value
817 });
818 ```
819
820### Patch Changes
821
822- Fix a Framework Mode bug where the `defaultShouldRevalidate` parameter to `shouldRevalidate` would not be correct after `action` returned a 4xx/5xx response (`true` when it should have been `false`) ([#14592](https://github.com/remix-run/react-router/pull/14592))
823 - If your `shouldRevalidate` function relied on that parameter, you may have seen unintended revalidations
824
825- Fix `fetcher.submit` failing with plain objects containing a `tagName` property ([#14534](https://github.com/remix-run/react-router/pull/14534))
826
827- \[UNSTABLE] Add `unstable_pattern` to the parameters for client side `unstable_onError`, refactor how it's called by `RouterProvider` to avoid potential strict mode issues ([#14573](https://github.com/remix-run/react-router/pull/14573))
828
829- Add new `unstable_useTransitions` flag to routers to give users control over the usage of [`React.startTransition`](https://react.dev/reference/react/startTransition) and [`React.useOptimistic`](https://react.dev/reference/react/useOptimistic). ([#14524](https://github.com/remix-run/react-router/pull/14524))
830 - Framework Mode + Data Mode:
831 - `<HydratedRouter unstable_transition>`/`<RouterProvider unstable_transition>`
832 - When left unset (current default behavior)
833 - Router state updates are wrapped in `React.startTransition`
834 - ⚠️ This can lead to buggy behaviors if you are wrapping your own navigations/fetchers in `React.startTransition`
835 - You should set the flag to `true` if you run into this scenario to get the enhanced `useOptimistic` behavior (requires React 19)
836 - When set to `true`
837 - Router state updates remain wrapped in `React.startTransition` (as they are without the flag)
838 - `Link`/`Form` navigations will be wrapped in `React.startTransition`
839 - A subset of router state info will be surfaced to the UI _during_ navigations via `React.useOptimistic` (i.e., `useNavigation()`, `useFetchers()`, etc.)
840 - ⚠️ This is a React 19 API so you must also be React 19 to opt into this flag for Framework/Data Mode
841 - When set to `false`
842 - The router will not leverage `React.startTransition` or `React.useOptimistic` on any navigations or state changes
843 - Declarative Mode
844 - `<BrowserRouter unstable_useTransitions>`
845 - When left unset
846 - Router state updates are wrapped in `React.startTransition`
847 - When set to `true`
848 - Router state updates remain wrapped in `React.startTransition` (as they are without the flag)
849 - `Link`/`Form` navigations will be wrapped in `React.startTransition`
850 - When set to `false`
851 - the router will not leverage `React.startTransition` on any navigations or state changes
852
853- Fix the promise returned from `useNavigate` in Framework/Data Mode so that it properly tracks the duration of `popstate` navigations (i.e., `navigate(-1)`) ([#14524](https://github.com/remix-run/react-router/pull/14524))
854
855- Fix internal type error in useRoute types that surfaces when skipLibCheck is disabled ([#14577](https://github.com/remix-run/react-router/pull/14577))
856
857- Preserve `statusText` on the `ErrorResponse` instance when throwing `data()` from a route handler ([#14555](https://github.com/remix-run/react-router/pull/14555))
858
859- Optimize href() to avoid backtracking regex on splat ([#14329](https://github.com/remix-run/react-router/pull/14329))
860
861## 7.9.6
862
863### Patch Changes
864
865- \[UNSTABLE] Add `location`/`params` as arguments to client-side `unstable_onError` to permit enhanced error reporting. ([#14509](https://github.com/remix-run/react-router/pull/14509))
866
867 ⚠️ This is a breaking change if you've already adopted `unstable_onError`. The second `errorInfo` parameter is now an object with `location` and `params`:
868
869 ```tsx
870 // Before
871 function errorHandler(error: unknown, errorInfo?: React.errorInfo) {
872 /*...*/
873 }
874
875 // After
876 function errorHandler(
877 error: unknown,
878 info: {
879 location: Location;
880 params: Params;
881 errorInfo?: React.ErrorInfo;
882 },
883 ) {
884 /*...*/
885 }
886 ```
887
888- Properly handle ancestor thrown middleware errors before `next()` on fetcher submissions ([#14517](https://github.com/remix-run/react-router/pull/14517))
889
890- Fix issue with splat routes interfering with multiple calls to patchRoutesOnNavigation ([#14487](https://github.com/remix-run/react-router/pull/14487))
891
892- Normalize double-slashes in `resolvePath` ([#14529](https://github.com/remix-run/react-router/pull/14529))
893
894## 7.9.5
895
896### Patch Changes
897
898- Move RSCHydratedRouter and utils to `/dom` export. ([#14457](https://github.com/remix-run/react-router/pull/14457))
899
900- useRoute: return type-safe `handle` ([#14462](https://github.com/remix-run/react-router/pull/14462))
901
902 For example:
903
904 ```ts
905 // app/routes/admin.tsx
906 const handle = { hello: "world" };
907 ```
908
909 ```ts
910 // app/routes/some-other-route.tsx
911 export default function Component() {
912 const admin = useRoute("routes/admin");
913 if (!admin) throw new Error("Not nested within 'routes/admin'");
914 console.log(admin.handle);
915 // ^? { hello: string }
916 }
917 ```
918
919- Ensure action handlers run for routes with middleware even if no loader is present ([#14443](https://github.com/remix-run/react-router/pull/14443))
920
921- Add `unstable_instrumentations` API to allow users to add observablity to their apps by instrumenting route loaders, actions, middlewares, lazy, as well as server-side request handlers and client side navigations/fetches ([#14412](https://github.com/remix-run/react-router/pull/14412))
922 - Framework Mode:
923 - `entry.server.tsx`: `export const unstable_instrumentations = [...]`
924 - `entry.client.tsx`: `<HydratedRouter unstable_instrumentations={[...]} />`
925 - Data Mode
926 - `createBrowserRouter(routes, { unstable_instrumentations: [...] })`
927
928 This also adds a new `unstable_pattern` parameter to loaders/actions/middleware which contains the un-interpolated route pattern (i.e., `/blog/:slug`) which is useful for aggregating performance metrics by route
929
930## 7.9.4
931
932### Patch Changes
933
934- handle external redirects in from server actions ([#14400](https://github.com/remix-run/react-router/pull/14400))
935- New (unstable) `useRoute` hook for accessing data from specific routes ([#14407](https://github.com/remix-run/react-router/pull/14407))
936
937 For example, let's say you have an `admin` route somewhere in your app and you want any child routes of `admin` to all have access to the `loaderData` and `actionData` from `admin.`
938
939 ```tsx
940 // app/routes/admin.tsx
941 import { Outlet } from "react-router";
942
943 export const loader = () => ({ message: "Hello, loader!" });
944
945 export const action = () => ({ count: 1 });
946
947 export default function Component() {
948 return (
949 <div>
950 {/* ... */}
951 <Outlet />
952 {/* ... */}
953 </div>
954 );
955 }
956 ```
957
958 You might even want to create a reusable widget that all of the routes nested under `admin` could use:
959
960 ```tsx
961 import { unstable_useRoute as useRoute } from "react-router";
962
963 export function AdminWidget() {
964 // How to get `message` and `count` from `admin` route?
965 }
966 ```
967
968 In framework mode, `useRoute` knows all your app's routes and gives you TS errors when invalid route IDs are passed in:
969
970 ```tsx
971 export function AdminWidget() {
972 const admin = useRoute("routes/dmin");
973 // ^^^^^^^^^^^
974 }
975 ```
976
977 `useRoute` returns `undefined` if the route is not part of the current page:
978
979 ```tsx
980 export function AdminWidget() {
981 const admin = useRoute("routes/admin");
982 if (!admin) {
983 throw new Error(`AdminWidget used outside of "routes/admin"`);
984 }
985 }
986 ```
987
988 Note: the `root` route is the exception since it is guaranteed to be part of the current page.
989 As a result, `useRoute` never returns `undefined` for `root`.
990
991 `loaderData` and `actionData` are marked as optional since they could be accessed before the `action` is triggered or after the `loader` threw an error:
992
993 ```tsx
994 export function AdminWidget() {
995 const admin = useRoute("routes/admin");
996 if (!admin) {
997 throw new Error(`AdminWidget used outside of "routes/admin"`);
998 }
999 const { loaderData, actionData } = admin;
1000 console.log(loaderData);
1001 // ^? { message: string } | undefined
1002 console.log(actionData);
1003 // ^? { count: number } | undefined
1004 }
1005 ```
1006
1007 If instead of a specific route, you wanted access to the _current_ route's `loaderData` and `actionData`, you can call `useRoute` without arguments:
1008
1009 ```tsx
1010 export function AdminWidget() {
1011 const currentRoute = useRoute();
1012 currentRoute.loaderData;
1013 currentRoute.actionData;
1014 }
1015 ```
1016
1017 This usage is equivalent to calling `useLoaderData` and `useActionData`, but consolidates all route data access into one hook: `useRoute`.
1018
1019 Note: when calling `useRoute()` (without a route ID), TS has no way to know which route is the current route.
1020 As a result, `loaderData` and `actionData` are typed as `unknown`.
1021 If you want more type-safety, you can either narrow the type yourself with something like `zod` or you can refactor your app to pass down typed props to your `AdminWidget`:
1022
1023 ```tsx
1024 export function AdminWidget({
1025 message,
1026 count,
1027 }: {
1028 message: string;
1029 count: number;
1030 }) {
1031 /* ... */
1032 }
1033 ```
1034
1035## 7.9.3
1036
1037### Patch Changes
1038
1039- Do not try to use `turbo-stream` to decode CDN errors that never reached the server ([#14385](https://github.com/remix-run/react-router/pull/14385))
1040 - We used to do this but lost this check with the adoption of single fetch
1041
1042- Fix Data Mode regression causing a 404 during initial load in when `middleware` exists without any `loader` functions ([#14393](https://github.com/remix-run/react-router/pull/14393))
1043
1044## 7.9.2
1045
1046### Patch Changes
1047
1048- - Update client-side router to run client `middleware` on initial load even if no loaders exist ([#14348](https://github.com/remix-run/react-router/pull/14348))
1049 - Update `createRoutesStub` to run route middleware
1050 - You will need to set the `<RoutesStub future={{ v8_middleware: true }} />` flag to enable the proper `context` type
1051
1052- Update Lazy Route Discovery manifest requests to use a singular comma-separated `paths` query param instead of repeated `p` query params ([#14321](https://github.com/remix-run/react-router/pull/14321))
1053 - This is because Cloudflare has a hard limit of 100 URL search param key/value pairs when used as a key for caching purposes
1054 - If more that 100 paths were included, the cache key would be incomplete and could produce false-positive cache hits
1055
1056- \[UNSTABLE] Add `fetcher.unstable_reset()` API ([#14206](https://github.com/remix-run/react-router/pull/14206))
1057
1058- Made useOutlet element reference have stable identity in-between route chages ([#13382](https://github.com/remix-run/react-router/pull/13382))
1059
1060- feat: enable full transition support for the rsc router ([#14362](https://github.com/remix-run/react-router/pull/14362))
1061
1062- In RSC Data Mode, handle SSR'd client errors and re-try in the browser ([#14342](https://github.com/remix-run/react-router/pull/14342))
1063
1064- Support `middleware` prop on `<Route>` for usage with a data router via `createRoutesFromElements` ([#14357](https://github.com/remix-run/react-router/pull/14357))
1065
1066- Handle encoded question mark and hash characters in ancestor splat routes ([#14249](https://github.com/remix-run/react-router/pull/14249))
1067
1068- Fail gracefully on manifest version mismatch logic if `sessionStorage` access is blocked ([#14335](https://github.com/remix-run/react-router/pull/14335))
1069
1070## 7.9.1
1071
1072### Patch Changes
1073
1074- Fix internal `Future` interface naming from `middleware` -> `v8_middleware` ([#14327](https://github.com/remix-run/react-router/pull/14327))
1075
1076## 7.9.0
1077
1078### Minor Changes
1079
1080- Stabilize middleware and context APIs. ([#14215](https://github.com/remix-run/react-router/pull/14215))
1081
1082 We have removed the `unstable_` prefix from the following APIs and they are now considered stable and ready for production use:
1083 - [`RouterContextProvider`](https://reactrouter.com/api/utils/RouterContextProvider)
1084 - [`createContext`](https://reactrouter.com/api/utils/createContext)
1085 - `createBrowserRouter` [`getContext`](https://reactrouter.com/api/data-routers/createBrowserRouter#optsgetcontext) option
1086 - `<HydratedRouter>` [`getContext`](https://reactrouter.com/api/framework-routers/HydratedRouter#getcontext) prop
1087
1088 Please see the [Middleware Docs](https://reactrouter.com/how-to/middleware), the [Middleware RFC](https://github.com/remix-run/remix/discussions/7642), and the [Client-side Context RFC](https://github.com/remix-run/react-router/discussions/9856) for more information.
1089
1090### Patch Changes
1091
1092- Escape HTML in `meta()` JSON-LD content ([#14316](https://github.com/remix-run/react-router/pull/14316))
1093- Add react-server Await component implementation ([#14261](https://github.com/remix-run/react-router/pull/14261))
1094- In RSC Data Mode when using a custom basename, fix hydration errors for routes that only have client loaders ([#14264](https://github.com/remix-run/react-router/pull/14264))
1095- Make `href` function available in a react-server context ([#14262](https://github.com/remix-run/react-router/pull/14262))
1096- decode each time `getPayload()` is called to allow for "in-context" decoding and hoisting of contextual assets ([#14248](https://github.com/remix-run/react-router/pull/14248))
1097- `href()` now correctly processes routes that have an extension after the parameter or are a single optional parameter. ([#13797](https://github.com/remix-run/react-router/pull/13797))
1098
1099## 7.8.2
1100
1101### Patch Changes
1102
1103- \[UNSTABLE] Remove Data Mode `future.unstable_middleware` flag from `createBrowserRouter` ([#14213](https://github.com/remix-run/react-router/pull/14213))
1104 - This is only needed as a Framework Mode flag because of the route modules and the `getLoadContext` type behavior change
1105 - In Data Mode, it's an opt-in feature because it's just a new property on a route object, so there's no behavior changes that necessitate a flag
1106
1107- \[UNSTABLE] Add `<RouterProvider unstable_onError>`/`<HydratedRouter unstable_onError>` prop for client side error reporting ([#14162](https://github.com/remix-run/react-router/pull/14162))
1108
1109- server action revalidation opt out via $SKIP_REVALIDATION field ([#14154](https://github.com/remix-run/react-router/pull/14154))
1110
1111- Properly escape interpolated param values in `generatePath()` ([#13530](https://github.com/remix-run/react-router/pull/13530))
1112
1113- Maintain `ReadonlyMap` and `ReadonlySet` types in server response data. ([#13092](https://github.com/remix-run/react-router/pull/13092))
1114
1115- \[UNSTABLE] Delay serialization of `.data` redirects to 202 responses until after middleware chain ([#14205](https://github.com/remix-run/react-router/pull/14205))
1116
1117- Fix `TypeError` if you throw from `patchRoutesOnNavigation` when no partial matches exist ([#14198](https://github.com/remix-run/react-router/pull/14198))
1118
1119- Fix `basename` usage without a leading slash in data routers ([#11671](https://github.com/remix-run/react-router/pull/11671))
1120
1121- \[UNSTABLE] Update client middleware so it returns the data strategy results allowing for more advanced post-processing middleware ([#14151](https://github.com/remix-run/react-router/pull/14151))
1122
1123## 7.8.1
1124
1125### Patch Changes
1126
1127- Fix usage of optional path segments in nested routes defined using absolute paths ([#14135](https://github.com/remix-run/react-router/pull/14135))
1128- Bubble client pre-next middleware error to the shallowest ancestor that needs to load, not strictly the shallowest ancestor with a loader ([#14150](https://github.com/remix-run/react-router/pull/14150))
1129- Fix optional static segment matching in `matchPath` ([#11813](https://github.com/remix-run/react-router/pull/11813))
1130- Fix prerendering when a `basename` is set with `ssr:false` ([#13791](https://github.com/remix-run/react-router/pull/13791))
1131- Provide `isRouteErrorResponse` utility in `react-server` environments ([#14166](https://github.com/remix-run/react-router/pull/14166))
1132- Propagate non-redirect Responses thrown from middleware to the error boundary on document/data requests ([#14182](https://github.com/remix-run/react-router/pull/14182))
1133- Handle `meta` and `links` Route Exports in RSC Data Mode ([#14136](https://github.com/remix-run/react-router/pull/14136))
1134- Properly convert returned/thrown `data()` values to `Response` instances via `Response.json()` in resource routes and middleware ([#14159](https://github.com/remix-run/react-router/pull/14159), [#14181](https://github.com/remix-run/react-router/pull/14181))
1135
1136## 7.8.0
1137
1138### Minor Changes
1139
1140- Add `nonce` prop to `Links` & `PrefetchPageLinks` ([#14048](https://github.com/remix-run/react-router/pull/14048))
1141- Add `loaderData` arguments/properties alongside existing `data` arguments/properties to provide consistency and clarity between `loaderData` and `actionData` across the board ([#14047](https://github.com/remix-run/react-router/pull/14047))
1142 - Updated types: `Route.MetaArgs`, `Route.MetaMatch`, `MetaArgs`, `MetaMatch`, `Route.ComponentProps.matches`, `UIMatch`
1143 - `@deprecated` warnings have been added to the existing `data` properties to point users to new `loaderData` properties, in preparation for removing the `data` properties in a future major release
1144
1145### Patch Changes
1146
1147- Prevent _"Did not find corresponding fetcher result"_ console error when navigating during a `fetcher.submit` revalidation ([#14114](https://github.com/remix-run/react-router/pull/14114))
1148
1149- Bubble client-side middleware errors prior to `next` to the appropriate ancestor error boundary ([#14138](https://github.com/remix-run/react-router/pull/14138))
1150
1151- Switch Lazy Route Discovery manifest URL generation to usea standalone `URLSearchParams` instance instead of `URL.searchParams` to avoid a major performance bottleneck in Chrome ([#14084](https://github.com/remix-run/react-router/pull/14084))
1152
1153- Adjust internal RSC usage of `React.use` to avoid Webpack compilation errors when using React 18 ([#14113](https://github.com/remix-run/react-router/pull/14113))
1154
1155- Remove dependency on `@types/node` in TypeScript declaration files ([#14059](https://github.com/remix-run/react-router/pull/14059))
1156
1157- Fix types for `UIMatch` to reflect that the `loaderData`/`data` properties may be `undefined` ([#12206](https://github.com/remix-run/react-router/pull/12206))
1158 - When an `ErrorBoundary` is being rendered, not all active matches will have loader data available, since it may have been their `loader` that threw to trigger the boundary
1159 - The `UIMatch.data` type was not correctly handing this and would always reflect the presence of data, leading to the unexpected runtime errors when an `ErrorBoundary` was rendered
1160 - ⚠️ This may cause some type errors to show up in your code for unguarded `match.data` accesses - you should properly guard for `undefined` values in those scenarios.
1161
1162 ```tsx
1163 // app/root.tsx
1164 export function loader() {
1165 someFunctionThatThrows(); // ❌ Throws an Error
1166 return { title: "My Title" };
1167 }
1168
1169 export function Layout({ children }: { children: React.ReactNode }) {
1170 let matches = useMatches();
1171 let rootMatch = matches[0] as UIMatch<Awaited<ReturnType<typeof loader>>>;
1172 // ^ rootMatch.data is incorrectly typed here, so TypeScript does not
1173 // complain if you do the following which throws an error at runtime:
1174 let { title } = rootMatch.data; // 💥
1175
1176 return <html>...</html>;
1177 }
1178 ```
1179
1180- \[UNSTABLE] Ensure resource route errors go through `handleError` w/middleware enabled ([#14078](https://github.com/remix-run/react-router/pull/14078))
1181
1182- \[UNSTABLE] Propagate returned Response from server middleware if next wasn't called ([#14093](https://github.com/remix-run/react-router/pull/14093))
1183
1184- \[UNSTABLE] Allow server middlewares to return `data()` values which will be converted into a `Response` ([#14093](https://github.com/remix-run/react-router/pull/14093))
1185
1186- \[UNSTABLE] Update middleware error handling so that the `next` function never throws and instead handles any middleware errors at the proper `ErrorBoundary` and returns the `Response` up through the ancestor `next` function ([#14118](https://github.com/remix-run/react-router/pull/14118))
1187
1188- \[UNSTABLE] When middleware is enabled, make the `context` parameter read-only (via `Readonly<unstable_RouterContextProvider>`) so that TypeScript will not allow you to write arbitrary fields to it in loaders, actions, or middleware. ([#14097](https://github.com/remix-run/react-router/pull/14097))
1189
1190- \[UNSTABLE] Rename and alter the signature/functionality of the `unstable_respond` API in `staticHandler.query`/`staticHandler.queryRoute` ([#14103](https://github.com/remix-run/react-router/pull/14103))
1191 - The API has been renamed to `unstable_generateMiddlewareResponse` for clarity
1192 - The main functional change is that instead of running the loaders/actions before calling `unstable_respond` and handing you the result, we now pass a `query`/`queryRoute` function as a parameter and you execute the loaders/actions inside your callback, giving you full access to pre-processing and error handling
1193 - The `query` version of the API now has a signature of `(query: (r: Request) => Promise<StaticHandlerContext | Response>) => Promise<Response>`
1194 - The `queryRoute` version of the API now has a signature of `(queryRoute: (r: Request) => Promise<Response>) => Promise<Response>`
1195 - This allows for more advanced usages such as running logic before/after calling `query` and direct error handling of errors thrown from query
1196 - ⚠️ This is a breaking change if you've adopted the `staticHandler` `unstable_respond` API
1197
1198 ```tsx
1199 let response = await staticHandler.query(request, {
1200 requestContext: new unstable_RouterContextProvider(),
1201 async unstable_generateMiddlewareResponse(query) {
1202 try {
1203 // At this point we've run middleware top-down so we need to call the
1204 // handlers and generate the Response to bubble back up the middleware
1205 let result = await query(request);
1206 if (isResponse(result)) {
1207 return result; // Redirects, etc.
1208 }
1209 return await generateHtmlResponse(result);
1210 } catch (error: unknown) {
1211 return generateErrorResponse(error);
1212 }
1213 },
1214 });
1215 ```
1216
1217- \[UNSTABLE] Convert internal middleware implementations to use the new `unstable_generateMiddlewareResponse` API ([#14103](https://github.com/remix-run/react-router/pull/14103))
1218
1219- \[UNSTABLE] Change `getLoadContext` signature (`type GetLoadContextFunction`) when `future.unstable_middleware` is enabled so that it returns an `unstable_RouterContextProvider` instance instead of a `Map` used to contruct the instance internally ([#14097](https://github.com/remix-run/react-router/pull/14097))
1220 - This also removes the `type unstable_InitialContext` export
1221 - ⚠️ This is a breaking change if you have adopted middleware and are using a custom server with a `getLoadContext` function
1222
1223- \[UNSTABLE] Run client middleware on client navigations even if no loaders exist ([#14106](https://github.com/remix-run/react-router/pull/14106))
1224
1225- \[UNSTABLE] Change the `unstable_getContext` signature on `RouterProvider`/`HydratedRouter`/`unstable_RSCHydratedRouter` so that it returns an `unstable_RouterContextProvider` instance instead of a `Map` used to contruct the instance internally ([#14097](https://github.com/remix-run/react-router/pull/14097))
1226 - ⚠️ This is a breaking change if you have adopted the `unstable_getContext` prop
1227
1228- \[UNSTABLE] proxy server action side-effect redirects from actions for document and callServer requests ([#14131](https://github.com/remix-run/react-router/pull/14131))
1229
1230- \[UNSTABLE] Fix RSC Data Mode issue where routes that return `false` from `shouldRevalidate` would be replaced by an `<Outlet />` ([#14071](https://github.com/remix-run/react-router/pull/14071))
1231
1232## 7.7.1
1233
1234### Patch Changes
1235
1236- In RSC Data Mode, fix bug where routes with errors weren't forced to revalidate when `shouldRevalidate` returned false ([#14026](https://github.com/remix-run/react-router/pull/14026))
1237- In RSC Data Mode, fix `Matched leaf route at location "/..." does not have an element or Component` warnings when error boundaries are rendered. ([#14021](https://github.com/remix-run/react-router/pull/14021))
1238
1239## 7.7.0
1240
1241### Minor Changes
1242
1243- Add unstable RSC support ([#13700](https://github.com/remix-run/react-router/pull/13700))
1244
1245 For more information, see the [RSC documentation](https://reactrouter.com/start/rsc/installation).
1246
1247### Patch Changes
1248
1249- Handle `InvalidCharacterError` when validating cookie signature ([#13847](https://github.com/remix-run/react-router/pull/13847))
1250
1251- Pass a copy of `searchParams` to the `setSearchParams` callback function to avoid muations of the internal `searchParams` instance. This was an issue when navigations were blocked because the internal instance be out of sync with `useLocation().search`. ([#12784](https://github.com/remix-run/react-router/pull/12784))
1252
1253- Support invalid `Date` in `turbo-stream` v2 fork ([#13684](https://github.com/remix-run/react-router/pull/13684))
1254
1255- In Framework Mode, clear critical CSS in development after initial render ([#13872](https://github.com/remix-run/react-router/pull/13872))
1256
1257- Strip search parameters from `patchRoutesOnNavigation` `path` param for fetcher calls ([#13911](https://github.com/remix-run/react-router/pull/13911))
1258
1259- Skip scroll restoration on useRevalidator() calls because they're not new locations ([#13671](https://github.com/remix-run/react-router/pull/13671))
1260
1261- Support unencoded UTF-8 routes in prerender config with `ssr` set to `false` ([#13699](https://github.com/remix-run/react-router/pull/13699))
1262
1263- Do not throw if the url hash is not a valid URI component ([#13247](https://github.com/remix-run/react-router/pull/13247))
1264
1265- Fix a regression in `createRoutesStub` introduced with the middleware feature. ([#13946](https://github.com/remix-run/react-router/pull/13946))
1266
1267 As part of that work we altered the signature to align with the new middleware APIs without making it backwards compatible with the prior `AppLoadContext` API. This permitted `createRoutesStub` to work if you were opting into middleware and the updated `context` typings, but broke `createRoutesStub` for users not yet opting into middleware.
1268
1269 We've reverted this change and re-implemented it in such a way that both sets of users can leverage it.
1270
1271 ```tsx
1272 // If you have not opted into middleware, the old API should work again
1273 let context: AppLoadContext = {
1274 /*...*/
1275 };
1276 let Stub = createRoutesStub(routes, context);
1277
1278 // If you have opted into middleware, you should now pass an instantiated `unstable_routerContextProvider` instead of a `getContext` factory function.
1279 let context = new unstable_RouterContextProvider();
1280 context.set(SomeContext, someValue);
1281 let Stub = createRoutesStub(routes, context);
1282 ```
1283
1284 ⚠️ This may be a breaking bug for if you have adopted the unstable Middleware feature and are using `createRoutesStub` with the updated API.
1285
1286- Remove `Content-Length` header from Single Fetch responses ([#13902](https://github.com/remix-run/react-router/pull/13902))
1287
1288## 7.6.3
1289
1290### Patch Changes
1291
1292- Do not serialize types for `useRouteLoaderData<typeof clientLoader>` ([#13752](https://github.com/remix-run/react-router/pull/13752))
1293
1294 For types to distinguish a `clientLoader` from a `serverLoader`, you MUST annotate `clientLoader` args:
1295
1296 ```ts
1297 // 👇 annotation required to skip serializing types
1298 export function clientLoader({}: Route.ClientLoaderArgs) {
1299 return { fn: () => "earth" };
1300 }
1301
1302 function SomeComponent() {
1303 const data = useRouteLoaderData<typeof clientLoader>("routes/this-route");
1304 const planet = data?.fn() ?? "world";
1305 return <h1>Hello, {planet}!</h1>;
1306 }
1307 ```
1308
1309## 7.6.2
1310
1311### Patch Changes
1312
1313- Avoid additional `with-props` chunk in Framework Mode by moving route module component prop logic from the Vite plugin to `react-router` ([#13650](https://github.com/remix-run/react-router/pull/13650))
1314- Slight refactor of internal `headers()` function processing for use with RSC ([#13639](https://github.com/remix-run/react-router/pull/13639))
1315
1316## 7.6.1
1317
1318### Patch Changes
1319
1320- Update `Route.MetaArgs` to reflect that `data` can be potentially `undefined` ([#13563](https://github.com/remix-run/react-router/pull/13563))
1321
1322 This is primarily for cases where a route `loader` threw an error to it's own `ErrorBoundary`. but it also arises in the case of a 404 which renders the root `ErrorBoundary`/`meta` but the root loader did not run because not routes matched.
1323
1324- Partially revert optimization added in `7.1.4` to reduce calls to `matchRoutes` because it surfaced other issues ([#13562](https://github.com/remix-run/react-router/pull/13562))
1325
1326- Fix typegen when same route is used at multiple paths ([#13574](https://github.com/remix-run/react-router/pull/13574))
1327
1328 For example, `routes/route.tsx` is used at 4 different paths here:
1329
1330 ```ts
1331 import { type RouteConfig, route } from "@react-router/dev/routes";
1332 export default [
1333 route("base/:base", "routes/base.tsx", [
1334 route("home/:home", "routes/route.tsx", { id: "home" }),
1335 route("changelog/:changelog", "routes/route.tsx", { id: "changelog" }),
1336 route("splat/*", "routes/route.tsx", { id: "splat" }),
1337 ]),
1338 route("other/:other", "routes/route.tsx", { id: "other" }),
1339 ] satisfies RouteConfig;
1340 ```
1341
1342 Previously, typegen would arbitrarily pick one of these paths to be the "winner" and generate types for the route module based on that path.
1343 Now, typegen creates unions as necessary for alternate paths for the same route file.
1344
1345- Better types for `params` ([#13543](https://github.com/remix-run/react-router/pull/13543))
1346
1347 For example:
1348
1349 ```ts
1350 // routes.ts
1351 import { type RouteConfig, route } from "@react-router/dev/routes";
1352
1353 export default [
1354 route("parent/:p", "routes/parent.tsx", [
1355 route("layout/:l", "routes/layout.tsx", [
1356 route("child1/:c1a/:c1b", "routes/child1.tsx"),
1357 route("child2/:c2a/:c2b", "routes/child2.tsx"),
1358 ]),
1359 ]),
1360 ] satisfies RouteConfig;
1361 ```
1362
1363 Previously, `params` for the `routes/layout.tsx` route were calculated as `{ p: string, l: string }`.
1364 This incorrectly ignores params that could come from child routes.
1365 If visiting `/parent/1/layout/2/child1/3/4`, the actual params passed to `routes/layout.tsx` will have a type of `{ p: string, l: string, c1a: string, c1b: string }`.
1366
1367 Now, `params` are aware of child routes and autocompletion will include child params as optionals:
1368
1369 ```ts
1370 params.|
1371 // ^ cursor is here and you ask for autocompletion
1372 // p: string
1373 // l: string
1374 // c1a?: string
1375 // c1b?: string
1376 // c2a?: string
1377 // c2b?: string
1378 ```
1379
1380 You can also narrow the types for `params` as it is implemented as a normalized union of params for each page that includes `routes/layout.tsx`:
1381
1382 ```ts
1383 if (typeof params.c1a === 'string') {
1384 params.|
1385 // ^ cursor is here and you ask for autocompletion
1386 // p: string
1387 // l: string
1388 // c1a: string
1389 // c1b: string
1390 }
1391 ```
1392
1393 ***
1394
1395 UNSTABLE: renamed internal `react-router/route-module` export to `react-router/internal`
1396 UNSTABLE: removed `Info` export from generated `+types/*` files
1397
1398- Avoid initial fetcher execution 404 error when Lazy Route Discovery is interrupted by a navigation ([#13564](https://github.com/remix-run/react-router/pull/13564))
1399
1400- href replaces splats `*` ([#13593](https://github.com/remix-run/react-router/pull/13593))
1401
1402 ```ts
1403 const a = href("/products/*", { "*": "/1/edit" });
1404 // -> /products/1/edit
1405 ```
1406
1407## 7.6.0
1408
1409### Minor Changes
1410
1411- Added a new `react-router.config.ts` `routeDiscovery` option to configure Lazy Route Discovery behavior. ([#13451](https://github.com/remix-run/react-router/pull/13451))
1412 - By default, Lazy Route Discovery is enabled and makes manifest requests to the `/__manifest` path:
1413 - `routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" }`
1414 - You can modify the manifest path used:
1415 - `routeDiscovery: { mode: "lazy", manifestPath: "/custom-manifest" }`
1416 - Or you can disable this feature entirely and include all routes in the manifest on initial document load:
1417 - `routeDiscovery: { mode: "initial" }`
1418
1419- Add support for route component props in `createRoutesStub`. This allows you to unit test your route components using the props instead of the hooks: ([#13528](https://github.com/remix-run/react-router/pull/13528))
1420
1421 ```tsx
1422 let RoutesStub = createRoutesStub([
1423 {
1424 path: "/",
1425 Component({ loaderData }) {
1426 let data = loaderData as { message: string };
1427 return <pre data-testid="data">Message: {data.message}</pre>;
1428 },
1429 loader() {
1430 return { message: "hello" };
1431 },
1432 },
1433 ]);
1434
1435 render(<RoutesStub />);
1436
1437 await waitFor(() => screen.findByText("Message: hello"));
1438 ```
1439
1440### Patch Changes
1441
1442- Fix `react-router` module augmentation for `NodeNext` ([#13498](https://github.com/remix-run/react-router/pull/13498))
1443
1444- Don't bundle `react-router` in `react-router/dom` CJS export ([#13497](https://github.com/remix-run/react-router/pull/13497))
1445
1446- Fix bug where a submitting `fetcher` would get stuck in a `loading` state if a revalidating `loader` redirected ([#12873](https://github.com/remix-run/react-router/pull/12873))
1447
1448- Fix hydration error if a server `loader` returned `undefined` ([#13496](https://github.com/remix-run/react-router/pull/13496))
1449
1450- Fix initial load 404 scenarios in data mode ([#13500](https://github.com/remix-run/react-router/pull/13500))
1451
1452- Stabilize `useRevalidator`'s `revalidate` function ([#13542](https://github.com/remix-run/react-router/pull/13542))
1453
1454- Preserve status code if a `clientAction` throws a `data()` result in framework mode ([#13522](https://github.com/remix-run/react-router/pull/13522))
1455
1456- Be defensive against leading double slashes in paths to avoid `Invalid URL` errors from the URL constructor ([#13510](https://github.com/remix-run/react-router/pull/13510))
1457 - Note we do not sanitize/normalize these paths - we only detect them so we can avoid the error that would be thrown by `new URL("//", window.location.origin)`
1458
1459- Remove `Navigator` declaration for `navigator.connection.saveData` to avoid messing with any other types beyond `saveData` in userland ([#13512](https://github.com/remix-run/react-router/pull/13512))
1460
1461- Fix `handleError` `params` values on `.data` requests for routes with a dynamic param as the last URL segment ([#13481](https://github.com/remix-run/react-router/pull/13481))
1462
1463- Don't trigger an `ErrorBoundary` UI before the reload when we detect a manifest verison mismatch in Lazy Route Discovery ([#13480](https://github.com/remix-run/react-router/pull/13480))
1464
1465- Inline `turbo-stream@2.4.1` dependency and fix decoding ordering of Map/Set instances ([#13518](https://github.com/remix-run/react-router/pull/13518))
1466
1467- Only render dev warnings in DEV mode ([#13461](https://github.com/remix-run/react-router/pull/13461))
1468
1469- UNSTABLE: Fix a few bugs with error bubbling in middleware use-cases ([#13538](https://github.com/remix-run/react-router/pull/13538))
1470
1471- Short circuit post-processing on aborted `dataStrategy` requests ([#13521](https://github.com/remix-run/react-router/pull/13521))
1472 - This resolves non-user-facing console errors of the form `Cannot read properties of undefined (reading 'result')`
1473
1474## 7.5.3
1475
1476### Patch Changes
1477
1478- Fix bug where bubbled action errors would result in `loaderData` being cleared at the handling `ErrorBoundary` route ([#13476](https://github.com/remix-run/react-router/pull/13476))
1479- Handle redirects from `clientLoader.hydrate` initial load executions ([#13477](https://github.com/remix-run/react-router/pull/13477))
1480
1481## 7.5.2
1482
1483### Patch Changes
1484
1485- Update Single Fetch to also handle the 204 redirects used in `?_data` requests in Remix v2 ([#13364](https://github.com/remix-run/react-router/pull/13364))
1486 - This allows applications to return a redirect on `.data` requests from outside the scope of React Router (i.e., an `express`/`hono` middleware)
1487 - ⚠️ Please note that doing so relies on implementation details that are subject to change without a SemVer major release
1488 - This is primarily done to ease upgrading to Single Fetch for existing Remix v2 applications, but the recommended way to handle this is redirecting from a route middleware
1489
1490- Adjust approach for Prerendering/SPA Mode via headers ([#13453](https://github.com/remix-run/react-router/pull/13453))
1491
1492## 7.5.1
1493
1494### Patch Changes
1495
1496- Fix single fetch bug where no revalidation request would be made when navigating upwards to a reused parent route ([#13253](https://github.com/remix-run/react-router/pull/13253))
1497
1498- When using the object-based `route.lazy` API, the `HydrateFallback` and `hydrateFallbackElement` properties are now skipped when lazy loading routes after hydration. ([#13376](https://github.com/remix-run/react-router/pull/13376))
1499
1500 If you move the code for these properties into a separate file, you can use this optimization to avoid downloading unused hydration code. For example:
1501
1502 ```ts
1503 createBrowserRouter([
1504 {
1505 path: "/show/:showId",
1506 lazy: {
1507 loader: async () => (await import("./show.loader.js")).loader,
1508 Component: async () => (await import("./show.component.js")).Component,
1509 HydrateFallback: async () =>
1510 (await import("./show.hydrate-fallback.js")).HydrateFallback,
1511 },
1512 },
1513 ]);
1514 ```
1515
1516- Properly revalidate prerendered paths when param values change ([#13380](https://github.com/remix-run/react-router/pull/13380))
1517
1518- UNSTABLE: Add a new `unstable_runClientMiddleware` argument to `dataStrategy` to enable middleware execution in custom `dataStrategy` implementations ([#13395](https://github.com/remix-run/react-router/pull/13395))
1519
1520- UNSTABLE: Add better error messaging when `getLoadContext` is not updated to return a `Map`" ([#13242](https://github.com/remix-run/react-router/pull/13242))
1521
1522- Do not automatically add `null` to `staticHandler.query()` `context.loaderData` if routes do not have loaders ([#13223](https://github.com/remix-run/react-router/pull/13223))
1523 - This was a Remix v2 implementation detail inadvertently left in for React Router v7
1524 - Now that we allow returning `undefined` from loaders, our prior check of `loaderData[routeId] !== undefined` was no longer sufficient and was changed to a `routeId in loaderData` check - these `null` values can cause issues for this new check
1525 - ⚠️ This could be a "breaking bug fix" for you if you are doing manual SSR with `createStaticHandler()`/`<StaticRouterProvider>`, and using `context.loaderData` to control `<RouterProvider>` hydration behavior on the client
1526
1527- Fix prerendering when a loader returns a redirect ([#13365](https://github.com/remix-run/react-router/pull/13365))
1528
1529- UNSTABLE: Update context type for `LoaderFunctionArgs`/`ActionFunctionArgs` when middleware is enabled ([#13381](https://github.com/remix-run/react-router/pull/13381))
1530
1531- Add support for the new `unstable_shouldCallHandler`/`unstable_shouldRevalidateArgs` APIs in `dataStrategy` ([#13253](https://github.com/remix-run/react-router/pull/13253))
1532
1533## 7.5.0
1534
1535### Minor Changes
1536
1537- Add granular object-based API for `route.lazy` to support lazy loading of individual route properties, for example: ([#13294](https://github.com/remix-run/react-router/pull/13294))
1538
1539 ```ts
1540 createBrowserRouter([
1541 {
1542 path: "/show/:showId",
1543 lazy: {
1544 loader: async () => (await import("./show.loader.js")).loader,
1545 action: async () => (await import("./show.action.js")).action,
1546 Component: async () => (await import("./show.component.js")).Component,
1547 },
1548 },
1549 ]);
1550 ```
1551
1552 **Breaking change for `route.unstable_lazyMiddleware` consumers**
1553
1554 The `route.unstable_lazyMiddleware` property is no longer supported. If you want to lazily load middleware, you must use the new object-based `route.lazy` API with `route.lazy.unstable_middleware`, for example:
1555
1556 ```ts
1557 createBrowserRouter([
1558 {
1559 path: "/show/:showId",
1560 lazy: {
1561 unstable_middleware: async () =>
1562 (await import("./show.middleware.js")).middleware,
1563 // etc.
1564 },
1565 },
1566 ]);
1567 ```
1568
1569### Patch Changes
1570
1571- Introduce `unstable_subResourceIntegrity` future flag that enables generation of an importmap with integrity for the scripts that will be loaded by the browser. ([#13163](https://github.com/remix-run/react-router/pull/13163))
1572
1573## 7.4.1
1574
1575### Patch Changes
1576
1577- Fix types on `unstable_MiddlewareFunction` to avoid type errors when a middleware doesn't return a value ([#13311](https://github.com/remix-run/react-router/pull/13311))
1578- Dedupe calls to `route.lazy` functions ([#13260](https://github.com/remix-run/react-router/pull/13260))
1579- Add support for `route.unstable_lazyMiddleware` function to allow lazy loading of middleware logic. ([#13210](https://github.com/remix-run/react-router/pull/13210))
1580
1581 **Breaking change for `unstable_middleware` consumers**
1582
1583 The `route.unstable_middleware` property is no longer supported in the return value from `route.lazy`. If you want to lazily load middleware, you must use `route.unstable_lazyMiddleware`.
1584
1585## 7.4.0
1586
1587### Patch Changes
1588
1589- Fix root loader data on initial load redirects in SPA mode ([#13222](https://github.com/remix-run/react-router/pull/13222))
1590- Load ancestor pathless/index routes in lazy route discovery for upwards non-eager-discoery routing ([#13203](https://github.com/remix-run/react-router/pull/13203))
1591- Fix `shouldRevalidate` behavior for `clientLoader`-only routes in `ssr:true` apps ([#13221](https://github.com/remix-run/react-router/pull/13221))
1592- UNSTABLE: Fix `RequestHandler` `loadContext` parameter type when middleware is enabled ([#13204](https://github.com/remix-run/react-router/pull/13204))
1593- UNSTABLE: Update `Route.unstable_MiddlewareFunction` to have a return value of `Response | undefined` instead of `Response | void` becaue you should not return anything if you aren't returning the `Response` ([#13199](https://github.com/remix-run/react-router/pull/13199))
1594- UNSTABLE(BREAKING): If a middleware throws an error, ensure we only bubble the error itself via `next()` and are no longer leaking the `MiddlewareError` implementation detail ([#13180](https://github.com/remix-run/react-router/pull/13180))
1595
1596## 7.3.0
1597
1598### Minor Changes
1599
1600- Add `fetcherKey` as a parameter to `patchRoutesOnNavigation` ([#13061](https://github.com/remix-run/react-router/pull/13061))
1601 - In framework mode, Lazy Route Discovery will now detect manifest version mismatches after a new deploy
1602 - On navigations to undiscovered routes, this mismatch will trigger a document reload of the destination path
1603 - On `fetcher` calls to undiscovered routes, this mismatch will trigger a document reload of the current path
1604
1605### Patch Changes
1606
1607- Skip resource route flow in dev server in SPA mode ([#13113](https://github.com/remix-run/react-router/pull/13113))
1608
1609- Support middleware on routes (unstable) ([#12941](https://github.com/remix-run/react-router/pull/12941))
1610
1611 Middleware is implemented behind a `future.unstable_middleware` flag. To enable, you must enable the flag and the types in your `react-router-config.ts` file:
1612
1613 ```ts
1614 import type { Config } from "@react-router/dev/config";
1615 import type { Future } from "react-router";
1616
1617 declare module "react-router" {
1618 interface Future {
1619 unstable_middleware: true; // 👈 Enable middleware types
1620 }
1621 }
1622
1623 export default {
1624 future: {
1625 unstable_middleware: true, // 👈 Enable middleware
1626 },
1627 } satisfies Config;
1628 ```
1629
1630 ⚠️ Middleware is unstable and should not be adopted in production. There is at least one known de-optimization in route module loading for `clientMiddleware` that we will be addressing this before a stable release.
1631
1632 ⚠️ Enabling middleware contains a breaking change to the `context` parameter passed to your `loader`/`action` functions - see below for more information.
1633
1634 Once enabled, routes can define an array of middleware functions that will run sequentially before route handlers run. These functions accept the same parameters as `loader`/`action` plus an additional `next` parameter to run the remaining data pipeline. This allows middlewares to perform logic before and after handlers execute.
1635
1636 ```tsx
1637 // Framework mode
1638 export const unstable_middleware = [serverLogger, serverAuth]; // server
1639 export const unstable_clientMiddleware = [clientLogger]; // client
1640
1641 // Library mode
1642 const routes = [
1643 {
1644 path: "/",
1645 // Middlewares are client-side for library mode SPA's
1646 unstable_middleware: [clientLogger, clientAuth],
1647 loader: rootLoader,
1648 Component: Root,
1649 },
1650 ];
1651 ```
1652
1653 Here's a simple example of a client-side logging middleware that can be placed on the root route:
1654
1655 ```tsx
1656 const clientLogger: Route.unstable_ClientMiddlewareFunction = async (
1657 { request },
1658 next,
1659 ) => {
1660 let start = performance.now();
1661
1662 // Run the remaining middlewares and all route loaders
1663 await next();
1664
1665 let duration = performance.now() - start;
1666 console.log(`Navigated to ${request.url} (${duration}ms)`);
1667 };
1668 ```
1669
1670 Note that in the above example, the `next`/`middleware` functions don't return anything. This is by design as on the client there is no "response" to send over the network like there would be for middlewares running on the server. The data is all handled behind the scenes by the stateful `router`.
1671
1672 For a server-side middleware, the `next` function will return the HTTP `Response` that React Router will be sending across the wire, thus giving you a chance to make changes as needed. You may throw a new response to short circuit and respond immediately, or you may return a new or altered response to override the default returned by `next()`.
1673
1674 ```tsx
1675 const serverLogger: Route.unstable_MiddlewareFunction = async (
1676 { request, params, context },
1677 next,
1678 ) => {
1679 let start = performance.now();
1680
1681 // 👇 Grab the response here
1682 let res = await next();
1683
1684 let duration = performance.now() - start;
1685 console.log(`Navigated to ${request.url} (${duration}ms)`);
1686
1687 // 👇 And return it here (optional if you don't modify the response)
1688 return res;
1689 };
1690 ```
1691
1692 You can throw a `redirect` from a middleware to short circuit any remaining processing:
1693
1694 ```tsx
1695 import { sessionContext } from "../context";
1696 const serverAuth: Route.unstable_MiddlewareFunction = (
1697 { request, params, context },
1698 next,
1699 ) => {
1700 let session = context.get(sessionContext);
1701 let user = session.get("user");
1702 if (!user) {
1703 session.set("returnTo", request.url);
1704 throw redirect("/login", 302);
1705 }
1706 };
1707 ```
1708
1709 _Note that in cases like this where you don't need to do any post-processing you don't need to call the `next` function or return a `Response`._
1710
1711 Here's another example of using a server middleware to detect 404s and check the CMS for a redirect:
1712
1713 ```tsx
1714 const redirects: Route.unstable_MiddlewareFunction = async ({
1715 request,
1716 next,
1717 }) => {
1718 // attempt to handle the request
1719 let res = await next();
1720
1721 // if it's a 404, check the CMS for a redirect, do it last
1722 // because it's expensive
1723 if (res.status === 404) {
1724 let cmsRedirect = await checkCMSRedirects(request.url);
1725 if (cmsRedirect) {
1726 throw redirect(cmsRedirect, 302);
1727 }
1728 }
1729
1730 return res;
1731 };
1732 ```
1733
1734 **`context` parameter**
1735
1736 When middleware is enabled, your application will use a different type of `context` parameter in your loaders and actions to provide better type safety. Instead of `AppLoadContext`, `context` will now be an instance of `ContextProvider` that you can use with type-safe contexts (similar to `React.createContext`):
1737
1738 ```ts
1739 import { unstable_createContext } from "react-router";
1740 import { Route } from "./+types/root";
1741 import type { Session } from "./sessions.server";
1742 import { getSession } from "./sessions.server";
1743
1744 let sessionContext = unstable_createContext<Session>();
1745
1746 const sessionMiddleware: Route.unstable_MiddlewareFunction = ({
1747 context,
1748 request,
1749 }) => {
1750 let session = await getSession(request);
1751 context.set(sessionContext, session);
1752 // ^ must be of type Session
1753 };
1754
1755 // ... then in some downstream middleware
1756 const loggerMiddleware: Route.unstable_MiddlewareFunction = ({
1757 context,
1758 request,
1759 }) => {
1760 let session = context.get(sessionContext);
1761 // ^ typeof Session
1762 console.log(session.get("userId"), request.method, request.url);
1763 };
1764
1765 // ... or some downstream loader
1766 export function loader({ context }: Route.LoaderArgs) {
1767 let session = context.get(sessionContext);
1768 let profile = await getProfile(session.get("userId"));
1769 return { profile };
1770 }
1771 ```
1772
1773 If you are using a custom server with a `getLoadContext` function, the return value for initial context values passed from the server adapter layer is no longer an object and should now return an `unstable_InitialContext` (`Map<RouterContext, unknown>`):
1774
1775 ```ts
1776 let adapterContext = unstable_createContext<MyAdapterContext>();
1777
1778 function getLoadContext(req, res): unstable_InitialContext {
1779 let map = new Map();
1780 map.set(adapterContext, getAdapterContext(req));
1781 return map;
1782 }
1783 ```
1784
1785- Fix types for loaderData and actionData that contained `Record`s ([#13139](https://github.com/remix-run/react-router/pull/13139))
1786
1787 UNSTABLE(BREAKING):
1788
1789 `unstable_SerializesTo` added a way to register custom serialization types in Single Fetch for other library and framework authors like Apollo.
1790 It was implemented with branded type whose branded property that was made optional so that casting arbitrary values was easy:
1791
1792 ```ts
1793 // without the brand being marked as optional
1794 let x1 = 42 as unknown as unstable_SerializesTo<number>;
1795 // ^^^^^^^^^^
1796
1797 // with the brand being marked as optional
1798 let x2 = 42 as unstable_SerializesTo<number>;
1799 ```
1800
1801 However, this broke type inference in `loaderData` and `actionData` for any `Record` types as those would now (incorrectly) match `unstable_SerializesTo`.
1802 This affected all users, not just those that depended on `unstable_SerializesTo`.
1803 To fix this, the branded property of `unstable_SerializesTo` is marked as required instead of optional.
1804
1805 For library and framework authors using `unstable_SerializesTo`, you may need to add `as unknown` casts before casting to `unstable_SerializesTo`.
1806
1807- Fix single fetch `_root.data` requests when a `basename` is used ([#12898](https://github.com/remix-run/react-router/pull/12898))
1808
1809- Add `context` support to client side data routers (unstable) ([#12941](https://github.com/remix-run/react-router/pull/12941))
1810
1811 Your application `loader` and `action` functions on the client will now receive a `context` parameter. This is an instance of `unstable_RouterContextProvider` that you use with type-safe contexts (similar to `React.createContext`) and is most useful with the corresponding `middleware`/`clientMiddleware` API's:
1812
1813 ```ts
1814 import { unstable_createContext } from "react-router";
1815
1816 type User = {
1817 /*...*/
1818 };
1819
1820 let userContext = unstable_createContext<User>();
1821
1822 function sessionMiddleware({ context }) {
1823 let user = await getUser();
1824 context.set(userContext, user);
1825 }
1826
1827 // ... then in some downstream loader
1828 function loader({ context }) {
1829 let user = context.get(userContext);
1830 let profile = await getProfile(user.id);
1831 return { profile };
1832 }
1833 ```
1834
1835 Similar to server-side requests, a fresh `context` will be created per navigation (or `fetcher` call). If you have initial data you'd like to populate in the context for every request, you can provide an `unstable_getContext` function at the root of your app:
1836 - Library mode - `createBrowserRouter(routes, { unstable_getContext })`
1837 - Framework mode - `<HydratedRouter unstable_getContext>`
1838
1839 This function should return an value of type `unstable_InitialContext` which is a `Map<unstable_RouterContext, unknown>` of context's and initial values:
1840
1841 ```ts
1842 const loggerContext = unstable_createContext<(...args: unknown[]) => void>();
1843
1844 function logger(...args: unknown[]) {
1845 console.log(new Date.toISOString(), ...args);
1846 }
1847
1848 function unstable_getContext() {
1849 let map = new Map();
1850 map.set(loggerContext, logger);
1851 return map;
1852 }
1853 ```
1854
1855## 7.2.0
1856
1857### Minor Changes
1858
1859- New type-safe `href` utility that guarantees links point to actual paths in your app ([#13012](https://github.com/remix-run/react-router/pull/13012))
1860
1861 ```tsx
1862 import { href } from "react-router";
1863
1864 export default function Component() {
1865 const link = href("/blog/:slug", { slug: "my-first-post" });
1866 return (
1867 <main>
1868 <Link to={href("/products/:id", { id: "asdf" })} />
1869 <NavLink to={href("/:lang?/about", { lang: "en" })} />
1870 </main>
1871 );
1872 }
1873 ```
1874
1875### Patch Changes
1876
1877- Fix typegen for repeated params ([#13012](https://github.com/remix-run/react-router/pull/13012))
1878
1879 In React Router, path parameters are keyed by their name.
1880 So for a path pattern like `/a/:id/b/:id?/c/:id`, the last `:id` will set the value for `id` in `useParams` and the `params` prop.
1881 For example, `/a/1/b/2/c/3` will result in the value `{ id: 3 }` at runtime.
1882
1883 Previously, generated types for params incorrectly modeled repeated params with an array.
1884 So `/a/1/b/2/c/3` generated a type like `{ id: [1,2,3] }`.
1885
1886 To be consistent with runtime behavior, the generated types now correctly model the "last one wins" semantics of path parameters.
1887 So `/a/1/b/2/c/3` now generates a type like `{ id: 3 }`.
1888
1889- Don't apply Single Fetch revalidation de-optimization when in SPA mode since there is no server HTTP request ([#12948](https://github.com/remix-run/react-router/pull/12948))
1890
1891- Properly handle revalidations to across a prerender/SPA boundary ([#13021](https://github.com/remix-run/react-router/pull/13021))
1892 - In "hybrid" applications where some routes are pre-rendered and some are served from a SPA fallback, we need to avoid making `.data` requests if the path wasn't pre-rendered because the request will 404
1893 - We don't know all the pre-rendered paths client-side, however:
1894 - All `loader` data in `ssr:false` mode is static because it's generated at build time
1895 - A route must use a `clientLoader` to do anything dynamic
1896 - Therefore, if a route only has a `loader` and not a `clientLoader`, we disable revalidation by default because there is no new data to retrieve
1897 - We short circuit and skip single fetch `.data` request logic if there are no server loaders with `shouldLoad=true` in our single fetch `dataStrategy`
1898 - This ensures that the route doesn't cause a `.data` request that would 404 after a submission
1899
1900- Error at build time in `ssr:false` + `prerender` apps for the edge case scenario of: ([#13021](https://github.com/remix-run/react-router/pull/13021))
1901 - A parent route has only a `loader` (does not have a `clientLoader`)
1902 - The parent route is pre-rendered
1903 - The parent route has children routes which are not prerendered
1904 - This means that when the child paths are loaded via the SPA fallback, the parent won't have any `loaderData` because there is no server on which to run the `loader`
1905 - This can be resolved by either adding a parent `clientLoader` or pre-rendering the child paths
1906 - If you add a `clientLoader`, calling the `serverLoader()` on non-prerendered paths will throw a 404
1907
1908- Add unstable support for splitting route modules in framework mode via `future.unstable_splitRouteModules` ([#11871](https://github.com/remix-run/react-router/pull/11871))
1909
1910- Add `unstable_SerializesTo` brand type for library authors to register types serializable by React Router's streaming format (`turbo-stream`) ([`ab5b05b02`](https://github.com/remix-run/react-router/commit/ab5b05b02f99f062edb3c536c392197c88eb6c77))
1911
1912- Align dev server behavior with static file server behavior when `ssr:false` is set ([#12948](https://github.com/remix-run/react-router/pull/12948))
1913 - When no `prerender` config exists, only SSR down to the root `HydrateFallback` (SPA Mode)
1914 - When a `prerender` config exists but the current path is not prerendered, only SSR down to the root `HydrateFallback` (SPA Fallback)
1915 - Return a 404 on `.data` requests to non-pre-rendered paths
1916
1917- Improve prefetch performance of CSS side effects in framework mode ([#12889](https://github.com/remix-run/react-router/pull/12889))
1918
1919- Disable Lazy Route Discovery for all `ssr:false` apps and not just "SPA Mode" because there is no runtime server to serve the search-param-configured `__manifest` requests ([#12894](https://github.com/remix-run/react-router/pull/12894))
1920 - We previously only disabled this for "SPA Mode" which is `ssr:false` and no `prerender` config but we realized it should apply to all `ssr:false` apps, including those prerendering multiple pages
1921 - In those `prerender` scenarios we would prerender the `/__manifest` file assuming the static file server would serve it but that makes some unneccesary assumptions about the static file server behaviors
1922
1923- Properly handle interrupted manifest requests in lazy route discovery ([#12915](https://github.com/remix-run/react-router/pull/12915))
1924
1925## 7.1.5
1926
1927### Patch Changes
1928
1929- Fix regression introduced in `7.1.4` via [#12800](https://github.com/remix-run/react-router/pull/12800) that caused issues navigating to hash routes inside splat routes for applications using Lazy Route Discovery (`patchRoutesOnNavigation`) ([#12927](https://github.com/remix-run/react-router/pull/12927))
1930
1931## 7.1.4
1932
1933### Patch Changes
1934
1935- Internal reorg to clean up some duplicated route module types ([#12799](https://github.com/remix-run/react-router/pull/12799))
1936- Properly handle status codes that cannot have a body in single fetch responses (204, etc.) ([#12760](https://github.com/remix-run/react-router/pull/12760))
1937- Stop erroring on resource routes that return raw strings/objects and instead serialize them as `text/plain` or `application/json` responses ([#12848](https://github.com/remix-run/react-router/pull/12848))
1938 - This only applies when accessed as a resource route without the `.data` extension
1939 - When accessed from a Single Fetch `.data` request, they will still be encoded via `turbo-stream`
1940- Optimize Lazy Route Discovery path discovery to favor a single `querySelectorAll` call at the `body` level instead of many calls at the sub-tree level ([#12731](https://github.com/remix-run/react-router/pull/12731))
1941- Properly bubble headers as `errorHeaders` when throwing a `data()` result ([#12846](https://github.com/remix-run/react-router/pull/12846))
1942 - Avoid duplication of `Set-Cookie` headers could be duplicated if also returned from `headers`
1943- Optimize route matching by skipping redundant `matchRoutes` calls when possible ([#12800](https://github.com/remix-run/react-router/pull/12800))
1944
1945## 7.1.3
1946
1947_No changes_
1948
1949## 7.1.2
1950
1951### Patch Changes
1952
1953- Fix issue with fetcher data cleanup in the data layer on fetcher unmount ([#12681](https://github.com/remix-run/react-router/pull/12681))
1954- Do not rely on `symbol` for filtering out `redirect` responses from loader data ([#12694](https://github.com/remix-run/react-router/pull/12694))
1955
1956 Previously, some projects were getting type checking errors like:
1957
1958 ```ts
1959 error TS4058: Return type of exported function has or is using name 'redirectSymbol' from external module "node_modules/..." but cannot be named.
1960 ```
1961
1962 Now that `symbol`s are not used for the `redirect` response type, these errors should no longer be present.
1963
1964## 7.1.1
1965
1966_No changes_
1967
1968## 7.1.0
1969
1970### Patch Changes
1971
1972- Throw unwrapped single fetch redirect to align with pre-single fetch behavior ([#12506](https://github.com/remix-run/react-router/pull/12506))
1973- Ignore redirects when inferring loader data types ([#12527](https://github.com/remix-run/react-router/pull/12527))
1974- Remove `<Link prefetch>` warning which suffers from false positives in a lazy route discovery world ([#12485](https://github.com/remix-run/react-router/pull/12485))
1975
1976## 7.0.2
1977
1978### Patch Changes
1979
1980- temporarily only use one build in export map so packages can have a peer dependency on react router ([#12437](https://github.com/remix-run/react-router/pull/12437))
1981- Generate wide `matches` and `params` types for current route and child routes ([#12397](https://github.com/remix-run/react-router/pull/12397))
1982
1983 At runtime, `matches` includes child route matches and `params` include child route path parameters.
1984 But previously, we only generated types for parent routes in `matches`; for `params`, we only considered the parent routes and the current route.
1985 To align our generated types more closely to the runtime behavior, we now generate more permissive, wider types when accessing child route information.
1986
1987## 7.0.1
1988
1989_No changes_
1990
1991## 7.0.0
1992
1993### Major Changes
1994
1995- Remove the original `defer` implementation in favor of using raw promises via single fetch and `turbo-stream`. This removes these exports from React Router: ([#11744](https://github.com/remix-run/react-router/pull/11744))
1996 - `defer`
1997 - `AbortedDeferredError`
1998 - `type TypedDeferredData`
1999 - `UNSAFE_DeferredData`
2000 - `UNSAFE_DEFERRED_SYMBOL`,
2001
2002- - Collapse `@remix-run/router` into `react-router` ([#11505](https://github.com/remix-run/react-router/pull/11505))
2003 - Collapse `react-router-dom` into `react-router`
2004 - Collapse `@remix-run/server-runtime` into `react-router`
2005 - Collapse `@remix-run/testing` into `react-router`
2006
2007- Remove single fetch future flag. ([#11522](https://github.com/remix-run/react-router/pull/11522))
2008
2009- Drop support for Node 16, React Router SSR now requires Node 18 or higher ([#11391](https://github.com/remix-run/react-router/pull/11391))
2010
2011- Remove `future.v7_startTransition` flag ([#11696](https://github.com/remix-run/react-router/pull/11696))
2012
2013- - Expose the underlying router promises from the following APIs for compsition in React 19 APIs: ([#11521](https://github.com/remix-run/react-router/pull/11521))
2014 - `useNavigate()`
2015 - `useSubmit`
2016 - `useFetcher().load`
2017 - `useFetcher().submit`
2018 - `useRevalidator.revalidate`
2019
2020- Remove `future.v7_normalizeFormMethod` future flag ([#11697](https://github.com/remix-run/react-router/pull/11697))
2021
2022- For Remix consumers migrating to React Router, the `crypto` global from the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) is now required when using cookie and session APIs. This means that the following APIs are provided from `react-router` rather than platform-specific packages: ([#11837](https://github.com/remix-run/react-router/pull/11837))
2023 - `createCookie`
2024 - `createCookieSessionStorage`
2025 - `createMemorySessionStorage`
2026 - `createSessionStorage`
2027
2028 For consumers running older versions of Node, the `installGlobals` function from `@remix-run/node` has been updated to define `globalThis.crypto`, using [Node's `require('node:crypto').webcrypto` implementation.](https://nodejs.org/api/webcrypto.html)
2029
2030 Since platform-specific packages no longer need to implement this API, the following low-level APIs have been removed:
2031 - `createCookieFactory`
2032 - `createSessionStorageFactory`
2033 - `createCookieSessionStorageFactory`
2034 - `createMemorySessionStorageFactory`
2035
2036- Imports/Exports cleanup ([#11840](https://github.com/remix-run/react-router/pull/11840))
2037 - Removed the following exports that were previously public API from `@remix-run/router`
2038 - types
2039 - `AgnosticDataIndexRouteObject`
2040 - `AgnosticDataNonIndexRouteObject`
2041 - `AgnosticDataRouteMatch`
2042 - `AgnosticDataRouteObject`
2043 - `AgnosticIndexRouteObject`
2044 - `AgnosticNonIndexRouteObject`
2045 - `AgnosticRouteMatch`
2046 - `AgnosticRouteObject`
2047 - `TrackedPromise`
2048 - `unstable_AgnosticPatchRoutesOnMissFunction`
2049 - `Action` -> exported as `NavigationType` via `react-router`
2050 - `Router` exported as `DataRouter` to differentiate from RR's `<Router>`
2051 - API
2052 - `getToPathname` (`@private`)
2053 - `joinPaths` (`@private`)
2054 - `normalizePathname` (`@private`)
2055 - `resolveTo` (`@private`)
2056 - `stripBasename` (`@private`)
2057 - `createBrowserHistory` -> in favor of `createBrowserRouter`
2058 - `createHashHistory` -> in favor of `createHashRouter`
2059 - `createMemoryHistory` -> in favor of `createMemoryRouter`
2060 - `createRouter`
2061 - `createStaticHandler` -> in favor of wrapper `createStaticHandler` in RR Dom
2062 - `getStaticContextFromError`
2063 - Removed the following exports that were previously public API from `react-router`
2064 - `Hash`
2065 - `Pathname`
2066 - `Search`
2067
2068- update minimum node version to 18 ([#11690](https://github.com/remix-run/react-router/pull/11690))
2069
2070- Remove `future.v7_prependBasename` from the ionternalized `@remix-run/router` package ([#11726](https://github.com/remix-run/react-router/pull/11726))
2071
2072- Migrate Remix type generics to React Router ([#12180](https://github.com/remix-run/react-router/pull/12180))
2073 - These generics are provided for Remix v2 migration purposes
2074 - These generics and the APIs they exist on should be considered informally deprecated in favor of the new `Route.*` types
2075 - Anyone migrating from React Router v6 should probably not leverage these new generics and should migrate straight to the `Route.*` types
2076 - For React Router v6 users, these generics are new and should not impact your app, with one exception
2077 - `useFetcher` previously had an optional generic (used primarily by Remix v2) that expected the data type
2078 - This has been updated in v7 to expect the type of the function that generates the data (i.e., `typeof loader`/`typeof action`)
2079 - Therefore, you should update your usages:
2080 - ❌ `useFetcher<LoaderData>()`
2081 - ✅ `useFetcher<typeof loader>()`
2082
2083- Remove `future.v7_throwAbortReason` from internalized `@remix-run/router` package ([#11728](https://github.com/remix-run/react-router/pull/11728))
2084
2085- Add `exports` field to all packages ([#11675](https://github.com/remix-run/react-router/pull/11675))
2086
2087- node package no longer re-exports from react-router ([#11702](https://github.com/remix-run/react-router/pull/11702))
2088
2089- renamed RemixContext to FrameworkContext ([#11705](https://github.com/remix-run/react-router/pull/11705))
2090
2091- updates the minimum React version to 18 ([#11689](https://github.com/remix-run/react-router/pull/11689))
2092
2093- PrefetchPageDescriptor replaced by PageLinkDescriptor ([#11960](https://github.com/remix-run/react-router/pull/11960))
2094
2095- - Consolidate types previously duplicated across `@remix-run/router`, `@remix-run/server-runtime`, and `@remix-run/react` now that they all live in `react-router` ([#12177](https://github.com/remix-run/react-router/pull/12177))
2096 - Examples: `LoaderFunction`, `LoaderFunctionArgs`, `ActionFunction`, `ActionFunctionArgs`, `DataFunctionArgs`, `RouteManifest`, `LinksFunction`, `Route`, `EntryRoute`
2097 - The `RouteManifest` type used by the "remix" code is now slightly stricter because it is using the former `@remix-run/router` `RouteManifest`
2098 - `Record<string, Route> -> Record<string, Route | undefined>`
2099 - Removed `AppData` type in favor of inlining `unknown` in the few locations it was used
2100 - Removed `ServerRuntimeMeta*` types in favor of the `Meta*` types they were duplicated from
2101
2102- - Remove the `future.v7_partialHydration` flag ([#11725](https://github.com/remix-run/react-router/pull/11725))
2103 - This also removes the `<RouterProvider fallbackElement>` prop
2104 - To migrate, move the `fallbackElement` to a `hydrateFallbackElement`/`HydrateFallback` on your root route
2105 - Also worth nothing there is a related breaking changer with this future flag:
2106 - Without `future.v7_partialHydration` (when using `fallbackElement`), `state.navigation` was populated during the initial load
2107 - With `future.v7_partialHydration`, `state.navigation` remains in an `"idle"` state during the initial load
2108
2109- Remove `v7_relativeSplatPath` future flag ([#11695](https://github.com/remix-run/react-router/pull/11695))
2110
2111- Drop support for Node 18, update minimum Node vestion to 20 ([#12171](https://github.com/remix-run/react-router/pull/12171))
2112 - Remove `installGlobals()` as this should no longer be necessary
2113
2114- Remove remaining future flags ([#11820](https://github.com/remix-run/react-router/pull/11820))
2115 - React Router `v7_skipActionErrorRevalidation`
2116 - Remix `v3_fetcherPersist`, `v3_relativeSplatPath`, `v3_throwAbortReason`
2117
2118- rename createRemixStub to createRoutesStub ([#11692](https://github.com/remix-run/react-router/pull/11692))
2119
2120- Remove `@remix-run/router` deprecated `detectErrorBoundary` option in favor of `mapRouteProperties` ([#11751](https://github.com/remix-run/react-router/pull/11751))
2121
2122- Add `react-router/dom` subpath export to properly enable `react-dom` as an optional `peerDependency` ([#11851](https://github.com/remix-run/react-router/pull/11851))
2123 - This ensures that we don't blindly `import ReactDOM from "react-dom"` in `<RouterProvider>` in order to access `ReactDOM.flushSync()`, since that would break `createMemoryRouter` use cases in non-DOM environments
2124 - DOM environments should import from `react-router/dom` to get the proper component that makes `ReactDOM.flushSync()` available:
2125 - If you are using the Vite plugin, use this in your `entry.client.tsx`:
2126 - `import { HydratedRouter } from 'react-router/dom'`
2127 - If you are not using the Vite plugin and are manually calling `createBrowserRouter`/`createHashRouter`:
2128 - `import { RouterProvider } from "react-router/dom"`
2129
2130- Remove `future.v7_fetcherPersist` flag ([#11731](https://github.com/remix-run/react-router/pull/11731))
2131
2132- Update `cookie` dependency to `^1.0.1` - please see the [release notes](https://github.com/jshttp/cookie/releases) for any breaking changes ([#12172](https://github.com/remix-run/react-router/pull/12172))
2133
2134### Minor Changes
2135
2136- - Add support for `prerender` config in the React Router vite plugin, to support existing SSG use-cases ([#11539](https://github.com/remix-run/react-router/pull/11539))
2137 - You can use the `prerender` config to pre-render your `.html` and `.data` files at build time and then serve them statically at runtime (either from a running server or a CDN)
2138 - `prerender` can either be an array of string paths, or a function (sync or async) that returns an array of strings so that you can dynamically generate the paths by talking to your CMS, etc.
2139
2140 ```ts
2141 // react-router.config.ts
2142 import type { Config } from "@react-router/dev/config";
2143
2144 export default {
2145 async prerender() {
2146 let slugs = await fakeGetSlugsFromCms();
2147 // Prerender these paths into `.html` files at build time, and `.data`
2148 // files if they have loaders
2149 return ["/", "/about", ...slugs.map((slug) => `/product/${slug}`)];
2150 },
2151 } satisfies Config;
2152
2153 async function fakeGetSlugsFromCms() {
2154 await new Promise((r) => setTimeout(r, 1000));
2155 return ["shirt", "hat"];
2156 }
2157 ```
2158
2159- Params, loader data, and action data as props for route component exports ([#11961](https://github.com/remix-run/react-router/pull/11961))
2160
2161 ```tsx
2162 export default function Component({ params, loaderData, actionData }) {}
2163
2164 export function HydrateFallback({ params }) {}
2165 export function ErrorBoundary({ params, loaderData, actionData }) {}
2166 ```
2167
2168- Remove duplicate `RouterProvider` impliementations ([#11679](https://github.com/remix-run/react-router/pull/11679))
2169
2170- ### Typesafety improvements ([#12019](https://github.com/remix-run/react-router/pull/12019))
2171
2172 React Router now generates types for each of your route modules.
2173 You can access those types by importing them from `./+types.<route filename without extension>`.
2174 For example:
2175
2176 ```ts
2177 // app/routes/product.tsx
2178 import type * as Route from "./+types.product";
2179
2180 export function loader({ params }: Route.LoaderArgs) {}
2181
2182 export default function Component({ loaderData }: Route.ComponentProps) {}
2183 ```
2184
2185 This initial implementation targets type inference for:
2186 - `Params` : Path parameters from your routing config in `routes.ts` including file-based routing
2187 - `LoaderData` : Loader data from `loader` and/or `clientLoader` within your route module
2188 - `ActionData` : Action data from `action` and/or `clientAction` within your route module
2189
2190 In the future, we plan to add types for the rest of the route module exports: `meta`, `links`, `headers`, `shouldRevalidate`, etc.
2191 We also plan to generate types for typesafe `Link`s:
2192
2193 ```tsx
2194 <Link to="/products/:id" params={{ id: 1 }} />
2195 // ^^^^^^^^^^^^^ ^^^^^^^^^
2196 // typesafe `to` and `params` based on the available routes in your app
2197 ```
2198
2199 Check out our docs for more:
2200 - [_Explanations > Type Safety_](https://reactrouter.com/dev/guides/explanation/type-safety)
2201 - [_How-To > Setting up type safety_](https://reactrouter.com/dev/guides/how-to/setting-up-type-safety)
2202
2203- Stabilize `unstable_dataStrategy` ([#11969](https://github.com/remix-run/react-router/pull/11969))
2204
2205- Stabilize `unstable_patchRoutesOnNavigation` ([#11970](https://github.com/remix-run/react-router/pull/11970))
2206
2207### Patch Changes
2208
2209- No changes ([`506329c4e`](https://github.com/remix-run/react-router/commit/506329c4e2e7aba9837cbfa44df6103b49423745))
2210
2211- chore: re-enable development warnings through a `development` exports condition. ([#12269](https://github.com/remix-run/react-router/pull/12269))
2212
2213- Remove unstable upload handler. ([#12015](https://github.com/remix-run/react-router/pull/12015))
2214
2215- Remove unneeded dependency on @web3-storage/multipart-parser ([#12274](https://github.com/remix-run/react-router/pull/12274))
2216
2217- Fix redirects returned from loaders/actions using `data()` ([#12021](https://github.com/remix-run/react-router/pull/12021))
2218
2219- fix(react-router): (v7) fix static prerender of non-ascii characters ([#12161](https://github.com/remix-run/react-router/pull/12161))
2220
2221- Replace `substr` with `substring` ([#12080](https://github.com/remix-run/react-router/pull/12080))
2222
2223- Remove the deprecated `json` utility ([#12146](https://github.com/remix-run/react-router/pull/12146))
2224 - You can use [`Response.json`](https://developer.mozilla.org/en-US/docs/Web/API/Response/json_static) if you still need to construct JSON responses in your app
2225
2226- Remove unneeded dependency on source-map ([#12275](https://github.com/remix-run/react-router/pull/12275))
2227
2228## 6.28.0
2229
2230### Minor Changes
2231
2232- - Log deprecation warnings for v7 flags ([#11750](https://github.com/remix-run/react-router/pull/11750))
2233 - Add deprecation warnings to `json`/`defer` in favor of returning raw objects
2234 - These methods will be removed in React Router v7
2235
2236### Patch Changes
2237
2238- Update JSDoc URLs for new website structure (add /v6/ segment) ([#12141](https://github.com/remix-run/react-router/pull/12141))
2239- Updated dependencies:
2240 - `@remix-run/router@1.21.0`
2241
2242## 6.27.0
2243
2244### Minor Changes
2245
2246- Stabilize `unstable_patchRoutesOnNavigation` ([#11973](https://github.com/remix-run/react-router/pull/11973))
2247 - Add new `PatchRoutesOnNavigationFunctionArgs` type for convenience ([#11967](https://github.com/remix-run/react-router/pull/11967))
2248- Stabilize `unstable_dataStrategy` ([#11974](https://github.com/remix-run/react-router/pull/11974))
2249- Stabilize the `unstable_flushSync` option for navigations and fetchers ([#11989](https://github.com/remix-run/react-router/pull/11989))
2250- Stabilize the `unstable_viewTransition` option for navigations and the corresponding `unstable_useViewTransitionState` hook ([#11989](https://github.com/remix-run/react-router/pull/11989))
2251
2252### Patch Changes
2253
2254- Fix bug when submitting to the current contextual route (parent route with an index child) when an `?index` param already exists from a prior submission ([#12003](https://github.com/remix-run/react-router/pull/12003))
2255
2256- Fix `useFormAction` bug - when removing `?index` param it would not keep other non-Remix `index` params ([#12003](https://github.com/remix-run/react-router/pull/12003))
2257
2258- Fix types for `RouteObject` within `PatchRoutesOnNavigationFunction`'s `patch` method so it doesn't expect agnostic route objects passed to `patch` ([#11967](https://github.com/remix-run/react-router/pull/11967))
2259
2260- Updated dependencies:
2261 - `@remix-run/router@1.20.0`
2262
2263## 6.26.2
2264
2265### Patch Changes
2266
2267- Updated dependencies:
2268 - `@remix-run/router@1.19.2`
2269
2270## 6.26.1
2271
2272### Patch Changes
2273
2274- Rename `unstable_patchRoutesOnMiss` to `unstable_patchRoutesOnNavigation` to match new behavior ([#11888](https://github.com/remix-run/react-router/pull/11888))
2275- Updated dependencies:
2276 - `@remix-run/router@1.19.1`
2277
2278## 6.26.0
2279
2280### Minor Changes
2281
2282- Add a new `replace(url, init?)` alternative to `redirect(url, init?)` that performs a `history.replaceState` instead of a `history.pushState` on client-side navigation redirects ([#11811](https://github.com/remix-run/react-router/pull/11811))
2283
2284### Patch Changes
2285
2286- Fix initial hydration behavior when using `future.v7_partialHydration` along with `unstable_patchRoutesOnMiss` ([#11838](https://github.com/remix-run/react-router/pull/11838))
2287 - During initial hydration, `router.state.matches` will now include any partial matches so that we can render ancestor `HydrateFallback` components
2288- Updated dependencies:
2289 - `@remix-run/router@1.19.0`
2290
2291## 6.25.1
2292
2293No significant changes to this package were made in this release. [See the repo `CHANGELOG.md`](https://github.com/remix-run/react-router/blob/main/CHANGELOG.md) for an overview of all changes in v6.25.1.
2294
2295## 6.25.0
2296
2297### Minor Changes
2298
2299- Stabilize `future.unstable_skipActionErrorRevalidation` as `future.v7_skipActionErrorRevalidation` ([#11769](https://github.com/remix-run/react-router/pull/11769))
2300 - When this flag is enabled, actions will not automatically trigger a revalidation if they return/throw a `Response` with a `4xx`/`5xx` status code
2301 - You may still opt-into revalidation via `shouldRevalidate`
2302 - This also changes `shouldRevalidate`'s `unstable_actionStatus` parameter to `actionStatus`
2303
2304### Patch Changes
2305
2306- Fix regression and properly decode paths inside `useMatch` so matches/params reflect decoded params ([#11789](https://github.com/remix-run/react-router/pull/11789))
2307- Updated dependencies:
2308 - `@remix-run/router@1.18.0`
2309
2310## 6.24.1
2311
2312### Patch Changes
2313
2314- When using `future.v7_relativeSplatPath`, properly resolve relative paths in splat routes that are children of pathless routes ([#11633](https://github.com/remix-run/react-router/pull/11633))
2315- Updated dependencies:
2316 - `@remix-run/router@1.17.1`
2317
2318## 6.24.0
2319
2320### Minor Changes
2321
2322- Add support for Lazy Route Discovery (a.k.a. Fog of War) ([#11626](https://github.com/remix-run/react-router/pull/11626))
2323 - RFC: <https://github.com/remix-run/react-router/discussions/11113>
2324 - `unstable_patchRoutesOnMiss` docs: <https://reactrouter.com/v6/routers/create-browser-router>
2325
2326### Patch Changes
2327
2328- Updated dependencies:
2329 - `@remix-run/router@1.17.0`
2330
2331## 6.23.1
2332
2333### Patch Changes
2334
2335- allow undefined to be resolved with `<Await>` ([#11513](https://github.com/remix-run/react-router/pull/11513))
2336- Updated dependencies:
2337 - `@remix-run/router@1.16.1`
2338
2339## 6.23.0
2340
2341### Minor Changes
2342
2343- Add a new `unstable_dataStrategy` configuration option ([#11098](https://github.com/remix-run/react-router/pull/11098))
2344 - This option allows Data Router applications to take control over the approach for executing route loaders and actions
2345 - The default implementation is today's behavior, to fetch all loaders in parallel, but this option allows users to implement more advanced data flows including Remix single-fetch, middleware/context APIs, automatic loader caching, and more
2346
2347### Patch Changes
2348
2349- Updated dependencies:
2350 - `@remix-run/router@1.16.0`
2351
2352## 6.22.3
2353
2354### Patch Changes
2355
2356- Updated dependencies:
2357 - `@remix-run/router@1.15.3`
2358
2359## 6.22.2
2360
2361### Patch Changes
2362
2363- Updated dependencies:
2364 - `@remix-run/router@1.15.2`
2365
2366## 6.22.1
2367
2368### Patch Changes
2369
2370- Fix encoding/decoding issues with pre-encoded dynamic parameter values ([#11199](https://github.com/remix-run/react-router/pull/11199))
2371- Updated dependencies:
2372 - `@remix-run/router@1.15.1`
2373
2374## 6.22.0
2375
2376### Patch Changes
2377
2378- Updated dependencies:
2379 - `@remix-run/router@1.15.0`
2380
2381## 6.21.3
2382
2383### Patch Changes
2384
2385- Remove leftover `unstable_` prefix from `Blocker`/`BlockerFunction` types ([#11187](https://github.com/remix-run/react-router/pull/11187))
2386
2387## 6.21.2
2388
2389### Patch Changes
2390
2391- Updated dependencies:
2392 - `@remix-run/router@1.14.2`
2393
2394## 6.21.1
2395
2396### Patch Changes
2397
2398- Fix bug with `route.lazy` not working correctly on initial SPA load when `v7_partialHydration` is specified ([#11121](https://github.com/remix-run/react-router/pull/11121))
2399- Updated dependencies:
2400 - `@remix-run/router@1.14.1`
2401
2402## 6.21.0
2403
2404### Minor Changes
2405
2406- Add a new `future.v7_relativeSplatPath` flag to implement a breaking bug fix to relative routing when inside a splat route. ([#11087](https://github.com/remix-run/react-router/pull/11087))
2407
2408 This fix was originally added in [#10983](https://github.com/remix-run/react-router/issues/10983) and was later reverted in [#11078](https://github.com/remix-run/react-router/pull/11078) because it was determined that a large number of existing applications were relying on the buggy behavior (see [#11052](https://github.com/remix-run/react-router/issues/11052))
2409
2410 **The Bug**
2411 The buggy behavior is that without this flag, the default behavior when resolving relative paths is to _ignore_ any splat (`*`) portion of the current route path.
2412
2413 **The Background**
2414 This decision was originally made thinking that it would make the concept of nested different sections of your apps in `<Routes>` easier if relative routing would _replace_ the current splat:
2415
2416 ```jsx
2417 <BrowserRouter>
2418 <Routes>
2419 <Route path="/" element={<Home />} />
2420 <Route path="dashboard/*" element={<Dashboard />} />
2421 </Routes>
2422 </BrowserRouter>
2423 ```
2424
2425 Any paths like `/dashboard`, `/dashboard/team`, `/dashboard/projects` will match the `Dashboard` route. The dashboard component itself can then render nested `<Routes>`:
2426
2427 ```jsx
2428 function Dashboard() {
2429 return (
2430 <div>
2431 <h2>Dashboard</h2>
2432 <nav>
2433 <Link to="/">Dashboard Home</Link>
2434 <Link to="team">Team</Link>
2435 <Link to="projects">Projects</Link>
2436 </nav>
2437
2438 <Routes>
2439 <Route path="/" element={<DashboardHome />} />
2440 <Route path="team" element={<DashboardTeam />} />
2441 <Route path="projects" element={<DashboardProjects />} />
2442 </Routes>
2443 </div>
2444 );
2445 }
2446 ```
2447
2448 Now, all links and route paths are relative to the router above them. This makes code splitting and compartmentalizing your app really easy. You could render the `Dashboard` as its own independent app, or embed it into your large app without making any changes to it.
2449
2450 **The Problem**
2451
2452 The problem is that this concept of ignoring part of a path breaks a lot of other assumptions in React Router - namely that `"."` always means the current location pathname for that route. When we ignore the splat portion, we start getting invalid paths when using `"."`:
2453
2454 ```jsx
2455 // If we are on URL /dashboard/team, and we want to link to /dashboard/team:
2456 function DashboardTeam() {
2457 // ❌ This is broken and results in <a href="/dashboard">
2458 return <Link to=".">A broken link to the Current URL</Link>;
2459
2460 // ✅ This is fixed but super unintuitive since we're already at /dashboard/team!
2461 return <Link to="./team">A broken link to the Current URL</Link>;
2462 }
2463 ```
2464
2465 We've also introduced an issue that we can no longer move our `DashboardTeam` component around our route hierarchy easily - since it behaves differently if we're underneath a non-splat route, such as `/dashboard/:widget`. Now, our `"."` links will, properly point to ourself _inclusive of the dynamic param value_ so behavior will break from it's corresponding usage in a `/dashboard/*` route.
2466
2467 Even worse, consider a nested splat route configuration:
2468
2469 ```jsx
2470 <BrowserRouter>
2471 <Routes>
2472 <Route path="dashboard">
2473 <Route path="*" element={<Dashboard />} />
2474 </Route>
2475 </Routes>
2476 </BrowserRouter>
2477 ```
2478
2479 Now, a `<Link to=".">` and a `<Link to="..">` inside the `Dashboard` component go to the same place! That is definitely not correct!
2480
2481 Another common issue arose in Data Routers (and Remix) where any `<Form>` should post to it's own route `action` if you the user doesn't specify a form action:
2482
2483 ```jsx
2484 let router = createBrowserRouter({
2485 path: "/dashboard",
2486 children: [
2487 {
2488 path: "*",
2489 action: dashboardAction,
2490 Component() {
2491 // ❌ This form is broken! It throws a 405 error when it submits because
2492 // it tries to submit to /dashboard (without the splat value) and the parent
2493 // `/dashboard` route doesn't have an action
2494 return <Form method="post">...</Form>;
2495 },
2496 },
2497 ],
2498 });
2499 ```
2500
2501 This is just a compounded issue from the above because the default location for a `Form` to submit to is itself (`"."`) - and if we ignore the splat portion, that now resolves to the parent route.
2502
2503 **The Solution**
2504 If you are leveraging this behavior, it's recommended to enable the future flag, move your splat to it's own route, and leverage `../` for any links to "sibling" pages:
2505
2506 ```jsx
2507 <BrowserRouter>
2508 <Routes>
2509 <Route path="dashboard">
2510 <Route index path="*" element={<Dashboard />} />
2511 </Route>
2512 </Routes>
2513 </BrowserRouter>
2514
2515 function Dashboard() {
2516 return (
2517 <div>
2518 <h2>Dashboard</h2>
2519 <nav>
2520 <Link to="..">Dashboard Home</Link>
2521 <Link to="../team">Team</Link>
2522 <Link to="../projects">Projects</Link>
2523 </nav>
2524
2525 <Routes>
2526 <Route path="/" element={<DashboardHome />} />
2527 <Route path="team" element={<DashboardTeam />} />
2528 <Route path="projects" element={<DashboardProjects />} />
2529 </Router>
2530 </div>
2531 );
2532 }
2533 ```
2534
2535 This way, `.` means "the full current pathname for my route" in all cases (including static, dynamic, and splat routes) and `..` always means "my parents pathname".
2536
2537### Patch Changes
2538
2539- Properly handle falsy error values in ErrorBoundary's ([#11071](https://github.com/remix-run/react-router/pull/11071))
2540- Updated dependencies:
2541 - `@remix-run/router@1.14.0`
2542
2543## 6.20.1
2544
2545### Patch Changes
2546
2547- Revert the `useResolvedPath` fix for splat routes due to a large number of applications that were relying on the buggy behavior (see <https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329>). We plan to re-introduce this fix behind a future flag in the next minor version. ([#11078](https://github.com/remix-run/react-router/pull/11078))
2548- Updated dependencies:
2549 - `@remix-run/router@1.13.1`
2550
2551## 6.20.0
2552
2553### Minor Changes
2554
2555- Export the `PathParam` type from the public API ([#10719](https://github.com/remix-run/react-router/pull/10719))
2556
2557### Patch Changes
2558
2559- Fix bug with `resolveTo` in splat routes ([#11045](https://github.com/remix-run/react-router/pull/11045))
2560 - This is a follow up to [#10983](https://github.com/remix-run/react-router/pull/10983) to handle the few other code paths using `getPathContributingMatches`
2561 - This removes the `UNSAFE_getPathContributingMatches` export from `@remix-run/router` since we no longer need this in the `react-router`/`react-router-dom` layers
2562- Updated dependencies:
2563 - `@remix-run/router@1.13.0`
2564
2565## 6.19.0
2566
2567### Minor Changes
2568
2569- Add `unstable_flushSync` option to `useNavigate`/`useSumbit`/`fetcher.load`/`fetcher.submit` to opt-out of `React.startTransition` and into `ReactDOM.flushSync` for state updates ([#11005](https://github.com/remix-run/react-router/pull/11005))
2570- Remove the `unstable_` prefix from the [`useBlocker`](https://reactrouter.com/v6/hooks/use-blocker) hook as it's been in use for enough time that we are confident in the API. We do not plan to remove the prefix from `unstable_usePrompt` due to differences in how browsers handle `window.confirm` that prevent React Router from guaranteeing consistent/correct behavior. ([#10991](https://github.com/remix-run/react-router/pull/10991))
2571
2572### Patch Changes
2573
2574- Fix `useActionData` so it returns proper contextual action data and not _any_ action data in the tree ([#11023](https://github.com/remix-run/react-router/pull/11023))
2575
2576- Fix bug in `useResolvedPath` that would cause `useResolvedPath(".")` in a splat route to lose the splat portion of the URL path. ([#10983](https://github.com/remix-run/react-router/pull/10983))
2577 - ⚠️ This fixes a quite long-standing bug specifically for `"."` paths inside a splat route which incorrectly dropped the splat portion of the URL. If you are relative routing via `"."` inside a splat route in your application you should double check that your logic is not relying on this buggy behavior and update accordingly.
2578
2579- Updated dependencies:
2580 - `@remix-run/router@1.12.0`
2581
2582## 6.18.0
2583
2584### Patch Changes
2585
2586- Fix the `future` prop on `BrowserRouter`, `HashRouter` and `MemoryRouter` so that it accepts a `Partial<FutureConfig>` instead of requiring all flags to be included. ([#10962](https://github.com/remix-run/react-router/pull/10962))
2587- Updated dependencies:
2588 - `@remix-run/router@1.11.0`
2589
2590## 6.17.0
2591
2592### Patch Changes
2593
2594- Fix `RouterProvider` `future` prop type to be a `Partial<FutureConfig>` so that not all flags must be specified ([#10900](https://github.com/remix-run/react-router/pull/10900))
2595- Updated dependencies:
2596 - `@remix-run/router@1.10.0`
2597
2598## 6.16.0
2599
2600### Minor Changes
2601
2602- In order to move towards stricter TypeScript support in the future, we're aiming to replace current usages of `any` with `unknown` on exposed typings for user-provided data. To do this in Remix v2 without introducing breaking changes in React Router v6, we have added generics to a number of shared types. These continue to default to `any` in React Router and are overridden with `unknown` in Remix. In React Router v7 we plan to move these to `unknown` as a breaking change. ([#10843](https://github.com/remix-run/react-router/pull/10843))
2603 - `Location` now accepts a generic for the `location.state` value
2604 - `ActionFunctionArgs`/`ActionFunction`/`LoaderFunctionArgs`/`LoaderFunction` now accept a generic for the `context` parameter (only used in SSR usages via `createStaticHandler`)
2605 - The return type of `useMatches` (now exported as `UIMatch`) accepts generics for `match.data` and `match.handle` - both of which were already set to `unknown`
2606- Move the `@private` class export `ErrorResponse` to an `UNSAFE_ErrorResponseImpl` export since it is an implementation detail and there should be no construction of `ErrorResponse` instances in userland. This frees us up to export a `type ErrorResponse` which correlates to an instance of the class via `InstanceType`. Userland code should only ever be using `ErrorResponse` as a type and should be type-narrowing via `isRouteErrorResponse`. ([#10811](https://github.com/remix-run/react-router/pull/10811))
2607- Export `ShouldRevalidateFunctionArgs` interface ([#10797](https://github.com/remix-run/react-router/pull/10797))
2608- Removed private/internal APIs only required for the Remix v1 backwards compatibility layer and no longer needed in Remix v2 (`_isFetchActionRedirect`, `_hasFetcherDoneAnything`) ([#10715](https://github.com/remix-run/react-router/pull/10715))
2609
2610### Patch Changes
2611
2612- Updated dependencies:
2613 - `@remix-run/router@1.9.0`
2614
2615## 6.15.0
2616
2617### Minor Changes
2618
2619- Add's a new `redirectDocument()` function which allows users to specify that a redirect from a `loader`/`action` should trigger a document reload (via `window.location`) instead of attempting to navigate to the redirected location via React Router ([#10705](https://github.com/remix-run/react-router/pull/10705))
2620
2621### Patch Changes
2622
2623- Ensure `useRevalidator` is referentially stable across re-renders if revalidations are not actively occurring ([#10707](https://github.com/remix-run/react-router/pull/10707))
2624- Updated dependencies:
2625 - `@remix-run/router@1.8.0`
2626
2627## 6.14.2
2628
2629### Patch Changes
2630
2631- Updated dependencies:
2632 - `@remix-run/router@1.7.2`
2633
2634## 6.14.1
2635
2636### Patch Changes
2637
2638- Fix loop in `unstable_useBlocker` when used with an unstable blocker function ([#10652](https://github.com/remix-run/react-router/pull/10652))
2639- Fix issues with reused blockers on subsequent navigations ([#10656](https://github.com/remix-run/react-router/pull/10656))
2640- Updated dependencies:
2641 - `@remix-run/router@1.7.1`
2642
2643## 6.14.0
2644
2645### Patch Changes
2646
2647- Strip `basename` from locations provided to `unstable_useBlocker` functions to match `useLocation` ([#10573](https://github.com/remix-run/react-router/pull/10573))
2648- Fix `generatePath` when passed a numeric `0` value parameter ([#10612](https://github.com/remix-run/react-router/pull/10612))
2649- Fix `unstable_useBlocker` key issues in `StrictMode` ([#10573](https://github.com/remix-run/react-router/pull/10573))
2650- Fix `tsc --skipLibCheck:false` issues on React 17 ([#10622](https://github.com/remix-run/react-router/pull/10622))
2651- Upgrade `typescript` to 5.1 ([#10581](https://github.com/remix-run/react-router/pull/10581))
2652- Updated dependencies:
2653 - `@remix-run/router@1.7.0`
2654
2655## 6.13.0
2656
2657### Minor Changes
2658
2659- Move [`React.startTransition`](https://react.dev/reference/react/startTransition) usage behind a [future flag](https://reactrouter.com/v6/guides/api-development-strategy) to avoid issues with existing incompatible `Suspense` usages. We recommend folks adopting this flag to be better compatible with React concurrent mode, but if you run into issues you can continue without the use of `startTransition` until v7. Issues usually boils down to creating net-new promises during the render cycle, so if you run into issues you should either lift your promise creation out of the render cycle or put it behind a `useMemo`. ([#10596](https://github.com/remix-run/react-router/pull/10596))
2660
2661 Existing behavior will no longer include `React.startTransition`:
2662
2663 ```jsx
2664 <BrowserRouter>
2665 <Routes>{/*...*/}</Routes>
2666 </BrowserRouter>
2667
2668 <RouterProvider router={router} />
2669 ```
2670
2671 If you wish to enable `React.startTransition`, pass the future flag to your component:
2672
2673 ```jsx
2674 <BrowserRouter future={{ v7_startTransition: true }}>
2675 <Routes>{/*...*/}</Routes>
2676 </BrowserRouter>
2677
2678 <RouterProvider router={router} future={{ v7_startTransition: true }}/>
2679 ```
2680
2681### Patch Changes
2682
2683- Work around webpack/terser `React.startTransition` minification bug in production mode ([#10588](https://github.com/remix-run/react-router/pull/10588))
2684
2685## 6.12.1
2686
2687> \[!WARNING]
2688> Please use version `6.13.0` or later instead of `6.12.1`. This version suffers from a `webpack`/`terser` minification issue resulting in invalid minified code in your resulting production bundles which can cause issues in your application. See [#10579](https://github.com/remix-run/react-router/issues/10579) for more details.
2689
2690### Patch Changes
2691
2692- Adjust feature detection of `React.startTransition` to fix webpack + react 17 compilation error ([#10569](https://github.com/remix-run/react-router/pull/10569))
2693
2694## 6.12.0
2695
2696### Minor Changes
2697
2698- Wrap internal router state updates with `React.startTransition` if it exists ([#10438](https://github.com/remix-run/react-router/pull/10438))
2699
2700### Patch Changes
2701
2702- Updated dependencies:
2703 - `@remix-run/router@1.6.3`
2704
2705## 6.11.2
2706
2707### Patch Changes
2708
2709- Fix `basename` duplication in descendant `<Routes>` inside a `<RouterProvider>` ([#10492](https://github.com/remix-run/react-router/pull/10492))
2710- Updated dependencies:
2711 - `@remix-run/router@1.6.2`
2712
2713## 6.11.1
2714
2715### Patch Changes
2716
2717- Fix usage of `Component` API within descendant `<Routes>` ([#10434](https://github.com/remix-run/react-router/pull/10434))
2718- Fix bug when calling `useNavigate` from `<Routes>` inside a `<RouterProvider>` ([#10432](https://github.com/remix-run/react-router/pull/10432))
2719- Fix usage of `<Navigate>` in strict mode when using a data router ([#10435](https://github.com/remix-run/react-router/pull/10435))
2720- Updated dependencies:
2721 - `@remix-run/router@1.6.1`
2722
2723## 6.11.0
2724
2725### Patch Changes
2726
2727- Log loader/action errors to the console in dev for easier stack trace evaluation ([#10286](https://github.com/remix-run/react-router/pull/10286))
2728- Fix bug preventing rendering of descendant `<Routes>` when `RouterProvider` errors existed ([#10374](https://github.com/remix-run/react-router/pull/10374))
2729- Fix inadvertent re-renders when using `Component` instead of `element` on a route definition ([#10287](https://github.com/remix-run/react-router/pull/10287))
2730- Fix detection of `useNavigate` in the render cycle by setting the `activeRef` in a layout effect, allowing the `navigate` function to be passed to child components and called in a `useEffect` there. ([#10394](https://github.com/remix-run/react-router/pull/10394))
2731- Switched from `useSyncExternalStore` to `useState` for internal `@remix-run/router` router state syncing in `<RouterProvider>`. We found some [subtle bugs](https://codesandbox.io/s/use-sync-external-store-loop-9g7b81) where router state updates got propagated _before_ other normal `useState` updates, which could lead to footguns in `useEffect` calls. ([#10377](https://github.com/remix-run/react-router/pull/10377), [#10409](https://github.com/remix-run/react-router/pull/10409))
2732- Allow `useRevalidator()` to resolve a loader-driven error boundary scenario ([#10369](https://github.com/remix-run/react-router/pull/10369))
2733- Avoid unnecessary unsubscribe/resubscribes on router state changes ([#10409](https://github.com/remix-run/react-router/pull/10409))
2734- When using a `RouterProvider`, `useNavigate`/`useSubmit`/`fetcher.submit` are now stable across location changes, since we can handle relative routing via the `@remix-run/router` instance and get rid of our dependence on `useLocation()`. When using `BrowserRouter`, these hooks remain unstable across location changes because they still rely on `useLocation()`. ([#10336](https://github.com/remix-run/react-router/pull/10336))
2735- Updated dependencies:
2736 - `@remix-run/router@1.6.0`
2737
2738## 6.10.0
2739
2740### Minor Changes
2741
2742- Added support for [**Future Flags**](https://reactrouter.com/v6/guides/api-development-strategy) in React Router. The first flag being introduced is `future.v7_normalizeFormMethod` which will normalize the exposed `useNavigation()/useFetcher()` `formMethod` fields as uppercase HTTP methods to align with the `fetch()` behavior. ([#10207](https://github.com/remix-run/react-router/pull/10207))
2743 - When `future.v7_normalizeFormMethod === false` (default v6 behavior),
2744 - `useNavigation().formMethod` is lowercase
2745 - `useFetcher().formMethod` is lowercase
2746 - When `future.v7_normalizeFormMethod === true`:
2747 - `useNavigation().formMethod` is uppercase
2748 - `useFetcher().formMethod` is uppercase
2749
2750### Patch Changes
2751
2752- Fix route ID generation when using Fragments in `createRoutesFromElements` ([#10193](https://github.com/remix-run/react-router/pull/10193))
2753- Updated dependencies:
2754 - `@remix-run/router@1.5.0`
2755
2756## 6.9.0
2757
2758### Minor Changes
2759
2760- React Router now supports an alternative way to define your route `element` and `errorElement` fields as React Components instead of React Elements. You can instead pass a React Component to the new `Component` and `ErrorBoundary` fields if you choose. There is no functional difference between the two, so use whichever approach you prefer 😀. You shouldn't be defining both, but if you do `Component`/`ErrorBoundary` will "win". ([#10045](https://github.com/remix-run/react-router/pull/10045))
2761
2762 **Example JSON Syntax**
2763
2764 ```jsx
2765 // Both of these work the same:
2766 const elementRoutes = [{
2767 path: '/',
2768 element: <Home />,
2769 errorElement: <HomeError />,
2770 }]
2771
2772 const componentRoutes = [{
2773 path: '/',
2774 Component: Home,
2775 ErrorBoundary: HomeError,
2776 }]
2777
2778 function Home() { ... }
2779 function HomeError() { ... }
2780 ```
2781
2782 **Example JSX Syntax**
2783
2784 ```jsx
2785 // Both of these work the same:
2786 const elementRoutes = createRoutesFromElements(
2787 <Route path='/' element={<Home />} errorElement={<HomeError /> } />
2788 );
2789
2790 const componentRoutes = createRoutesFromElements(
2791 <Route path='/' Component={Home} ErrorBoundary={HomeError} />
2792 );
2793
2794 function Home() { ... }
2795 function HomeError() { ... }
2796 ```
2797
2798- **Introducing Lazy Route Modules!** ([#10045](https://github.com/remix-run/react-router/pull/10045))
2799
2800 In order to keep your application bundles small and support code-splitting of your routes, we've introduced a new `lazy()` route property. This is an async function that resolves the non-route-matching portions of your route definition (`loader`, `action`, `element`/`Component`, `errorElement`/`ErrorBoundary`, `shouldRevalidate`, `handle`).
2801
2802 Lazy routes are resolved on initial load and during the `loading` or `submitting` phase of a navigation or fetcher call. You cannot lazily define route-matching properties (`path`, `index`, `children`) since we only execute your lazy route functions after we've matched known routes.
2803
2804 Your `lazy` functions will typically return the result of a dynamic import.
2805
2806 ```jsx
2807 // In this example, we assume most folks land on the homepage so we include that
2808 // in our critical-path bundle, but then we lazily load modules for /a and /b so
2809 // they don't load until the user navigates to those routes
2810 let routes = createRoutesFromElements(
2811 <Route path="/" element={<Layout />}>
2812 <Route index element={<Home />} />
2813 <Route path="a" lazy={() => import("./a")} />
2814 <Route path="b" lazy={() => import("./b")} />
2815 </Route>,
2816 );
2817 ```
2818
2819 Then in your lazy route modules, export the properties you want defined for the route:
2820
2821 ```jsx
2822 export async function loader({ request }) {
2823 let data = await fetchData(request);
2824 return json(data);
2825 }
2826
2827 // Export a `Component` directly instead of needing to create a React Element from it
2828 export function Component() {
2829 let data = useLoaderData();
2830
2831 return (
2832 <>
2833 <h1>You made it!</h1>
2834 <p>{data}</p>
2835 </>
2836 );
2837 }
2838
2839 // Export an `ErrorBoundary` directly instead of needing to create a React Element from it
2840 export function ErrorBoundary() {
2841 let error = useRouteError();
2842 return isRouteErrorResponse(error) ? (
2843 <h1>
2844 {error.status} {error.statusText}
2845 </h1>
2846 ) : (
2847 <h1>{error.message || error}</h1>
2848 );
2849 }
2850 ```
2851
2852 An example of this in action can be found in the [`examples/lazy-loading-router-provider`](https://github.com/remix-run/react-router/tree/main/examples/lazy-loading-router-provider) directory of the repository.
2853
2854 🙌 Huge thanks to @rossipedia for the [Initial Proposal](https://github.com/remix-run/react-router/discussions/9826) and [POC Implementation](https://github.com/remix-run/react-router/pull/9830).
2855
2856- Updated dependencies:
2857 - `@remix-run/router@1.4.0`
2858
2859### Patch Changes
2860
2861- Fix `generatePath` incorrectly applying parameters in some cases ([#10078](https://github.com/remix-run/react-router/pull/10078))
2862- Improve memoization for context providers to avoid unnecessary re-renders ([#9983](https://github.com/remix-run/react-router/pull/9983))
2863
2864## 6.8.2
2865
2866### Patch Changes
2867
2868- Updated dependencies:
2869 - `@remix-run/router@1.3.3`
2870
2871## 6.8.1
2872
2873### Patch Changes
2874
2875- Remove inaccurate console warning for POP navigations and update active blocker logic ([#10030](https://github.com/remix-run/react-router/pull/10030))
2876- Updated dependencies:
2877 - `@remix-run/router@1.3.2`
2878
2879## 6.8.0
2880
2881### Patch Changes
2882
2883- Updated dependencies:
2884 - `@remix-run/router@1.3.1`
2885
2886## 6.7.0
2887
2888### Minor Changes
2889
2890- Add `unstable_useBlocker` hook for blocking navigations within the app's location origin ([#9709](https://github.com/remix-run/react-router/pull/9709))
2891
2892### Patch Changes
2893
2894- Fix `generatePath` when optional params are present ([#9764](https://github.com/remix-run/react-router/pull/9764))
2895- Update `<Await>` to accept `ReactNode` as children function return result ([#9896](https://github.com/remix-run/react-router/pull/9896))
2896- Updated dependencies:
2897 - `@remix-run/router@1.3.0`
2898
2899## 6.6.2
2900
2901### Patch Changes
2902
2903- Ensure `useId` consistency during SSR ([#9805](https://github.com/remix-run/react-router/pull/9805))
2904
2905## 6.6.1
2906
2907### Patch Changes
2908
2909- Updated dependencies:
2910 - `@remix-run/router@1.2.1`
2911
2912## 6.6.0
2913
2914### Patch Changes
2915
2916- Prevent `useLoaderData` usage in `errorElement` ([#9735](https://github.com/remix-run/react-router/pull/9735))
2917- Updated dependencies:
2918 - `@remix-run/router@1.2.0`
2919
2920## 6.5.0
2921
2922This release introduces support for [Optional Route Segments](https://github.com/remix-run/react-router/issues/9546). Now, adding a `?` to the end of any path segment will make that entire segment optional. This works for both static segments and dynamic parameters.
2923
2924**Optional Params Examples**
2925
2926- `<Route path=":lang?/about>` will match:
2927 - `/:lang/about`
2928 - `/about`
2929- `<Route path="/multistep/:widget1?/widget2?/widget3?">` will match:
2930 - `/multistep`
2931 - `/multistep/:widget1`
2932 - `/multistep/:widget1/:widget2`
2933 - `/multistep/:widget1/:widget2/:widget3`
2934
2935**Optional Static Segment Example**
2936
2937- `<Route path="/home?">` will match:
2938 - `/`
2939 - `/home`
2940- `<Route path="/fr?/about">` will match:
2941 - `/about`
2942 - `/fr/about`
2943
2944### Minor Changes
2945
2946- Allows optional routes and optional static segments ([#9650](https://github.com/remix-run/react-router/pull/9650))
2947
2948### Patch Changes
2949
2950- Stop incorrectly matching on partial named parameters, i.e. `<Route path="prefix-:param">`, to align with how splat parameters work. If you were previously relying on this behavior then it's recommended to extract the static portion of the path at the `useParams` call site: ([#9506](https://github.com/remix-run/react-router/pull/9506))
2951
2952```jsx
2953// Old behavior at URL /prefix-123
2954<Route path="prefix-:id" element={<Comp /> }>
2955
2956function Comp() {
2957 let params = useParams(); // { id: '123' }
2958 let id = params.id; // "123"
2959 ...
2960}
2961
2962// New behavior at URL /prefix-123
2963<Route path=":id" element={<Comp /> }>
2964
2965function Comp() {
2966 let params = useParams(); // { id: 'prefix-123' }
2967 let id = params.id.replace(/^prefix-/, ''); // "123"
2968 ...
2969}
2970```
2971
2972- Updated dependencies:
2973 - `@remix-run/router@1.1.0`
2974
2975## 6.4.5
2976
2977### Patch Changes
2978
2979- Updated dependencies:
2980 - `@remix-run/router@1.0.5`
2981
2982## 6.4.4
2983
2984### Patch Changes
2985
2986- Updated dependencies:
2987 - `@remix-run/router@1.0.4`
2988
2989## 6.4.3
2990
2991### Patch Changes
2992
2993- `useRoutes` should be able to return `null` when passing `locationArg` ([#9485](https://github.com/remix-run/react-router/pull/9485))
2994- fix `initialEntries` type in `createMemoryRouter` ([#9498](https://github.com/remix-run/react-router/pull/9498))
2995- Updated dependencies:
2996 - `@remix-run/router@1.0.3`
2997
2998## 6.4.2
2999
3000### Patch Changes
3001
3002- Fix `IndexRouteObject` and `NonIndexRouteObject` types to make `hasErrorElement` optional ([#9394](https://github.com/remix-run/react-router/pull/9394))
3003- Enhance console error messages for invalid usage of data router hooks ([#9311](https://github.com/remix-run/react-router/pull/9311))
3004- If an index route has children, it will result in a runtime error. We have strengthened our `RouteObject`/`RouteProps` types to surface the error in TypeScript. ([#9366](https://github.com/remix-run/react-router/pull/9366))
3005- Updated dependencies:
3006 - `@remix-run/router@1.0.2`
3007
3008## 6.4.1
3009
3010### Patch Changes
3011
3012- Preserve state from `initialEntries` ([#9288](https://github.com/remix-run/react-router/pull/9288))
3013- Updated dependencies:
3014 - `@remix-run/router@1.0.1`
3015
3016## 6.4.0
3017
3018Whoa this is a big one! `6.4.0` brings all the data loading and mutation APIs over from Remix. Here's a quick high level overview, but it's recommended you go check out the [docs](https://reactrouter.com), especially the [feature overview](https://reactrouter.com/en/6.4.0/start/overview) and the [tutorial](https://reactrouter.com/en/6.4.0/start/tutorial).
3019
3020**New APIs**
3021
3022- Create your router with `createMemoryRouter`
3023- Render your router with `<RouterProvider>`
3024- Load data with a Route `loader` and mutate with a Route `action`
3025- Handle errors with Route `errorElement`
3026- Defer non-critical data with `defer` and `Await`
3027
3028**Bug Fixes**
3029
3030- Path resolution is now trailing slash agnostic (#8861)
3031- `useLocation` returns the scoped location inside a `<Routes location>` component (#9094)
3032
3033**Updated Dependencies**
3034
3035- `@remix-run/router@1.0.0`