react-router 7.8.2 → 7.9.0-pre.0

package/dist/production/{routeModules-rOzWJJ9x.d.ts → routeModules-DSKAn01V.d.ts}

@@ -1,16 +1,6 @@
 import * as React from 'react';
 import { ComponentType, ReactElement } from 'react';
 
-/**
- * An augmentable interface users can modify in their app-code to opt into
- * future-flag-specific types
- */
-interface Future {
-}
-type MiddlewareEnabled = Future extends {
-    unstable_middleware: infer T extends boolean;
-} ? T : false;
-
 /**
  * Actions represent the type of change to a location value.
  */
@@ -216,6 +206,16 @@ type UrlHistoryOptions = {
     v5Compat?: boolean;
 };
 
+/**
+ * An augmentable interface users can modify in their app-code to opt into
+ * future-flag-specific types
+ */
+interface Future {
+}
+type MiddlewareEnabled = Future extends {
+    middleware: infer T extends boolean;
+} ? T : false;
+
 type MaybePromise<T> = T | Promise<T>;
 /**
  * Map of routeId -> data returned from a loader/action/error
@@ -273,14 +273,14 @@ type Submission = {
 };
 /**
  * A context instance used as the key for the `get`/`set` methods of a
- * {@link unstable_RouterContextProvider}. Accepts an optional default
+ * {@link RouterContextProvider}. Accepts an optional default
  * value to be returned if no value has been set.
  */
-interface unstable_RouterContext<T = unknown> {
+interface RouterContext<T = unknown> {
     defaultValue?: T;
 }
 /**
- * Creates a type-safe {@link unstable_RouterContext} object that can be used to
+ * Creates a type-safe {@link RouterContext} object that can be used to
  * store and retrieve arbitrary values in [`action`](../../start/framework/route-module#action)s,
  * [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
  * Similar to React's [`createContext`](https://react.dev/reference/react/createContext),
@@ -291,11 +291,11 @@ interface unstable_RouterContext<T = unknown> {
  * when no value has been set will throw an error.
  *
  * ```tsx filename=app/context.ts
- * import { unstable_createContext } from "react-router";
+ * import { createContext } from "react-router";
  *
  * // Create a context for user data
  * export const userContext =
- *   unstable_createContext<User | null>(null);
+ *   createContext<User | null>(null);
  * ```
  *
  * ```tsx filename=app/middleware/auth.ts
@@ -333,23 +333,23 @@ interface unstable_RouterContext<T = unknown> {
  * @mode data
  * @param defaultValue An optional default value for the context. This value
  * will be returned if no value has been set for this context.
- * @returns A {@link unstable_RouterContext} object that can be used with
+ * @returns A {@link RouterContext} object that can be used with
  * `context.get()` and `context.set()` in [`action`](../../start/framework/route-module#action)s,
  * [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
  */
-declare function unstable_createContext<T>(defaultValue?: T): unstable_RouterContext<T>;
+declare function createContext<T>(defaultValue?: T): RouterContext<T>;
 /**
  * Provides methods for writing/reading values in application context in a
  * type-safe way. Primarily for usage with [middleware](../../how-to/middleware).
  *
  * @example
  * import {
- *   unstable_createContext,
- *   unstable_RouterContextProvider
+ *   createContext,
+ *   RouterContextProvider
  * } from "react-router";
  *
- * const userContext = unstable_createContext<User | null>(null);
- * const contextProvider = new unstable_RouterContextProvider();
+ * const userContext = createContext<User | null>(null);
+ * const contextProvider = new RouterContextProvider();
  * contextProvider.set(userContext, getUser());
  * //                               ^ Type-safe
  * const user = contextProvider.get(userContext);
@@ -360,13 +360,13 @@ declare function unstable_createContext<T>(defaultValue?: T): unstable_RouterCon
  * @mode framework
  * @mode data
  */
-declare class unstable_RouterContextProvider {
+declare class RouterContextProvider {
     #private;
     /**
-     * Create a new `unstable_RouterContextProvider` instance
+     * Create a new `RouterContextProvider` instance
      * @param init An optional initial context map to populate the provider with
      */
-    constructor(init?: Map<unstable_RouterContext, unknown>);
+    constructor(init?: Map<RouterContext, unknown>);
     /**
      * Access a value from the context. If no value has been set for the context,
      * it will return the context's `defaultValue` if provided, or throw an error
@@ -375,7 +375,7 @@ declare class unstable_RouterContextProvider {
      * @returns The value for the context, or the context's `defaultValue` if no
      * value was set
      */
-    get<T>(context: unstable_RouterContext<T>): T;
+    get<T>(context: RouterContext<T>): T;
     /**
      * Set a value for the context. If the context already has a value set, this
      * will overwrite it.
@@ -384,9 +384,9 @@ declare class unstable_RouterContextProvider {
      * @param value The value to set for the context
      * @returns {void}
      */
-    set<C extends unstable_RouterContext>(context: C, value: C extends unstable_RouterContext<infer T> ? T : never): void;
+    set<C extends RouterContext>(context: C, value: C extends RouterContext<infer T> ? T : never): void;
 }
-type DefaultContext = MiddlewareEnabled extends true ? Readonly<unstable_RouterContextProvider> : any;
+type DefaultContext = MiddlewareEnabled extends true ? Readonly<RouterContextProvider> : any;
 /**
  * @private
  * Arguments passed to route loader/action functions.  Same for now but we keep
@@ -421,7 +421,7 @@ interface DataFunctionArgs<Context> {
  * Route middleware `next` function to call downstream handlers and then complete
  * middlewares from the bottom-up
  */
-interface unstable_MiddlewareNextFunction<Result = unknown> {
+interface MiddlewareNextFunction<Result = unknown> {
     (): Promise<Result>;
 }
 /**
@@ -430,7 +430,7 @@ interface unstable_MiddlewareNextFunction<Result = unknown> {
  * a `next` function as the second parameter which will call downstream handlers
  * and then complete middlewares from the bottom-up
  */
-type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<Readonly<unstable_RouterContextProvider>>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
+type MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<Readonly<RouterContextProvider>>, next: MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
 /**
  * Arguments passed to loader functions
  */
@@ -585,7 +585,7 @@ interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctio
      * Matches for this route extended with Data strategy APIs
      */
     matches: DataStrategyMatch[];
-    unstable_runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
+    runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
     /**
      * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
      * for navigational executions
@@ -630,7 +630,7 @@ type UnsupportedLazyRouteObjectKey = "lazy" | "caseSensitive" | "path" | "id" |
  * onto the route. Either they're meaningful to the router, or they'll get
  * ignored.
  */
-type UnsupportedLazyRouteFunctionKey = UnsupportedLazyRouteObjectKey | "unstable_middleware";
+type UnsupportedLazyRouteFunctionKey = UnsupportedLazyRouteObjectKey | "middleware";
 /**
  * lazy object to load route properties, which can add non-matching
  * related properties to a route
@@ -653,7 +653,7 @@ type AgnosticBaseRouteObject = {
     caseSensitive?: boolean;
     path?: string;
     id?: string;
-    unstable_middleware?: unstable_MiddlewareFunction[];
+    middleware?: MiddlewareFunction[];
     loader?: LoaderFunction | boolean;
     action?: ActionFunction | boolean;
     hasErrorBoundary?: boolean;
@@ -903,6 +903,11 @@ declare class DataWithResponseInit<D> {
  * response init.
  */
 declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
+interface TrackedPromise extends Promise<any> {
+    _tracked?: boolean;
+    _data?: any;
+    _error?: any;
+}
 type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
 /**
  * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
@@ -1308,7 +1313,7 @@ interface RouterInit {
     routes: AgnosticRouteObject[];
     history: History;
     basename?: string;
-    unstable_getContext?: () => MaybePromise<unstable_RouterContextProvider>;
+    getContext?: () => MaybePromise<RouterContextProvider>;
     mapRouteProperties?: MapRoutePropertiesFunction;
     future?: Partial<FutureConfig>;
     hydrationRouteProperties?: string[];
@@ -1343,7 +1348,7 @@ interface StaticHandler {
         skipLoaderErrorBubbling?: boolean;
         skipRevalidation?: boolean;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_generateMiddlewareResponse?: (query: (r: Request, args?: {
+        generateMiddlewareResponse?: (query: (r: Request, args?: {
             filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
         }) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
     }): Promise<StaticHandlerContext | Response>;
@@ -1351,7 +1356,7 @@ interface StaticHandler {
         routeId?: string;
         requestContext?: unknown;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>;
+        generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>;
     }): Promise<any>;
 }
 type ViewTransitionOpts = {
@@ -1585,124 +1590,6 @@ interface CreateStaticHandlerOptions {
     future?: {};
 }
 
-interface IndexRouteObject {
-    caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
-    path?: AgnosticIndexRouteObject["path"];
-    id?: AgnosticIndexRouteObject["id"];
-    unstable_middleware?: AgnosticIndexRouteObject["unstable_middleware"];
-    loader?: AgnosticIndexRouteObject["loader"];
-    action?: AgnosticIndexRouteObject["action"];
-    hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
-    shouldRevalidate?: AgnosticIndexRouteObject["shouldRevalidate"];
-    handle?: AgnosticIndexRouteObject["handle"];
-    index: true;
-    children?: undefined;
-    element?: React.ReactNode | null;
-    hydrateFallbackElement?: React.ReactNode | null;
-    errorElement?: React.ReactNode | null;
-    Component?: React.ComponentType | null;
-    HydrateFallback?: React.ComponentType | null;
-    ErrorBoundary?: React.ComponentType | null;
-    lazy?: LazyRouteDefinition<RouteObject>;
-}
-interface NonIndexRouteObject {
-    caseSensitive?: AgnosticNonIndexRouteObject["caseSensitive"];
-    path?: AgnosticNonIndexRouteObject["path"];
-    id?: AgnosticNonIndexRouteObject["id"];
-    unstable_middleware?: AgnosticNonIndexRouteObject["unstable_middleware"];
-    loader?: AgnosticNonIndexRouteObject["loader"];
-    action?: AgnosticNonIndexRouteObject["action"];
-    hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];
-    shouldRevalidate?: AgnosticNonIndexRouteObject["shouldRevalidate"];
-    handle?: AgnosticNonIndexRouteObject["handle"];
-    index?: false;
-    children?: RouteObject[];
-    element?: React.ReactNode | null;
-    hydrateFallbackElement?: React.ReactNode | null;
-    errorElement?: React.ReactNode | null;
-    Component?: React.ComponentType | null;
-    HydrateFallback?: React.ComponentType | null;
-    ErrorBoundary?: React.ComponentType | null;
-    lazy?: LazyRouteDefinition<RouteObject>;
-}
-type RouteObject = IndexRouteObject | NonIndexRouteObject;
-type DataRouteObject = RouteObject & {
-    children?: DataRouteObject[];
-    id: string;
-};
-interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {
-}
-interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
-}
-type PatchRoutesOnNavigationFunctionArgs = AgnosticPatchRoutesOnNavigationFunctionArgs<RouteObject, RouteMatch>;
-type PatchRoutesOnNavigationFunction = AgnosticPatchRoutesOnNavigationFunction<RouteObject, RouteMatch>;
-interface DataRouterContextObject extends Omit<NavigationContextObject, "future"> {
-    router: Router$1;
-    staticContext?: StaticHandlerContext;
-    unstable_onError?: unstable_ClientOnErrorFunction;
-}
-declare const DataRouterContext: React.Context<DataRouterContextObject | null>;
-declare const DataRouterStateContext: React.Context<RouterState | null>;
-type ViewTransitionContextObject = {
-    isTransitioning: false;
-} | {
-    isTransitioning: true;
-    flushSync: boolean;
-    currentLocation: Location;
-    nextLocation: Location;
-};
-declare const ViewTransitionContext: React.Context<ViewTransitionContextObject>;
-type FetchersContextObject = Map<string, any>;
-declare const FetchersContext: React.Context<FetchersContextObject>;
-interface NavigateOptions {
-    /** Replace the current entry in the history stack instead of pushing a new one */
-    replace?: boolean;
-    /** Adds persistent client side routing state to the next location */
-    state?: any;
-    /** If you are using {@link https://api.reactrouter.com/v7/functions/react_router.ScrollRestoration.html <ScrollRestoration>}, prevent the scroll position from being reset to the top of the window when navigating */
-    preventScrollReset?: boolean;
-    /** Defines the relative path behavior for the link. "route" will use the route hierarchy so ".." will remove all URL segments of the current route pattern while "path" will use the URL path so ".." will remove one URL segment. */
-    relative?: RelativeRoutingType;
-    /** Wraps the initial state update for this navigation in a {@link https://react.dev/reference/react-dom/flushSync ReactDOM.flushSync} call instead of the default {@link https://react.dev/reference/react/startTransition React.startTransition} */
-    flushSync?: boolean;
-    /** Enables a {@link https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API View Transition} for this navigation by wrapping the final state update in `document.startViewTransition()`. If you need to apply specific styles for this view transition, you will also need to leverage the {@link https://api.reactrouter.com/v7/functions/react_router.useViewTransitionState.html useViewTransitionState()} hook.  */
-    viewTransition?: boolean;
-}
-/**
- * A Navigator is a "location changer"; it's how you get to different locations.
- *
- * Every history instance conforms to the Navigator interface, but the
- * distinction is useful primarily when it comes to the low-level `<Router>` API
- * where both the location and a navigator must be provided separately in order
- * to avoid "tearing" that may occur in a suspense-enabled app if the action
- * and/or location were to be read directly from the history instance.
- */
-interface Navigator {
-    createHref: History["createHref"];
-    encodeLocation?: History["encodeLocation"];
-    go: History["go"];
-    push(to: To, state?: any, opts?: NavigateOptions): void;
-    replace(to: To, state?: any, opts?: NavigateOptions): void;
-}
-interface NavigationContextObject {
-    basename: string;
-    navigator: Navigator;
-    static: boolean;
-    future: {};
-}
-declare const NavigationContext: React.Context<NavigationContextObject>;
-interface LocationContextObject {
-    location: Location;
-    navigationType: Action;
-}
-declare const LocationContext: React.Context<LocationContextObject>;
-interface RouteContextObject {
-    outlet: React.ReactElement | null;
-    matches: RouteMatch[];
-    isDataRoute: boolean;
-}
-declare const RouteContext: React.Context<RouteContextObject>;
-
 declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
     hasErrorBoundary: boolean;
 };
@@ -1716,13 +1603,13 @@ interface MemoryRouterOpts {
      */
     basename?: string;
     /**
-     * A function that returns an {@link unstable_RouterContextProvider} instance
+     * A function that returns an {@link RouterContextProvider} instance
      * which is provided as the `context` argument to client [`action`](../../start/data/route-object#action)s,
      * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
      * This function is called to generate a fresh `context` instance on each
      * navigation or fetcher call.
      */
-    unstable_getContext?: RouterInit["unstable_getContext"];
+    getContext?: RouterInit["getContext"];
     /**
      * Future flags to enable for the router.
      */
@@ -1763,7 +1650,7 @@ interface MemoryRouterOpts {
  * @param {MemoryRouterOpts.basename} opts.basename n/a
  * @param {MemoryRouterOpts.dataStrategy} opts.dataStrategy n/a
  * @param {MemoryRouterOpts.future} opts.future n/a
- * @param {MemoryRouterOpts.unstable_getContext} opts.unstable_getContext n/a
+ * @param {MemoryRouterOpts.getContext} opts.getContext n/a
  * @param {MemoryRouterOpts.hydrationData} opts.hydrationData n/a
  * @param {MemoryRouterOpts.initialEntries} opts.initialEntries n/a
  * @param {MemoryRouterOpts.initialIndex} opts.initialIndex n/a
@@ -2539,6 +2426,126 @@ declare function withErrorBoundaryProps(ErrorBoundary: ErrorBoundaryType): () =>
     error: unknown;
 }, string | React.JSXElementConstructor<any>>;
 
+interface IndexRouteObject {
+    caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
+    path?: AgnosticIndexRouteObject["path"];
+    id?: AgnosticIndexRouteObject["id"];
+    middleware?: AgnosticIndexRouteObject["middleware"];
+    loader?: AgnosticIndexRouteObject["loader"];
+    action?: AgnosticIndexRouteObject["action"];
+    hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: AgnosticIndexRouteObject["shouldRevalidate"];
+    handle?: AgnosticIndexRouteObject["handle"];
+    index: true;
+    children?: undefined;
+    element?: React.ReactNode | null;
+    hydrateFallbackElement?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    Component?: React.ComponentType | null;
+    HydrateFallback?: React.ComponentType | null;
+    ErrorBoundary?: React.ComponentType | null;
+    lazy?: LazyRouteDefinition<RouteObject>;
+}
+interface NonIndexRouteObject {
+    caseSensitive?: AgnosticNonIndexRouteObject["caseSensitive"];
+    path?: AgnosticNonIndexRouteObject["path"];
+    id?: AgnosticNonIndexRouteObject["id"];
+    middleware?: AgnosticNonIndexRouteObject["middleware"];
+    loader?: AgnosticNonIndexRouteObject["loader"];
+    action?: AgnosticNonIndexRouteObject["action"];
+    hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: AgnosticNonIndexRouteObject["shouldRevalidate"];
+    handle?: AgnosticNonIndexRouteObject["handle"];
+    index?: false;
+    children?: RouteObject[];
+    element?: React.ReactNode | null;
+    hydrateFallbackElement?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    Component?: React.ComponentType | null;
+    HydrateFallback?: React.ComponentType | null;
+    ErrorBoundary?: React.ComponentType | null;
+    lazy?: LazyRouteDefinition<RouteObject>;
+}
+type RouteObject = IndexRouteObject | NonIndexRouteObject;
+type DataRouteObject = RouteObject & {
+    children?: DataRouteObject[];
+    id: string;
+};
+interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {
+}
+interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
+}
+type PatchRoutesOnNavigationFunctionArgs = AgnosticPatchRoutesOnNavigationFunctionArgs<RouteObject, RouteMatch>;
+type PatchRoutesOnNavigationFunction = AgnosticPatchRoutesOnNavigationFunction<RouteObject, RouteMatch>;
+interface DataRouterContextObject extends Omit<NavigationContextObject, "future"> {
+    router: Router$1;
+    staticContext?: StaticHandlerContext;
+    unstable_onError?: unstable_ClientOnErrorFunction;
+}
+declare const DataRouterContext: React.Context<DataRouterContextObject | null>;
+declare const DataRouterStateContext: React.Context<RouterState | null>;
+type ViewTransitionContextObject = {
+    isTransitioning: false;
+} | {
+    isTransitioning: true;
+    flushSync: boolean;
+    currentLocation: Location;
+    nextLocation: Location;
+};
+declare const ViewTransitionContext: React.Context<ViewTransitionContextObject>;
+type FetchersContextObject = Map<string, any>;
+declare const FetchersContext: React.Context<FetchersContextObject>;
+declare const AwaitContext: React.Context<TrackedPromise | null>;
+declare const AwaitContextProvider: (props: React.ComponentProps<typeof AwaitContext.Provider>) => React.FunctionComponentElement<React.ProviderProps<TrackedPromise | null>>;
+interface NavigateOptions {
+    /** Replace the current entry in the history stack instead of pushing a new one */
+    replace?: boolean;
+    /** Adds persistent client side routing state to the next location */
+    state?: any;
+    /** If you are using {@link https://api.reactrouter.com/v7/functions/react_router.ScrollRestoration.html <ScrollRestoration>}, prevent the scroll position from being reset to the top of the window when navigating */
+    preventScrollReset?: boolean;
+    /** Defines the relative path behavior for the link. "route" will use the route hierarchy so ".." will remove all URL segments of the current route pattern while "path" will use the URL path so ".." will remove one URL segment. */
+    relative?: RelativeRoutingType;
+    /** Wraps the initial state update for this navigation in a {@link https://react.dev/reference/react-dom/flushSync ReactDOM.flushSync} call instead of the default {@link https://react.dev/reference/react/startTransition React.startTransition} */
+    flushSync?: boolean;
+    /** Enables a {@link https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API View Transition} for this navigation by wrapping the final state update in `document.startViewTransition()`. If you need to apply specific styles for this view transition, you will also need to leverage the {@link https://api.reactrouter.com/v7/functions/react_router.useViewTransitionState.html useViewTransitionState()} hook.  */
+    viewTransition?: boolean;
+}
+/**
+ * A Navigator is a "location changer"; it's how you get to different locations.
+ *
+ * Every history instance conforms to the Navigator interface, but the
+ * distinction is useful primarily when it comes to the low-level `<Router>` API
+ * where both the location and a navigator must be provided separately in order
+ * to avoid "tearing" that may occur in a suspense-enabled app if the action
+ * and/or location were to be read directly from the history instance.
+ */
+interface Navigator {
+    createHref: History["createHref"];
+    encodeLocation?: History["encodeLocation"];
+    go: History["go"];
+    push(to: To, state?: any, opts?: NavigateOptions): void;
+    replace(to: To, state?: any, opts?: NavigateOptions): void;
+}
+interface NavigationContextObject {
+    basename: string;
+    navigator: Navigator;
+    static: boolean;
+    future: {};
+}
+declare const NavigationContext: React.Context<NavigationContextObject>;
+interface LocationContextObject {
+    location: Location;
+    navigationType: Action;
+}
+declare const LocationContext: React.Context<LocationContextObject>;
+interface RouteContextObject {
+    outlet: React.ReactElement | null;
+    matches: RouteMatch[];
+    isDataRoute: boolean;
+}
+declare const RouteContext: React.Context<RouteContextObject>;
+
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 interface HtmlLinkProps {
@@ -2735,14 +2742,14 @@ type ClientDataFunctionArgs<Params> = {
      **/
     params: Params;
     /**
-     * When `future.unstable_middleware` is not enabled, this is undefined.
+     * When `future.v8_middleware` is not enabled, this is undefined.
      *
-     * When `future.unstable_middleware` is enabled, this is an instance of
-     * `unstable_RouterContextProvider` and can be used to access context values
+     * When `future.v8_middleware` is enabled, this is an instance of
+     * `RouterContextProvider` and can be used to access context values
      * from your route middlewares.  You may pass in initial context values in your
-     * `<HydratedRouter unstable_getContext>` prop
+     * `<HydratedRouter getContext>` prop
      */
-    context: Readonly<unstable_RouterContextProvider>;
+    context: Readonly<RouterContextProvider>;
 };
 type ServerDataFunctionArgs<Params> = {
     /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the url, method, headers (such as cookies), and request body from the request. */
@@ -2763,18 +2770,18 @@ type ServerDataFunctionArgs<Params> = {
      **/
     params: Params;
     /**
-     * Without `future.unstable_middleware` enabled, this is the context passed in
+     * Without `future.v8_middleware` enabled, this is the context passed in
      * to your server adapter's `getLoadContext` function. It's a way to bridge the
      * gap between the adapter's request/response API with your React Router app.
      * It is only applicable if you are using a custom server adapter.
      *
-     * With `future.unstable_middleware` enabled, this is an instance of
-     * `unstable_RouterContextProvider` and can be used for type-safe access to
+     * With `future.v8_middleware` enabled, this is an instance of
+     * `RouterContextProvider` and can be used for type-safe access to
      * context value set in your route middlewares.  If you are using a custom
      * server adapter, you may provide an initial set of context values from your
      * `getLoadContext` function.
      */
-    context: MiddlewareEnabled extends true ? Readonly<unstable_RouterContextProvider> : AppLoadContext;
+    context: MiddlewareEnabled extends true ? Readonly<RouterContextProvider> : AppLoadContext;
 };
 type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
     ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
@@ -2810,7 +2817,7 @@ interface RouteModules {
 interface RouteModule {
     clientAction?: ClientActionFunction;
     clientLoader?: ClientLoaderFunction;
-    unstable_clientMiddleware?: unstable_MiddlewareFunction<Record<string, DataStrategyResult>>[];
+    clientMiddleware?: MiddlewareFunction<Record<string, DataStrategyResult>>[];
     ErrorBoundary?: ErrorBoundaryComponent;
     HydrateFallback?: HydrateFallbackComponent;
     Layout?: LayoutComponent;
@@ -2829,7 +2836,7 @@ interface ServerRouteModule extends RouteModule {
         [name: string]: string;
     };
     loader?: LoaderFunction;
-    unstable_middleware?: unstable_MiddlewareFunction<Response>[];
+    middleware?: MiddlewareFunction<Response>[];
 }
 /**
  * A function that handles data mutations for a route on the client
@@ -3008,4 +3015,4 @@ type RouteComponent = ComponentType<{}>;
  */
 type RouteHandle = unknown;
 
-export { type PatchRoutesOnNavigationFunction as $, Action as A, type BlockerFunction as B, type ClientDataFunctionArgs as C, type DataStrategyResult as D, type ErrorBoundaryType as E, type Func as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type AppLoadContext as J, unstable_RouterContextProvider as K, type LinkDescriptor as L, type MetaDescriptor as M, type Normalize as N, type MiddlewareEnabled as O, type Pretty as P, type Equal as Q, type RouteModule$1 as R, type ServerDataFunctionArgs as S, type To as T, type UIMatch as U, type ClientActionFunction as V, type ClientLoaderFunction as W, type HeadersFunction as X, type ShouldRevalidateFunction as Y, type RouterInit as Z, type RouterState as _, type Location as a, Router as a$, type DataRouteObject as a0, type StaticHandler as a1, type GetScrollPositionFunction as a2, type GetScrollRestorationKeyFunction as a3, type StaticHandlerContext as a4, type Fetcher as a5, type NavigationStates as a6, type RouterSubscriber as a7, type RouterNavigateOptions as a8, type RouterFetchOptions as a9, matchRoutes as aA, redirect as aB, redirectDocument as aC, replace as aD, resolvePath as aE, type DataRouteMatch as aF, type Navigator as aG, type PatchRoutesOnNavigationFunctionArgs as aH, type RouteMatch as aI, type AwaitProps as aJ, type IndexRouteProps as aK, type unstable_ClientOnErrorFunction as aL, type LayoutRouteProps as aM, type MemoryRouterOpts as aN, type MemoryRouterProps as aO, type NavigateProps as aP, type OutletProps as aQ, type PathRouteProps as aR, type RouteProps as aS, type RouterProps as aT, type RouterProviderProps as aU, type RoutesProps as aV, Await as aW, MemoryRouter as aX, Navigate as aY, Outlet as aZ, Route as a_, type RevalidationState as aa, type ActionFunctionArgs as ab, type DataStrategyFunctionArgs as ac, type DataStrategyMatch as ad, DataWithResponseInit as ae, type ErrorResponse as af, type FormEncType as ag, type FormMethod as ah, type HTMLFormMethod as ai, type LazyRouteFunction as aj, type LoaderFunctionArgs as ak, type unstable_MiddlewareFunction as al, type PathParam as am, type RedirectFunction as an, type unstable_RouterContext as ao, type ShouldRevalidateFunctionArgs as ap, unstable_createContext as aq, createPath as ar, parsePath as as, IDLE_NAVIGATION as at, IDLE_FETCHER as au, IDLE_BLOCKER as av, data as aw, generatePath as ax, isRouteErrorResponse as ay, matchPath as az, type ServerDataFrom as b, RouterProvider as b0, Routes as b1, createMemoryRouter as b2, createRoutesFromChildren as b3, createRoutesFromElements as b4, renderMatches as b5, type ClientActionFunctionArgs as b6, type ClientLoaderFunctionArgs as b7, type HeadersArgs as b8, type MetaArgs as b9, type FutureConfig as bA, type CreateStaticHandlerOptions as bB, type PageLinkDescriptor as ba, type HtmlLinkDescriptor as bb, type Future as bc, type unstable_SerializesTo as bd, createBrowserHistory as be, invariant as bf, createRouter as bg, ErrorResponseImpl as bh, DataRouterContext as bi, DataRouterStateContext as bj, FetchersContext as bk, LocationContext as bl, NavigationContext as bm, RouteContext as bn, ViewTransitionContext as bo, hydrationRouteProperties as bp, mapRouteProperties as bq, WithComponentProps as br, withComponentProps as bs, WithHydrateFallbackProps as bt, withHydrateFallbackProps as bu, WithErrorBoundaryProps as bv, withErrorBoundaryProps as bw, type RouteManifest as bx, type ServerRouteModule as by, type History as bz, type GetActionData as c, type Router$1 as d, type RouteModules as e, type DataStrategyFunction as f, type NavigateOptions as g, type Blocker as h, type SerializeFrom as i, type RelativeRoutingType as j, type ParamParseKey as k, type Path as l, type PathPattern as m, type PathMatch as n, type Navigation as o, type Params as p, type RouteObject as q, type IndexRouteObject as r, type RouteComponentType as s, type HydrateFallbackType as t, type unstable_MiddlewareNextFunction as u, type LoaderFunction as v, type ActionFunction as w, type MetaFunction as x, type LinksFunction as y, type NonIndexRouteObject as z };
+export { type PatchRoutesOnNavigationFunction as $, Action as A, type BlockerFunction as B, type ClientDataFunctionArgs as C, type DataStrategyResult as D, type ErrorBoundaryType as E, type Func as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type AppLoadContext as J, RouterContextProvider as K, type LinkDescriptor as L, type MetaDescriptor as M, type Normalize as N, type MiddlewareEnabled as O, type Pretty as P, type Equal as Q, type RouteModule$1 as R, type ServerDataFunctionArgs as S, type To as T, type UIMatch as U, type ClientActionFunction as V, type ClientLoaderFunction as W, type HeadersFunction as X, type ShouldRevalidateFunction as Y, type RouterInit as Z, type RouterState as _, type Location as a, Route as a$, type DataRouteObject as a0, type StaticHandler as a1, type GetScrollPositionFunction as a2, type GetScrollRestorationKeyFunction as a3, type StaticHandlerContext as a4, type Fetcher as a5, type NavigationStates as a6, type RouterSubscriber as a7, type RouterNavigateOptions as a8, type RouterFetchOptions as a9, matchRoutes as aA, redirect as aB, redirectDocument as aC, replace as aD, resolvePath as aE, type DataRouteMatch as aF, type Navigator as aG, type PatchRoutesOnNavigationFunctionArgs as aH, type RouteMatch as aI, AwaitContextProvider as aJ, type AwaitProps as aK, type IndexRouteProps as aL, type unstable_ClientOnErrorFunction as aM, type LayoutRouteProps as aN, type MemoryRouterOpts as aO, type MemoryRouterProps as aP, type NavigateProps as aQ, type OutletProps as aR, type PathRouteProps as aS, type RouteProps as aT, type RouterProps as aU, type RouterProviderProps as aV, type RoutesProps as aW, Await as aX, MemoryRouter as aY, Navigate as aZ, Outlet as a_, type RevalidationState as aa, type ActionFunctionArgs as ab, type DataStrategyFunctionArgs as ac, type DataStrategyMatch as ad, DataWithResponseInit as ae, type ErrorResponse as af, type FormEncType as ag, type FormMethod as ah, type HTMLFormMethod as ai, type LazyRouteFunction as aj, type LoaderFunctionArgs as ak, type MiddlewareFunction as al, type PathParam as am, type RedirectFunction as an, type RouterContext as ao, type ShouldRevalidateFunctionArgs as ap, createContext as aq, createPath as ar, parsePath as as, IDLE_NAVIGATION as at, IDLE_FETCHER as au, IDLE_BLOCKER as av, data as aw, generatePath as ax, isRouteErrorResponse as ay, matchPath as az, type MiddlewareNextFunction as b, Router as b0, RouterProvider as b1, Routes as b2, createMemoryRouter as b3, createRoutesFromChildren as b4, createRoutesFromElements as b5, renderMatches as b6, type ClientActionFunctionArgs as b7, type ClientLoaderFunctionArgs as b8, type HeadersArgs as b9, type History as bA, type FutureConfig as bB, type CreateStaticHandlerOptions as bC, type MetaArgs as ba, type PageLinkDescriptor as bb, type HtmlLinkDescriptor as bc, type Future as bd, type unstable_SerializesTo as be, createBrowserHistory as bf, invariant as bg, createRouter as bh, ErrorResponseImpl as bi, DataRouterContext as bj, DataRouterStateContext as bk, FetchersContext as bl, LocationContext as bm, NavigationContext as bn, RouteContext as bo, ViewTransitionContext as bp, hydrationRouteProperties as bq, mapRouteProperties as br, WithComponentProps as bs, withComponentProps as bt, WithHydrateFallbackProps as bu, withHydrateFallbackProps as bv, WithErrorBoundaryProps as bw, withErrorBoundaryProps as bx, type RouteManifest as by, type ServerRouteModule as bz, type ServerDataFrom as c, type GetActionData as d, type Router$1 as e, type RouteModules as f, type DataStrategyFunction as g, type NavigateOptions as h, type Blocker as i, type SerializeFrom as j, type RelativeRoutingType as k, type ParamParseKey as l, type Path as m, type PathPattern as n, type PathMatch as o, type Navigation as p, type Params as q, type RouteObject as r, type IndexRouteObject as s, type RouteComponentType as t, type HydrateFallbackType as u, type LoaderFunction as v, type ActionFunction as w, type MetaFunction as x, type LinksFunction as y, type NonIndexRouteObject as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-router",
-  "version": "7.8.2",
+  "version": "7.9.0-pre.0",
   "description": "Declarative routing for React",
   "keywords": [
     "react",