Declarative routing for React
React Router is a multi-strategy router for React bridging the gap from React 18 to React 19. You can use it maximally as a React framework or minimally as a library with your own architecture.
remix-run
react-router@react-router/dev@react-router/node@react-router/cloudflare@react-router/serve@react-router/fs-routesreact-routerNo changes
Do not rely on symbol for filtering out redirect responses from loader data (#12694)
Previously, some projects were getting type checking errors like:
error TS4058: Return type of exported function has or is using name 'redirectSymbol' from external module "node_modules/..." but cannot be named.Now that symbols are not used for the redirect response type, these errors should no longer be present.
No changes
<Link prefetch> warning which suffers from false positives in a lazy route discovery world (#12485)Generate wide matches and params types for current route and child routes (#12397)
At runtime, matches includes child route matches and params include child route path parameters.
But previously, we only generated types for parent routes in matches; for params, we only considered the parent routes and the current route.
To align our generated types more closely to the runtime behavior, we now generate more permissive, wider types when accessing child route information.
No changes
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)
deferAbortedDeferredErrortype TypedDeferredDataUNSAFE_DeferredDataUNSAFE_DEFERRED_SYMBOL,@remix-run/router into react-router (#11505)react-router-dom into react-router@remix-run/server-runtime into react-router@remix-run/testing into react-routerRemove single_fetch future flag. (#11522)
Drop support for Node 16, React Router SSR now requires Node 18 or higher (#11391)
Remove future.v7_startTransition flag (#11696)
useNavigate()useSubmituseFetcher().loaduseFetcher().submituseRevalidator.revalidateRemove future.v7_normalizeFormMethod future flag (#11697)
For Remix consumers migrating to React Router, the crypto global from the 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)
createCookiecreateCookieSessionStoragecreateMemorySessionStoragecreateSessionStorageFor 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.
Since platform-specific packages no longer need to implement this API, the following low-level APIs have been removed:
createCookieFactorycreateSessionStorageFactorycreateCookieSessionStorageFactorycreateMemorySessionStorageFactoryImports/Exports cleanup (#11840)
@remix-run/routerAgnosticDataIndexRouteObjectAgnosticDataNonIndexRouteObjectAgnosticDataRouteMatchAgnosticDataRouteObjectAgnosticIndexRouteObjectAgnosticNonIndexRouteObjectAgnosticRouteMatchAgnosticRouteObjectTrackedPromiseunstable_AgnosticPatchRoutesOnMissFunctionAction -> exported as NavigationType via react-routerRouter exported as DataRouter to differentiate from RR's <Router>getToPathname (@private)joinPaths (@private)normalizePathname (@private)resolveTo (@private)stripBasename (@private)createBrowserHistory -> in favor of createBrowserRoutercreateHashHistory -> in favor of createHashRoutercreateMemoryHistory -> in favor of createMemoryRoutercreateRoutercreateStaticHandler -> in favor of wrapper createStaticHandler in RR DomgetStaticContextFromErrorreact-routerHashPathnameSearchupdate minimum node version to 18 (#11690)
Remove future.v7_prependBasename from the ionternalized @remix-run/router package (#11726)
Migrate Remix type generics to React Router (#12180)
Route.* typesRoute.* typesuseFetcher previously had an optional generic (used primarily by Remix v2) that expected the data typetypeof loader/typeof action)useFetcher<LoaderData>()useFetcher<typeof loader>()Remove future.v7_throwAbortReason from internalized @remix-run/router package (#11728)
Add exports field to all packages (#11675)
node package no longer re-exports from react-router (#11702)
renamed RemixContext to FrameworkContext (#11705)
updates the minimum React version to 18 (#11689)
PrefetchPageDescriptor replaced by PageLinkDescriptor (#11960)
@remix-run/router, @remix-run/server-runtime, and @remix-run/react now that they all live in react-router (#12177)LoaderFunction, LoaderFunctionArgs, ActionFunction, ActionFunctionArgs, DataFunctionArgs, RouteManifest, LinksFunction, Route, EntryRouteRouteManifest type used by the "remix" code is now slightly stricter because it is using the former @remix-run/router RouteManifestRecord<string, Route> -> Record<string, Route | undefined>AppData type in favor of inlining unknown in the few locations it was usedServerRuntimeMeta* types in favor of the Meta* types they were duplicated fromfuture.v7_partialHydration flag (#11725)<RouterProvider fallbackElement> propfallbackElement to a hydrateFallbackElement/HydrateFallback on your root routefuture.v7_partialHydration (when using fallbackElement), state.navigation was populated during the initial loadfuture.v7_partialHydration, state.navigation remains in an "idle" state during the initial loadRemove v7_relativeSplatPath future flag (#11695)
Drop support for Node 18, update minimum Node vestion to 20 (#12171)
installGlobals() as this should no longer be necessaryRemove remaining future flags (#11820)
v7_skipActionErrorRevalidationv3_fetcherPersist, v3_relativeSplatPath, v3_throwAbortReasonrename createRemixStub to createRoutesStub (#11692)
Remove @remix-run/router deprecated detectErrorBoundary option in favor of mapRouteProperties (#11751)
Add react-router/dom subpath export to properly enable react-dom as an optional peerDependency (#11851)
import ReactDOM from "react-dom" in <RouterProvider> in order to access ReactDOM.flushSync(), since that would break createMemoryRouter use cases in non-DOM environmentsreact-router/dom to get the proper component that makes ReactDOM.flushSync() available:entry.client.tsx:import { HydratedRouter } from 'react-router/dom'createBrowserRouter/createHashRouter:import { RouterProvider } from "react-router/dom"Remove future.v7_fetcherPersist flag (#11731)
Update cookie dependency to ^1.0.1 - please see the release notes for any breaking changes (#12172)
prerender config in the React Router vite plugin, to support existing SSG use-cases (#11539)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)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.// react-router.config.ts
import type { Config } from "@react-router/dev/config";
export default {
async prerender() {
let slugs = await fakeGetSlugsFromCms();
// Prerender these paths into `.html` files at build time, and `.data`
// files if they have loaders
return ["/", "/about", ...slugs.map((slug) => `/product/${slug}`)];
},
} satisfies Config;
async function fakeGetSlugsFromCms() {
await new Promise((r) => setTimeout(r, 1000));
return ["shirt", "hat"];
}Params, loader data, and action data as props for route component exports (#11961)
export default function Component({ params, loaderData, actionData }) {}
export function HydrateFallback({ params }) {}
export function ErrorBoundary({ params, loaderData, actionData }) {}Remove duplicate RouterProvider impliementations (#11679)
React Router now generates types for each of your route modules.
You can access those types by importing them from ./+types.<route filename without extension>.
For example:
// app/routes/product.tsx
import type * as Route from "./+types.product";
export function loader({ params }: Route.LoaderArgs) {}
export default function Component({ loaderData }: Route.ComponentProps) {}This initial implementation targets type inference for:
Params : Path parameters from your routing config in routes.ts including file-based routingLoaderData : Loader data from loader and/or clientLoader within your route moduleActionData : Action data from action and/or clientAction within your route moduleIn the future, we plan to add types for the rest of the route module exports: meta, links, headers, shouldRevalidate, etc.
We also plan to generate types for typesafe Links:
<Link to="/products/:id" params={{ id: 1 }} />
// ^^^^^^^^^^^^^ ^^^^^^^^^
// typesafe `to` and `params` based on the available routes in your appCheck out our docs for more:
Stabilize unstable_dataStrategy (#11969)
Stabilize unstable_patchRoutesOnNavigation (#11970)
No changes (506329c4e)
chore: re-enable development warnings through a development exports condition. (#12269)
Remove unstable upload handler. (#12015)
Remove unneeded dependency on @web3-storage/multipart-parser (#12274)
Fix redirects returned from loaders/actions using data() (#12021)
fix(react-router): (v7) fix static prerender of non-ascii characters (#12161)
Replace substr with substring (#12080)
Remove the deprecated json utility (#12146)
Response.json if you still need to construct JSON responses in your appRemove unneeded dependency on source-map (#12275)
json/defer in favor of returning raw objects@remix-run/router@1.21.0unstable_patchRoutesOnNavigation (#11973)PatchRoutesOnNavigationFunctionArgs type for convenience (#11967)unstable_dataStrategy (#11974)unstable_flushSync option for navigations and fetchers (#11989)unstable_viewTransition option for navigations and the corresponding unstable_useViewTransitionState hook (#11989)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)
Fix useFormAction bug - when removing ?index param it would not keep other non-Remix index params (#12003)
Fix types for RouteObject within PatchRoutesOnNavigationFunction's patch method so it doesn't expect agnostic route objects passed to patch (#11967)
Updated dependencies:
@remix-run/router@1.20.0@remix-run/router@1.19.2unstable_patchRoutesOnMiss to unstable_patchRoutesOnNavigation to match new behavior (#11888)@remix-run/router@1.19.1replace(url, init?) alternative to redirect(url, init?) that performs a history.replaceState instead of a history.pushState on client-side navigation redirects (#11811)future.v7_partialHydration along with unstable_patchRoutesOnMiss (#11838)router.state.matches will now include any partial matches so that we can render ancestor HydrateFallback components@remix-run/router@1.19.0No significant changes to this package were made in this release. See the repo CHANGELOG.md for an overview of all changes in v6.25.1.
future.unstable_skipActionErrorRevalidation as future.v7_skipActionErrorRevalidation (#11769)Response with a 4xx/5xx status codeshouldRevalidateshouldRevalidate's unstable_actionStatus parameter to actionStatususeMatch so matches/params reflect decoded params (#11789)@remix-run/router@1.18.0future.v7_relativeSplatPath, properly resolve relative paths in splat routes that are children of pathless routes (#11633)@remix-run/router@1.17.1unstable_patchRoutesOnMiss docs: https://reactrouter.com/v6/routers/create-browser-router@remix-run/router@1.17.0<Await> (#11513)@remix-run/router@1.16.1unstable_dataStrategy configuration option (#11098)@remix-run/router@1.16.0@remix-run/router@1.15.3@remix-run/router@1.15.2@remix-run/router@1.15.1@remix-run/router@1.15.0unstable_ prefix from Blocker/BlockerFunction types (#11187)@remix-run/router@1.14.2route.lazy not working correctly on initial SPA load when v7_partialHydration is specified (#11121)@remix-run/router@1.14.1Add a new future.v7_relativeSplatPath flag to implement a breaking bug fix to relative routing when inside a splat route. (#11087)
This fix was originally added in #10983 and was later reverted in #11078 because it was determined that a large number of existing applications were relying on the buggy behavior (see #11052)
The Bug
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.
The Background
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:
<BrowserRouter>
<Routes>
<Route path="/" element={<Home />} />
<Route path="dashboard/*" element={<Dashboard />} />
</Routes>
</BrowserRouter>Any paths like /dashboard, /dashboard/team, /dashboard/projects will match the Dashboard route. The dashboard component itself can then render nested <Routes>:
function Dashboard() {
return (
<div>
<h2>Dashboard</h2>
<nav>
<Link to="/">Dashboard Home</Link>
<Link to="team">Team</Link>
<Link to="projects">Projects</Link>
</nav>
<Routes>
<Route path="/" element={<DashboardHome />} />
<Route path="team" element={<DashboardTeam />} />
<Route path="projects" element={<DashboardProjects />} />
</Routes>
</div>
);
}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.
The Problem
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 ".":
// If we are on URL /dashboard/team, and we want to link to /dashboard/team:
function DashboardTeam() {
// ❌ This is broken and results in <a href="/dashboard">
return <Link to=".">A broken link to the Current URL</Link>;
// ✅ This is fixed but super unintuitive since we're already at /dashboard/team!
return <Link to="./team">A broken link to the Current URL</Link>;
}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.
Even worse, consider a nested splat route configuration:
<BrowserRouter>
<Routes>
<Route path="dashboard">
<Route path="*" element={<Dashboard />} />
</Route>
</Routes>
</BrowserRouter>Now, a <Link to="."> and a <Link to=".."> inside the Dashboard component go to the same place! That is definitely not correct!
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:
let router = createBrowserRouter({
path: "/dashboard",
children: [
{
path: "*",
action: dashboardAction,
Component() {
// ❌ This form is broken! It throws a 405 error when it submits because
// it tries to submit to /dashboard (without the splat value) and the parent
// `/dashboard` route doesn't have an action
return <Form method="post">...</Form>;
},
},
],
});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.
The Solution
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:
<BrowserRouter>
<Routes>
<Route path="dashboard">
<Route index path="*" element={<Dashboard />} />
</Route>
</Routes>
</BrowserRouter>
function Dashboard() {
return (
<div>
<h2>Dashboard</h2>
<nav>
<Link to="..">Dashboard Home</Link>
<Link to="../team">Team</Link>
<Link to="../projects">Projects</Link>
</nav>
<Routes>
<Route path="/" element={<DashboardHome />} />
<Route path="team" element={<DashboardTeam />} />
<Route path="projects" element={<DashboardProjects />} />
</Router>
</div>
);
}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".
@remix-run/router@1.14.0useResolvedPath 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)@remix-run/router@1.13.1PathParam type from the public API (#10719)resolveTo in splat routes (#11045)getPathContributingMatchesUNSAFE_getPathContributingMatches export from @remix-run/router since we no longer need this in the react-router/react-router-dom layers@remix-run/router@1.13.0unstable_flushSync option to useNavigate/useSumbit/fetcher.load/fetcher.submit to opt-out of React.startTransition and into ReactDOM.flushSync for state updates (#11005)unstable_ prefix from the useBlocker 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)Fix useActionData so it returns proper contextual action data and not any action data in the tree (#11023)
Fix bug in useResolvedPath that would cause useResolvedPath(".") in a splat route to lose the splat portion of the URL path. (#10983)
"." 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.Updated dependencies:
@remix-run/router@1.12.0future prop on BrowserRouter, HashRouter and MemoryRouter so that it accepts a Partial<FutureConfig> instead of requiring all flags to be included. (#10962)@remix-run/router@1.11.0RouterProvider future prop type to be a Partial<FutureConfig> so that not all flags must be specified (#10900)@remix-run/router@1.10.0any 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)Location now accepts a generic for the location.state valueActionFunctionArgs/ActionFunction/LoaderFunctionArgs/LoaderFunction now accept a generic for the context parameter (only used in SSR usages via createStaticHandler)useMatches (now exported as UIMatch) accepts generics for match.data and match.handle - both of which were already set to unknown@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)ShouldRevalidateFunctionArgs interface (#10797)_isFetchActionRedirect, _hasFetcherDoneAnything) (#10715)@remix-run/router@1.9.0redirectDocument() 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)useRevalidator is referentially stable across re-renders if revalidations are not actively occurring (#10707)@remix-run/router@1.8.0@remix-run/router@1.7.2unstable_useBlocker when used with an unstable blocker function (#10652)@remix-run/router@1.7.1basename from locations provided to unstable_useBlocker functions to match useLocation (#10573)generatePath when passed a numeric 0 value parameter (#10612)unstable_useBlocker key issues in StrictMode (#10573)tsc --skipLibCheck:false issues on React 17 (#10622)typescript to 5.1 (#10581)@remix-run/router@1.7.0Move React.startTransition usage behind a future flag 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)
Existing behavior will no longer include React.startTransition:
<BrowserRouter>
<Routes>{/*...*/}</Routes>
</BrowserRouter>
<RouterProvider router={router} />If you wish to enable React.startTransition, pass the future flag to your component:
<BrowserRouter future={{ v7_startTransition: true }}>
<Routes>{/*...*/}</Routes>
</BrowserRouter>
<RouterProvider router={router} future={{ v7_startTransition: true }}/>React.startTransition minification bug in production mode (#10588)[!WARNING] Please use version
6.13.0or later instead of6.12.1. This version suffers from awebpack/terserminification issue resulting in invalid minified code in your resulting production bundles which can cause issues in your application. See #10579 for more details.
React.startTransition to fix webpack + react 17 compilation error (#10569)React.startTransition if it exists (#10438)@remix-run/router@1.6.3basename duplication in descendant <Routes> inside a <RouterProvider> (#10492)@remix-run/router@1.6.2Component API within descendant <Routes> (#10434)useNavigate from <Routes> inside a <RouterProvider> (#10432)<Navigate> in strict mode when using a data router (#10435)@remix-run/router@1.6.1<Routes> when RouterProvider errors existed (#10374)Component instead of element on a route definition (#10287)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)useSyncExternalStore to useState for internal @remix-run/router router state syncing in <RouterProvider>. We found some subtle bugs where router state updates got propagated before other normal useState updates, which could lead to footguns in useEffect calls. (#10377, #10409)useRevalidator() to resolve a loader-driven error boundary scenario (#10369)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)@remix-run/router@1.6.0Added support for Future Flags 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)
future.v7_normalizeFormMethod === false (default v6 behavior),useNavigation().formMethod is lowercaseuseFetcher().formMethod is lowercasefuture.v7_normalizeFormMethod === true:useNavigation().formMethod is uppercaseuseFetcher().formMethod is uppercasecreateRoutesFromElements (#10193)@remix-run/router@1.5.0React 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)
Example JSON Syntax
// Both of these work the same:
const elementRoutes = [{
path: '/',
element: <Home />,
errorElement: <HomeError />,
}]
const componentRoutes = [{
path: '/',
Component: Home,
ErrorBoundary: HomeError,
}]
function Home() { ... }
function HomeError() { ... }Example JSX Syntax
// Both of these work the same:
const elementRoutes = createRoutesFromElements(
<Route path='/' element={<Home />} errorElement={<HomeError /> } />
);
const componentRoutes = createRoutesFromElements(
<Route path='/' Component={Home} ErrorBoundary={HomeError} />
);
function Home() { ... }
function HomeError() { ... }Introducing Lazy Route Modules! (#10045)
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).
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.
Your lazy functions will typically return the result of a dynamic import.
// In this example, we assume most folks land on the homepage so we include that
// in our critical-path bundle, but then we lazily load modules for /a and /b so
// they don't load until the user navigates to those routes
let routes = createRoutesFromElements(
<Route path="/" element={<Layout />}>
<Route index element={<Home />} />
<Route path="a" lazy={() => import("./a")} />
<Route path="b" lazy={() => import("./b")} />
</Route>
);Then in your lazy route modules, export the properties you want defined for the route:
export async function loader({ request }) {
let data = await fetchData(request);
return json(data);
}
// Export a `Component` directly instead of needing to create a React Element from it
export function Component() {
let data = useLoaderData();
return (
<>
<h1>You made it!</h1>
<p>{data}</p>
</>
);
}
// Export an `ErrorBoundary` directly instead of needing to create a React Element from it
export function ErrorBoundary() {
let error = useRouteError();
return isRouteErrorResponse(error) ? (
<h1>
{error.status} {error.statusText}
</h1>
) : (
<h1>{error.message || error}</h1>
);
}An example of this in action can be found in the examples/lazy-loading-router-provider directory of the repository.
🙌 Huge thanks to @rossipedia for the Initial Proposal and POC Implementation.
Updated dependencies:
@remix-run/router@1.4.0generatePath incorrectly applying parameters in some cases (#10078)@remix-run/router@1.3.3@remix-run/router@1.3.2@remix-run/router@1.3.1unstable_useBlocker hook for blocking navigations within the app's location origin (#9709)generatePath when optional params are present (#9764)<Await> to accept ReactNode as children function return result (#9896)@remix-run/router@1.3.0useId consistency during SSR (#9805)@remix-run/router@1.2.1useLoaderData usage in errorElement (#9735)@remix-run/router@1.2.0This release introduces support for Optional Route Segments. 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.
Optional Params Examples
<Route path=":lang?/about> will match:/:lang/about/about<Route path="/multistep/:widget1?/widget2?/widget3?"> will match:/multistep/multistep/:widget1/multistep/:widget1/:widget2/multistep/:widget1/:widget2/:widget3Optional Static Segment Example
<Route path="/home?"> will match://home<Route path="/fr?/about"> will match:/about/fr/about<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)// Old behavior at URL /prefix-123
<Route path="prefix-:id" element={<Comp /> }>
function Comp() {
let params = useParams(); // { id: '123' }
let id = params.id; // "123"
...
}
// New behavior at URL /prefix-123
<Route path=":id" element={<Comp /> }>
function Comp() {
let params = useParams(); // { id: 'prefix-123' }
let id = params.id.replace(/^prefix-/, ''); // "123"
...
}@remix-run/router@1.1.0@remix-run/router@1.0.5@remix-run/router@1.0.4useRoutes should be able to return null when passing locationArg (#9485)initialEntries type in createMemoryRouter (#9498)@remix-run/router@1.0.3IndexRouteObject and NonIndexRouteObject types to make hasErrorElement optional (#9394)RouteObject/RouteProps types to surface the error in TypeScript. (#9366)@remix-run/router@1.0.2initialEntries (#9288)@remix-run/router@1.0.1Whoa 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, especially the feature overview and the tutorial.
New APIs
createMemoryRouter<RouterProvider>loader and mutate with a Route actionerrorElementdefer and AwaitBug Fixes
useLocation returns the scoped location inside a <Routes location> component (#9094)Updated Dependencies
@remix-run/router@1.0.0