react-router 7.9.6 → 7.10.0-pre.1

package/dist/development/dom-export.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.9.6
+ * react-router v7.10.0-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -14,7 +14,7 @@ import {
   deserializeErrors,
   getHydrationData,
   populateRSCRouteModules
-} from "./chunk-G3INQAYP.mjs";
+} from "./chunk-V5RTLP6E.mjs";
 import {
   CRITICAL_CSS_DATA_ATTRIBUTE,
   ErrorResponseImpl,
@@ -22,7 +22,6 @@ import {
   RSCRouterContext,
   RemixErrorBoundary,
   RouterProvider,
-  UNSTABLE_TransitionEnabledRouterProvider,
   createBrowserHistory,
   createClientRoutes,
   createClientRoutesWithHMRRevalidationOptOut,
@@ -43,7 +42,7 @@ import {
   singleFetchUrl,
   stripIndexParam,
   useFogOFWarDiscovery
-} from "./chunk-4WY6JWTD.mjs";
+} from "./chunk-GIMUO62I.mjs";
 
 // lib/dom-export/dom-router-provider.tsx
 import * as React from "react";
@@ -245,6 +244,7 @@ function HydratedRouter(props) {
         RouterProvider2,
         {
           router,
+          unstable_useTransitions: props.unstable_useTransitions,
           unstable_onError: props.unstable_onError
         }
       ))
@@ -283,66 +283,68 @@ function createCallServer({
         temporaryReferences
       });
     });
-    globalVar.__reactRouterDataRouter.__setPendingRerender(
-      Promise.resolve(payloadPromise).then(async (payload) => {
-        if (payload.type === "redirect") {
-          if (payload.reload || isExternalLocation(payload.location)) {
-            window.location.href = payload.location;
-            return () => {
-            };
-          }
-          return () => {
-            globalVar.__reactRouterDataRouter.navigate(payload.location, {
-              replace: payload.replace
-            });
-          };
-        }
-        if (payload.type !== "action") {
-          throw new Error("Unexpected payload type");
-        }
-        const rerender = await payload.rerender;
-        if (rerender && landedActionId < actionId && globalVar.__routerActionID <= actionId) {
-          if (rerender.type === "redirect") {
-            if (rerender.reload || isExternalLocation(rerender.location)) {
-              window.location.href = rerender.location;
+    React3.startTransition(
+      () => (
+        // @ts-expect-error - Needs React 19 types
+        Promise.resolve(payloadPromise).then(async (payload) => {
+          if (payload.type === "redirect") {
+            if (payload.reload || isExternalLocation(payload.location)) {
+              window.location.href = payload.location;
               return;
             }
-            return () => {
-              globalVar.__reactRouterDataRouter.navigate(rerender.location, {
-                replace: rerender.replace
+            React3.startTransition(() => {
+              globalVar.__reactRouterDataRouter.navigate(payload.location, {
+                replace: payload.replace
               });
-            };
+            });
+            return;
           }
-          return () => {
-            let lastMatch;
-            for (const match of rerender.matches) {
-              globalVar.__reactRouterDataRouter.patchRoutes(
-                lastMatch?.id ?? null,
-                [createRouteFromServerManifest(match)],
-                true
-              );
-              lastMatch = match;
+          if (payload.type !== "action") {
+            throw new Error("Unexpected payload type");
+          }
+          const rerender = await payload.rerender;
+          if (rerender && landedActionId < actionId && globalVar.__routerActionID <= actionId) {
+            if (rerender.type === "redirect") {
+              if (rerender.reload || isExternalLocation(rerender.location)) {
+                window.location.href = rerender.location;
+                return;
+              }
+              React3.startTransition(() => {
+                globalVar.__reactRouterDataRouter.navigate(rerender.location, {
+                  replace: rerender.replace
+                });
+              });
+              return;
             }
-            window.__reactRouterDataRouter._internalSetStateDoNotUseOrYouWillBreakYourApp(
-              {
-                loaderData: Object.assign(
-                  {},
-                  globalVar.__reactRouterDataRouter.state.loaderData,
-                  rerender.loaderData
-                ),
-                errors: rerender.errors ? Object.assign(
-                  {},
-                  globalVar.__reactRouterDataRouter.state.errors,
-                  rerender.errors
-                ) : null
+            React3.startTransition(() => {
+              let lastMatch;
+              for (const match of rerender.matches) {
+                globalVar.__reactRouterDataRouter.patchRoutes(
+                  lastMatch?.id ?? null,
+                  [createRouteFromServerManifest(match)],
+                  true
+                );
+                lastMatch = match;
               }
-            );
-          };
-        }
-        return () => {
-        };
-      }).catch(() => {
-      })
+              window.__reactRouterDataRouter._internalSetStateDoNotUseOrYouWillBreakYourApp(
+                {
+                  loaderData: Object.assign(
+                    {},
+                    globalVar.__reactRouterDataRouter.state.loaderData,
+                    rerender.loaderData
+                  ),
+                  errors: rerender.errors ? Object.assign(
+                    {},
+                    globalVar.__reactRouterDataRouter.state.errors,
+                    rerender.errors
+                  ) : null
+                }
+              );
+            });
+          }
+        }).catch(() => {
+        })
+      )
     );
     return payloadPromise.then((payload) => {
       if (payload.type !== "action" && payload.type !== "redirect") {
@@ -541,18 +543,20 @@ function getRSCSingleFetchDataStrategy(getRouter, ssr, basename, createFromReada
       }
       renderedRoutesById.get(route.id).push(route);
     }
-    for (const match of args.matches) {
-      const renderedRoutes = renderedRoutesById.get(match.route.id);
-      if (renderedRoutes) {
-        for (const rendered of renderedRoutes) {
-          window.__reactRouterDataRouter.patchRoutes(
-            rendered.parentId ?? null,
-            [createRouteFromServerManifest(rendered)],
-            true
-          );
+    React3.startTransition(() => {
+      for (const match of args.matches) {
+        const renderedRoutes = renderedRoutesById.get(match.route.id);
+        if (renderedRoutes) {
+          for (const rendered of renderedRoutes) {
+            window.__reactRouterDataRouter.patchRoutes(
+              rendered.parentId ?? null,
+              [createRouteFromServerManifest(rendered)],
+              true
+            );
+          }
         }
       }
-    }
+    });
     return results;
   });
 }
@@ -638,14 +642,29 @@ function RSCHydratedRouter({
       globalVar.__reactRouterDataRouter.initialize();
     }
   }, []);
-  let [location2, setLocation] = React3.useState(router2.state.location);
+  let [{ routes, state }, setState] = React3.useState(() => ({
+    routes: cloneRoutes(router2.routes),
+    state: router2.state
+  }));
   React3.useLayoutEffect(
     () => router2.subscribe((newState) => {
-      if (newState.location !== location2) {
-        setLocation(newState.location);
-      }
+      if (diffRoutes(router2.routes, routes))
+        React3.startTransition(() => {
+          setState({
+            routes: cloneRoutes(router2.routes),
+            state: newState
+          });
+        });
+    }),
+    [router2.subscribe, routes, router2]
+  );
+  const transitionEnabledRouter = React3.useMemo(
+    () => ({
+      ...router2,
+      state,
+      routes
     }),
-    [router2, location2]
+    [router2, routes, state]
   );
   React3.useEffect(() => {
     if (routeDiscovery === "lazy" || // @ts-expect-error - TS doesn't know about this yet
@@ -716,7 +735,14 @@ function RSCHydratedRouter({
     routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" },
     routeModules
   };
-  return /* @__PURE__ */ React3.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React3.createElement(RSCRouterGlobalErrorBoundary, { location: location2 }, /* @__PURE__ */ React3.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React3.createElement(UNSTABLE_TransitionEnabledRouterProvider, { router: router2, flushSync: ReactDOM2.flushSync }))));
+  return /* @__PURE__ */ React3.createElement(RSCRouterContext.Provider, { value: true }, /* @__PURE__ */ React3.createElement(RSCRouterGlobalErrorBoundary, { location: state.location }, /* @__PURE__ */ React3.createElement(FrameworkContext.Provider, { value: frameworkContext }, /* @__PURE__ */ React3.createElement(
+    RouterProvider,
+    {
+      router: transitionEnabledRouter,
+      flushSync: ReactDOM2.flushSync,
+      unstable_useTransitions: true
+    }
+  ))));
 }
 function createRouteFromServerManifest(match, payload) {
   let hasInitialData = payload && match.id in payload.loaderData;
@@ -852,11 +878,13 @@ async function fetchAndApplyManifestPatches(paths, createFromReadableStream, fet
     throw new Error("Failed to patch routes");
   }
   paths.forEach((p) => addToFifoQueue(p, discoveredPaths));
-  payload.patches.forEach((p) => {
-    window.__reactRouterDataRouter.patchRoutes(
-      p.parentId ?? null,
-      [createRouteFromServerManifest(p)]
-    );
+  React3.startTransition(() => {
+    payload.patches.forEach((p) => {
+      window.__reactRouterDataRouter.patchRoutes(
+        p.parentId ?? null,
+        [createRouteFromServerManifest(p)]
+      );
+    });
   });
 }
 function addToFifoQueue(path, queue) {
@@ -877,6 +905,32 @@ function isExternalLocation(location2) {
   const newLocation = new URL(location2, window.location.href);
   return newLocation.origin !== window.location.origin;
 }
+function cloneRoutes(routes) {
+  if (!routes) return void 0;
+  return routes.map((route) => ({
+    ...route,
+    children: cloneRoutes(route.children)
+  }));
+}
+function diffRoutes(a, b) {
+  if (a.length !== b.length) return true;
+  return a.some((route, index) => {
+    if (route.element !== b[index].element) return true;
+    if (route.errorElement !== b[index].errorElement)
+      return true;
+    if (route.hydrateFallbackElement !== b[index].hydrateFallbackElement)
+      return true;
+    if (route.hasErrorBoundary !== b[index].hasErrorBoundary)
+      return true;
+    if (route.hasLoader !== b[index].hasLoader) return true;
+    if (route.hasClientLoader !== b[index].hasClientLoader)
+      return true;
+    if (route.hasAction !== b[index].hasAction) return true;
+    if (route.hasClientAction !== b[index].hasClientAction)
+      return true;
+    return diffRoutes(route.children || [], b[index].children || []);
+  });
+}
 
 // lib/rsc/html-stream/browser.ts
 function getRSCStream() {

package/dist/{production/index-react-server-client-Da3kmxNd.d.ts → development/index-react-server-client-CCjKYJTH.d.ts}

@@ -1,4 +1,4 @@
-import { bE as RouteManifest, o as RouteModules, Q as HydrationState, a1 as DataRouteObject, a as ClientLoaderFunction, a5 as StaticHandlerContext, bF as ServerRouteModule, q as MiddlewareEnabled, c as RouterContextProvider, r as AppLoadContext, al as LoaderFunctionArgs, ac as ActionFunctionArgs, au as unstable_ServerInstrumentation, aj as HTMLFormMethod, ah as FormEncType, w as RelativeRoutingType, bh as PageLinkDescriptor, T as To, bG as History, a4 as GetScrollRestorationKeyFunction, e as RouterInit, bH as FutureConfig$1, u as unstable_ClientInstrumentation, p as DataStrategyFunction, a0 as PatchRoutesOnNavigationFunction, s as NavigateOptions, a6 as Fetcher, K as RouteObject, n as Router, v as SerializeFrom, B as BlockerFunction, L as Location, bI as CreateStaticHandlerOptions$1, a2 as StaticHandler } from './instrumentation-Unc20tLk.js';
+import { bE as RouteManifest, o as RouteModules, Q as HydrationState, a1 as DataRouteObject, a as ClientLoaderFunction, a5 as StaticHandlerContext, bF as ServerRouteModule, q as MiddlewareEnabled, c as RouterContextProvider, r as AppLoadContext, al as LoaderFunctionArgs, ac as ActionFunctionArgs, au as unstable_ServerInstrumentation, aj as HTMLFormMethod, ah as FormEncType, w as RelativeRoutingType, bh as PageLinkDescriptor, T as To, bG as History, a4 as GetScrollRestorationKeyFunction, e as RouterInit, bH as FutureConfig$1, u as unstable_ClientInstrumentation, p as DataStrategyFunction, a0 as PatchRoutesOnNavigationFunction, s as NavigateOptions, a6 as Fetcher, K as RouteObject, n as Router, v as SerializeFrom, B as BlockerFunction, L as Location, bI as CreateStaticHandlerOptions$1, a2 as StaticHandler } from './instrumentation-BB0wRuqz.js';
 import * as React from 'react';
 
 interface Route {
@@ -536,7 +536,7 @@ interface DOMRouterOpts {
      * added routes via `route.lazy` or `patchRoutesOnNavigation`).  This is
      * mostly useful for observability such as wrapping navigations, fetches,
      * as well as route loaders/actions/middlewares with logging and/or performance
-     * tracing.
+     * tracing.  See the [docs](../../how-to/instrumentation) for more information.
      *
      * ```tsx
      * let router = createBrowserRouter(routes, {
@@ -580,189 +580,32 @@ interface DOMRouterOpts {
      */
     unstable_instrumentations?: unstable_ClientInstrumentation[];
     /**
-     * Override the default data strategy of running loaders in parallel.
-     * See {@link DataStrategyFunction}.
-     *
-     * <docs-warning>This is a low-level API intended for advanced use-cases. This
-     * overrides React Router's internal handling of
-     * [`action`](../../start/data/route-object#action)/[`loader`](../../start/data/route-object#loader)
-     * execution, and if done incorrectly will break your app code. Please use
-     * with caution and perform the appropriate testing.</docs-warning>
-     *
-     * By default, React Router is opinionated about how your data is loaded/submitted -
-     * and most notably, executes all of your [`loader`](../../start/data/route-object#loader)s
-     * in parallel for optimal data fetching. While we think this is the right
-     * behavior for most use-cases, we realize that there is no "one size fits all"
-     * solution when it comes to data fetching for the wide landscape of
-     * application requirements.
-     *
-     * The `dataStrategy` option gives you full control over how your [`action`](../../start/data/route-object#action)s
-     * and [`loader`](../../start/data/route-object#loader)s are executed and lays
-     * the foundation to build in more advanced APIs such as middleware, context,
-     * and caching layers. Over time, we expect that we'll leverage this API
-     * internally to bring more first class APIs to React Router, but until then
-     * (and beyond), this is your way to add more advanced functionality for your
-     * application's data needs.
-     *
-     * The `dataStrategy` function should return a key/value-object of
-     * `routeId` -> {@link DataStrategyResult} and should include entries for any
-     * routes where a handler was executed. A `DataStrategyResult` indicates if
-     * the handler was successful or not based on the `DataStrategyResult.type`
-     * field. If the returned `DataStrategyResult.result` is a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response),
-     * React Router will unwrap it for you (via [`res.json`](https://developer.mozilla.org/en-US/docs/Web/API/Response/json)
-     * or [`res.text`](https://developer.mozilla.org/en-US/docs/Web/API/Response/text)).
-     * If you need to do custom decoding of a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
-     * but want to preserve the status code, you can use the `data` utility to
-     * return your decoded data along with a `ResponseInit`.
-     *
-     * <details>
-     * <summary><b>Example <code>dataStrategy</code> Use Cases</b></summary>
-     *
-     * **Adding logging**
-     *
-     * In the simplest case, let's look at hooking into this API to add some logging
-     * for when our route [`action`](../../start/data/route-object#action)s/[`loader`](../../start/data/route-object#loader)s
-     * execute:
+     * Override the default data strategy of running loaders in parallel -
+     * see the [docs](../../how-to/data-strategy) for more information.
      *
      * ```tsx
      * let router = createBrowserRouter(routes, {
-     *   async dataStrategy({ matches, request }) {
-     *     const matchesToLoad = matches.filter((m) => m.shouldLoad);
-     *     const results: Record<string, DataStrategyResult> = {};
-     *     await Promise.all(
-     *       matchesToLoad.map(async (match) => {
-     *         console.log(`Processing ${match.route.id}`);
-     *         results[match.route.id] = await match.resolve();;
-     *       })
+     *   async dataStrategy({
+     *     matches,
+     *     request,
+     *     runClientMiddleware,
+     *   }) {
+     *     const matchesToLoad = matches.filter((m) =>
+     *       m.shouldCallHandler(),
      *     );
-     *     return results;
-     *   },
-     * });
-     * ```
-     *
-     * **Middleware**
-     *
-     * Let's define a middleware on each route via [`handle`](../../start/data/route-object#handle)
-     * and call middleware sequentially first, then call all
-     * [`loader`](../../start/data/route-object#loader)s in parallel - providing
-     * any data made available via the middleware:
-     *
-     * ```ts
-     * const routes = [
-     *   {
-     *     id: "parent",
-     *     path: "/parent",
-     *     loader({ request }, context) {
-     *        // ...
-     *     },
-     *     handle: {
-     *       async middleware({ request }, context) {
-     *         context.parent = "PARENT MIDDLEWARE";
-     *       },
-     *     },
-     *     children: [
-     *       {
-     *         id: "child",
-     *         path: "child",
-     *         loader({ request }, context) {
-     *           // ...
-     *         },
-     *         handle: {
-     *           async middleware({ request }, context) {
-     *             context.child = "CHILD MIDDLEWARE";
-     *           },
-     *         },
-     *       },
-     *     ],
-     *   },
-     * ];
      *
-     * let router = createBrowserRouter(routes, {
-     *   async dataStrategy({ matches, params, request }) {
-     *     // Run middleware sequentially and let them add data to `context`
-     *     let context = {};
-     *     for (const match of matches) {
-     *       if (match.route.handle?.middleware) {
-     *         await match.route.handle.middleware(
-     *           { request, params },
-     *           context
-     *         );
-     *       }
-     *     }
-     *
-     *     // Run loaders in parallel with the `context` value
-     *     let matchesToLoad = matches.filter((m) => m.shouldLoad);
-     *     let results = await Promise.all(
-     *       matchesToLoad.map((match, i) =>
-     *         match.resolve((handler) => {
-     *           // Whatever you pass to `handler` will be passed as the 2nd parameter
-     *           // to your loader/action
-     *           return handler(context);
-     *         })
-     *       )
-     *     );
-     *     return results.reduce(
-     *       (acc, result, i) =>
-     *         Object.assign(acc, {
-     *           [matchesToLoad[i].route.id]: result,
+     *     const results: Record<string, DataStrategyResult> = {};
+     *     await runClientMiddleware(() =>
+     *       Promise.all(
+     *         matchesToLoad.map(async (match) => {
+     *           results[match.route.id] = await match.resolve();
      *         }),
-     *       {}
+     *       ),
      *     );
-     *   },
-     * });
-     * ```
-     *
-     * **Custom Handler**
-     *
-     * It's also possible you don't even want to define a [`loader`](../../start/data/route-object#loader)
-     * implementation at the route level. Maybe you want to just determine the
-     * routes and issue a single GraphQL request for all of your data? You can do
-     * that by setting your `route.loader=true` so it qualifies as "having a
-     * loader", and then store GQL fragments on `route.handle`:
-     *
-     * ```ts
-     * const routes = [
-     *   {
-     *     id: "parent",
-     *     path: "/parent",
-     *     loader: true,
-     *     handle: {
-     *       gql: gql`
-     *         fragment Parent on Whatever {
-     *           parentField
-     *         }
-     *       `,
-     *     },
-     *     children: [
-     *       {
-     *         id: "child",
-     *         path: "child",
-     *         loader: true,
-     *         handle: {
-     *           gql: gql`
-     *             fragment Child on Whatever {
-     *               childField
-     *             }
-     *           `,
-     *         },
-     *       },
-     *     ],
-     *   },
-     * ];
-     *
-     * let router = createBrowserRouter(routes, {
-     *   async dataStrategy({ matches, params, request }) {
-     *     // Compose route fragments into a single GQL payload
-     *     let gql = getFragmentsFromRouteHandles(matches);
-     *     let data = await fetchGql(gql);
-     *     // Parse results back out into individual route level `DataStrategyResult`'s
-     *     // keyed by `routeId`
-     *     let results = parseResultsFromGql(data);
      *     return results;
      *   },
      * });
      * ```
-     *</details>
      */
     dataStrategy?: DataStrategyFunction;
     /**
@@ -1122,6 +965,21 @@ interface BrowserRouterProps {
      * {@link Route | `<Route>`} components describing your route configuration
      */
     children?: React.ReactNode;
+    /**
+     * Control whether router state updates are internally wrapped in
+     * [`React.startTransition`](https://react.dev/reference/react/startTransition).
+     *
+     * - When left `undefined`, all router state updates are wrapped in
+     *   `React.startTransition`
+     * - When set to `true`, {@link Link} and {@link Form} navigations will be wrapped
+     *   in `React.startTransition` and all router state updates are wrapped in
+     *   `React.startTransition`
+     * - When set to `false`, the router will not leverage `React.startTransition`
+     *   on any navigations or state changes.
+     *
+     * For more information, please see the [docs](https://reactrouter.com/explanation/react-transitions).
+     */
+    unstable_useTransitions?: boolean;
     /**
      * [`Window`](https://developer.mozilla.org/en-US/docs/Web/API/Window) object
      * override. Defaults to the global `window` instance
@@ -1138,11 +996,12 @@ interface BrowserRouterProps {
  * @param props Props
  * @param {BrowserRouterProps.basename} props.basename n/a
  * @param {BrowserRouterProps.children} props.children n/a
+ * @param {BrowserRouterProps.unstable_useTransitions} props.unstable_useTransitions n/a
  * @param {BrowserRouterProps.window} props.window n/a
  * @returns A declarative {@link Router | `<Router>`} using the browser [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
  * API for client-side routing.
  */
-declare function BrowserRouter({ basename, children, window, }: BrowserRouterProps): React.JSX.Element;
+declare function BrowserRouter({ basename, children, unstable_useTransitions, window, }: BrowserRouterProps): React.JSX.Element;
 /**
  * @category Types
  */
@@ -1155,6 +1014,21 @@ interface HashRouterProps {
      * {@link Route | `<Route>`} components describing your route configuration
      */
     children?: React.ReactNode;
+    /**
+     * Control whether router state updates are internally wrapped in
+     * [`React.startTransition`](https://react.dev/reference/react/startTransition).
+     *
+     * - When left `undefined`, all router state updates are wrapped in
+     *   `React.startTransition`
+     * - When set to `true`, {@link Link} and {@link Form} navigations will be wrapped
+     *   in `React.startTransition` and all router state updates are wrapped in
+     *   `React.startTransition`
+     * - When set to `false`, the router will not leverage `React.startTransition`
+     *   on any navigations or state changes.
+     *
+     * For more information, please see the [docs](https://reactrouter.com/explanation/react-transitions).
+     */
+    unstable_useTransitions?: boolean;
     /**
      * [`Window`](https://developer.mozilla.org/en-US/docs/Web/API/Window) object
      * override. Defaults to the global `window` instance
@@ -1172,11 +1046,12 @@ interface HashRouterProps {
  * @param props Props
  * @param {HashRouterProps.basename} props.basename n/a
  * @param {HashRouterProps.children} props.children n/a
+ * @param {HashRouterProps.unstable_useTransitions} props.unstable_useTransitions n/a
  * @param {HashRouterProps.window} props.window n/a
  * @returns A declarative {@link Router | `<Router>`} using the URL [`hash`](https://developer.mozilla.org/en-US/docs/Web/API/URL/hash)
  * for client-side routing.
  */
-declare function HashRouter({ basename, children, window }: HashRouterProps): React.JSX.Element;
+declare function HashRouter({ basename, children, unstable_useTransitions, window, }: HashRouterProps): React.JSX.Element;
 /**
  * @category Types
  */
@@ -1193,6 +1068,21 @@ interface HistoryRouterProps {
      *  A {@link History} implementation for use by the router
      */
     history: History;
+    /**
+     * Control whether router state updates are internally wrapped in
+     * [`React.startTransition`](https://react.dev/reference/react/startTransition).
+     *
+     * - When left `undefined`, all router state updates are wrapped in
+     *   `React.startTransition`
+     * - When set to `true`, {@link Link} and {@link Form} navigations will be wrapped
+     *   in `React.startTransition` and all router state updates are wrapped in
+     *   `React.startTransition`
+     * - When set to `false`, the router will not leverage `React.startTransition`
+     *   on any navigations or state changes.
+     *
+     * For more information, please see the [docs](https://reactrouter.com/explanation/react-transitions).
+     */
+    unstable_useTransitions?: boolean;
 }
 /**
  * A declarative {@link Router | `<Router>`} that accepts a pre-instantiated
@@ -1209,10 +1099,11 @@ interface HistoryRouterProps {
  * @param {HistoryRouterProps.basename} props.basename n/a
  * @param {HistoryRouterProps.children} props.children n/a
  * @param {HistoryRouterProps.history} props.history n/a
+ * @param {HistoryRouterProps.unstable_useTransitions} props.unstable_useTransitions n/a
  * @returns A declarative {@link Router | `<Router>`} using the provided history
  * implementation for client-side routing.
  */
-declare function HistoryRouter({ basename, children, history, }: HistoryRouterProps): React.JSX.Element;
+declare function HistoryRouter({ basename, children, history, unstable_useTransitions, }: HistoryRouterProps): React.JSX.Element;
 declare namespace HistoryRouter {
     var displayName: string;
 }
@@ -1830,15 +1721,19 @@ declare namespace ScrollRestoration {
  * @param options.viewTransition Enables a [View Transition](https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API)
  * for this navigation. To apply specific styles during the transition, see
  * {@link useViewTransitionState}. Defaults to `false`.
+ * @param options.unstable_useTransitions Wraps the navigation in
+ * [`React.startTransition`](https://react.dev/reference/react/startTransition)
+ * for concurrent rendering. Defaults to `false`.
  * @returns A click handler function that can be used in a custom {@link Link} component.
  */
-declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to: To, { target, replace: replaceProp, state, preventScrollReset, relative, viewTransition, }?: {
+declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to: To, { target, replace: replaceProp, state, preventScrollReset, relative, viewTransition, unstable_useTransitions, }?: {
     target?: React.HTMLAttributeAnchorTarget;
     replace?: boolean;
     state?: any;
     preventScrollReset?: boolean;
     relative?: RelativeRoutingType;
     viewTransition?: boolean;
+    unstable_useTransitions?: boolean;
 }): (event: React.MouseEvent<E, MouseEvent>) => void;
 /**
  * Returns a tuple of the current URL's [`URLSearchParams`](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams)
@@ -2167,7 +2062,7 @@ type FetcherWithComponents<TData> = Fetcher<TData> & {
      * @param reason Optional `reason` to provide to [`AbortController.abort()`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort)
      * @returns void
      */
-    unstable_reset: (opts?: {
+    reset: (opts?: {
         reason?: unknown;
     }) => void;
     /**
@@ -2256,7 +2151,7 @@ type FetcherWithComponents<TData> = Fetcher<TData> & {
  *   })
  *
  *   // reset fetcher
- *   fetcher.unstable_reset()
+ *   fetcher.reset()
  * }
  *
  * @public