react-router 7.7.1 → 7.8.0-pre.1

package/dist/{development/routeModules-BR2FO0ix.d.ts → production/routeModules-qBivMBjd.d.ts}

@@ -271,35 +271,122 @@ type Submission = {
     json: undefined;
     text: string;
 };
+/**
+ * A context instance used as the key for the `get`/`set` methods of a
+ * {@link unstable_RouterContextProvider}. Accepts an optional default
+ * value to be returned if no value has been set.
+ */
 interface unstable_RouterContext<T = unknown> {
     defaultValue?: T;
 }
 /**
- * Creates a context object that may be used to store and retrieve arbitrary values.
+ * Creates a type-safe {@link unstable_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),
+ * but specifically designed for React Router's request/response lifecycle.
+ *
+ * If a `defaultValue` is provided, it will be returned from `context.get()`
+ * when no value has been set for the context. Otherwise, reading this context
+ * when no value has been set will throw an error.
+ *
+ * ```tsx filename=app/context.ts
+ * import { unstable_createContext } from "react-router";
+ *
+ * // Create a context for user data
+ * export const userContext =
+ *   unstable_createContext<User | null>(null);
+ * ```
+ *
+ * ```tsx filename=app/middleware/auth.ts
+ * import { getUserFromSession } from "~/auth.server";
+ * import { userContext } from "~/context";
+ *
+ * export const authMiddleware = async ({
+ *   context,
+ *   request,
+ * }) => {
+ *   const user = await getUserFromSession(request);
+ *   context.set(userContext, user);
+ * };
+ * ```
  *
- * If a `defaultValue` is provided, it will be returned from `context.get()` when no value has been
- * set for the context. Otherwise reading this context when no value has been set will throw an
- * error.
+ * ```tsx filename=app/routes/profile.tsx
+ * import { userContext } from "~/context";
  *
- * @param defaultValue The default value for the context
- * @returns A context object
+ * export async function loader({
+ *   context,
+ * }: Route.LoaderArgs) {
+ *   const user = context.get(userContext);
+ *
+ *   if (!user) {
+ *     throw new Response("Unauthorized", { status: 401 });
+ *   }
+ *
+ *   return { user };
+ * }
+ * ```
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @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
+ * `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>;
 /**
- * A Map of RouterContext objects to their initial values - used to populate a
- * fresh `context` value per request/navigation/fetch
- */
-type unstable_InitialContext = Map<unstable_RouterContext, unknown>;
-/**
- * Provides methods for writing/reading values in application context in a typesafe way.
+ * 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
+ * } from "react-router";
+ *
+ * const userContext = unstable_createContext<User | null>(null);
+ * const contextProvider = new unstable_RouterContextProvider();
+ * contextProvider.set(userContext, getUser());
+ * //                               ^ Type-safe
+ * const user = contextProvider.get(userContext);
+ * //    ^ User
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
  */
 declare class unstable_RouterContextProvider {
     #private;
-    constructor(init?: unstable_InitialContext);
+    /**
+     * Create a new `unstable_RouterContextProvider` instance
+     * @param init An optional initial context map to populate the provider with
+     */
+    constructor(init?: Map<unstable_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
+     * if no `defaultValue` was set.
+     * @param context The context to get the value for
+     * @returns The value for the context, or the context's `defaultValue` if no
+     * value was set
+     */
     get<T>(context: unstable_RouterContext<T>): T;
+    /**
+     * Set a value for the context. If the context already has a value set, this
+     * will overwrite it.
+     *
+     * @param context The context to set the value for
+     * @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;
 }
-type DefaultContext = MiddlewareEnabled extends true ? unstable_RouterContextProvider : any;
+type DefaultContext = MiddlewareEnabled extends true ? Readonly<unstable_RouterContextProvider> : any;
 /**
  * @private
  * Arguments passed to route loader/action functions.  Same for now but we keep
@@ -321,7 +408,7 @@ interface DataFunctionArgs<Context> {
      *   params.teamId;
      *   //        ^ string
      * }
-     **/
+     */
     params: Params;
     /**
      * This is the context passed in to your server adapter's getLoadContext() function.
@@ -335,7 +422,7 @@ interface DataFunctionArgs<Context> {
  * middlewares from the bottom-up
  */
 interface unstable_MiddlewareNextFunction<Result = unknown> {
-    (): MaybePromise<Result>;
+    (): Promise<Result>;
 }
 /**
  * Route middleware function signature.  Receives the same "data" arguments as a
@@ -343,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<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
+type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<Readonly<unstable_RouterContextProvider>>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
 /**
  * Arguments passed to loader functions
  */
@@ -449,34 +536,39 @@ interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRoute
         route: Promise<void> | undefined;
     };
     /**
-     * A boolean value indicating whether this route handler should be called in this pass.
+     * A boolean value indicating whether this route handler should be called in
+     * this pass.
      *
-     * The `matches` array always includes _all_ matched routes even when only _some_
-     * route handlers need to be called so that things like middleware can be implemented.
+     * The `matches` array always includes _all_ matched routes even when only
+     * _some_ route handlers need to be called so that things like middleware can
+     * be implemented.
      *
-     * `shouldLoad` is usually only interesting if you are skipping the route handler
-     * entirely and implementing custom handler logic - since it lets you determine
-     * if that custom logic should run for this route or not.
+     * `shouldLoad` is usually only interesting if you are skipping the route
+     * handler entirely and implementing custom handler logic - since it lets you
+     * determine if that custom logic should run for this route or not.
      *
      * For example:
      *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
      *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
      *    will have `shouldLoad=true` because the data for `parent` and `child` is
      *    already loaded
-     *  - If you are on `/parent/child/a` and you submit to `a`'s `action`, then only
-     *    `a` will have `shouldLoad=true` for the action execution of `dataStrategy`
-     *  - After the `action`, `dataStrategy` will be called again for the `loader`
-     *    revalidation, and all matches will have `shouldLoad=true` (assuming no custom
-     *   `shouldRevalidate` implementations)
+     *  - If you are on `/parent/child/a` and you submit to `a`'s [`action`](https://reactrouter.com/docs/start/data/route-object#action),
+     *    then only `a` will have `shouldLoad=true` for the action execution of
+     *    `dataStrategy`
+     *  - After the [`action`](https://reactrouter.com/docs/start/data/route-object#action),
+     *    `dataStrategy` will be called again for the [`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
+     *    revalidation, and all matches will have `shouldLoad=true` (assuming no
+     *    custom `shouldRevalidate` implementations)
      */
     shouldLoad: boolean;
     unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
     unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
     /**
      * An async function that will resolve any `route.lazy` implementations and
-     * execute the route's handler (if necessary), returning a `DataStrategyResult`
+     * execute the route's handler (if necessary), returning a {@link DataStrategyResult}
      *
-     * - Calling `match.resolve` does not mean you're calling the `loader`/`action`
+     * - Calling `match.resolve` does not mean you're calling the
+     *   [`action`](https://reactrouter.com/docs/start/data/route-object#action)/[`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
      *   (the "handler") - `resolve` will only call the `handler` internally if
      *   needed _and_ if you don't pass your own `handlerOverride` function parameter
      * - It is safe to call `match.resolve` for all matches, even if they have
@@ -643,7 +735,28 @@ interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticData
 /**
  * Matches the given routes to a location and returns the match data.
  *
+ * @example
+ * import { matchRoutes } from "react-router";
+ *
+ * let routes = [{
+ *   path: "/",
+ *   Component: Root,
+ *   children: [{
+ *     path: "dashboard",
+ *     Component: Dashboard,
+ *   }]
+ * }];
+ *
+ * matchRoutes(routes, "/dashboard"); // [rootMatch, dashboardMatch]
+ *
+ * @public
  * @category Utils
+ * @param routes The array of route objects to match against.
+ * @param locationArg The location to match against, either a string path or a
+ * partial {@link Location} object
+ * @param basename Optional base path to strip from the location before matching.
+ * Defaults to `/`.
+ * @returns An array of matched routes, or `null` if no matches were found.
  */
 declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
 interface UIMatch<Data = unknown, Handle = unknown> {
@@ -651,29 +764,53 @@ interface UIMatch<Data = unknown, Handle = unknown> {
     pathname: string;
     /**
      * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the matched route.
-     **/
+     */
     params: AgnosticRouteMatch["params"];
-    /** The return value from the matched route's loader or clientLoader */
-    data: Data;
-    /** The {@link https://reactrouter.com/start/framework/route-module#handle handle object} exported from the matched route module */
+    /**
+     * The return value from the matched route's loader or clientLoader. This might
+     * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
+     * an error and we're currently displaying an `ErrorBoundary`.
+     *
+     * @deprecated Use `UIMatch.loaderData` instead
+     */
+    data: Data | undefined;
+    /**
+     * The return value from the matched route's loader or clientLoader. This might
+     * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
+     * an error and we're currently displaying an `ErrorBoundary`.
+     */
+    loaderData: Data | undefined;
+    /**
+     * The {@link https://reactrouter.com/start/framework/route-module#handle handle object}
+     * exported from the matched route module
+     */
     handle: Handle;
 }
 /**
  * Returns a path with params interpolated.
  *
+ * @example
+ * import { generatePath } from "react-router";
+ *
+ * generatePath("/users/:id", { id: "123" }); // "/users/123"
+ *
+ * @public
  * @category Utils
+ * @param originalPath The original path to generate.
+ * @param params The parameters to interpolate into the path.
+ * @returns The generated path with parameters interpolated.
  */
 declare function generatePath<Path extends string>(originalPath: Path, params?: {
     [key in PathParam<Path>]: string | null;
 }): string;
 /**
- * A PathPattern is used to match on some portion of a URL pathname.
+ * Used to match on some portion of a URL pathname.
  */
 interface PathPattern<Path extends string = string> {
     /**
      * A string to match against a URL pathname. May contain `:id`-style segments
-     * to indicate placeholders for dynamic parameters. May also end with `/*` to
-     * indicate matching the rest of the URL pathname.
+     * to indicate placeholders for dynamic parameters. It May also end with `/*`
+     * to indicate matching the rest of the URL pathname.
      */
     path: Path;
     /**
@@ -687,7 +824,7 @@ interface PathPattern<Path extends string = string> {
     end?: boolean;
 }
 /**
- * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+ * Contains info about how a {@link PathPattern} matched on a URL pathname.
  */
 interface PathMatch<ParamKey extends string = string> {
     /**
@@ -711,13 +848,26 @@ interface PathMatch<ParamKey extends string = string> {
  * Performs pattern matching on a URL pathname and returns information about
  * the match.
  *
+ * @public
  * @category Utils
+ * @param pattern The pattern to match against the URL pathname. This can be a
+ * string or a {@link PathPattern} object. If a string is provided, it will be
+ * treated as a pattern with `caseSensitive` set to `false` and `end` set to
+ * `true`.
+ * @param pathname The URL pathname to match against the pattern.
+ * @returns A path match object if the pattern matches the pathname,
+ * or `null` if it does not match.
  */
 declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
 /**
- * Returns a resolved path object relative to the given pathname.
+ * Returns a resolved {@link Path} object relative to the given pathname.
  *
+ * @public
  * @category Utils
+ * @param to The path to resolve, either a string or a partial {@link Path}
+ * object.
+ * @param fromPathname The pathname to resolve the path from. Defaults to `/`.
+ * @returns A {@link Path} object with the resolved pathname, search, and hash.
  */
 declare function resolvePath(to: To, fromPathname?: string): Path;
 declare class DataWithResponseInit<D> {
@@ -727,35 +877,116 @@ declare class DataWithResponseInit<D> {
     constructor(data: D, init?: ResponseInit);
 }
 /**
- * Create "responses" that contain `status`/`headers` without forcing
- * serialization into an actual `Response` - used by Remix single fetch
+ * Create "responses" that contain `headers`/`status` without forcing
+ * serialization into an actual [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
  *
+ * @example
+ * import { data } from "react-router";
+ *
+ * export async function action({ request }: Route.ActionArgs) {
+ *   let formData = await request.formData();
+ *   let item = await createItem(formData);
+ *   return data(item, {
+ *     headers: { "X-Custom-Header": "value" }
+ *     status: 201,
+ *   });
+ * }
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param data The data to be included in the response.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A {@link DataWithResponseInit} instance containing the data and
+ * response init.
  */
 declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
 type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
 /**
- * A redirect response. Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
+ * Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
+ *
+ * @example
+ * import { redirect } from "react-router";
+ *
+ * export async function loader({ request }: Route.LoaderArgs) {
+ *   if (!isLoggedIn(request))
+ *     throw redirect("/login");
+ *   }
  *
+ *   // ...
+ * }
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param url The URL to redirect to.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header.
  */
 declare const redirect: RedirectFunction;
 /**
- * A redirect response that will force a document reload to the new location.
- * Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * that will force a document reload to the new location. Sets the status code
+ * and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
+ *
+ * ```tsx filename=routes/logout.tsx
+ * import { redirectDocument } from "react-router";
+ *
+ * import { destroySession } from "../sessions.server";
  *
+ * export async function action({ request }: Route.ActionArgs) {
+ *   let session = await getSession(request.headers.get("Cookie"));
+ *   return redirectDocument("/", {
+ *     headers: { "Set-Cookie": await destroySession(session) }
+ *   });
+ * }
+ * ```
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param url The URL to redirect to.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header.
  */
 declare const redirectDocument: RedirectFunction;
 /**
- * A redirect response that will perform a `history.replaceState` instead of a
- * `history.pushState` for client-side navigation redirects.
- * Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * that will perform a [`history.replaceState`](https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState)
+ * instead of a [`history.pushState`](https://developer.mozilla.org/en-US/docs/Web/API/History/pushState)
+ * for client-side navigation redirects. Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
  *
+ * @example
+ * import { replace } from "react-router";
+ *
+ * export async function loader() {
+ *   return replace("/new-location");
+ * }
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param url The URL to redirect to.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header.
  */
 declare const replace: RedirectFunction;
 type ErrorResponse = {
@@ -763,14 +994,6 @@ type ErrorResponse = {
     statusText: string;
     data: any;
 };
-/**
- * @private
- * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
- *
- * We don't export the class for public use since it's an implementation
- * detail, but we export the interface above so folks can build their own
- * abstractions around instances via isRouteErrorResponse()
- */
 declare class ErrorResponseImpl implements ErrorResponse {
     status: number;
     statusText: string;
@@ -780,10 +1003,35 @@ declare class ErrorResponseImpl implements ErrorResponse {
     constructor(status: number, statusText: string | undefined, data: any, internal?: boolean);
 }
 /**
- * Check if the given error is an ErrorResponse generated from a 4xx/5xx
- * Response thrown from an action/loader
+ * Check if the given error is an {@link ErrorResponse} generated from a 4xx/5xx
+ * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * thrown from an [`action`](../../start/framework/route-module#action)/[`loader`](../../start/framework/route-module#loader)
+ *
+ * @example
+ * import { isRouteErrorResponse } from "react-router";
+ *
+ * export function ErrorBoundary({ error }: Route.ErrorBoundaryProps) {
+ *   if (isRouteErrorResponse(error)) {
+ *     return (
+ *       <>
+ *         <p>Error: `${error.status}: ${error.statusText}`</p>
+ *         <p>{error.data}</p>
+ *       </>
+ *     );
+ *   }
+ *
+ *   return (
+ *     <p>Error: {error instanceof Error ? error.message : "Unknown Error"}</p>
+ *   );
+ * }
  *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param error The error to check.
+ * @returns `true` if the error is an {@link ErrorResponse}, `false` otherwise.
+ *
  */
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 
@@ -1061,7 +1309,7 @@ interface RouterInit {
     routes: AgnosticRouteObject[];
     history: History;
     basename?: string;
-    unstable_getContext?: () => MaybePromise<unstable_InitialContext>;
+    unstable_getContext?: () => MaybePromise<unstable_RouterContextProvider>;
     mapRouteProperties?: MapRoutePropertiesFunction;
     future?: Partial<FutureConfig>;
     hydrationRouteProperties?: string[];
@@ -1096,14 +1344,13 @@ interface StaticHandler {
         skipLoaderErrorBubbling?: boolean;
         skipRevalidation?: boolean;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_respond?: (staticContext: StaticHandlerContext) => MaybePromise<Response>;
-        unstable_stream?: (context: unstable_RouterContextProvider, query: (r: Request) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
+        unstable_generateMiddlewareResponse?: (query: (r: Request) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
     }): Promise<StaticHandlerContext | Response>;
     queryRoute(request: Request, opts?: {
         routeId?: string;
         requestContext?: unknown;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_respond?: (res: Response) => MaybePromise<Response>;
+        unstable_generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>;
     }): Promise<any>;
 }
 type ViewTransitionOpts = {
@@ -1552,7 +1799,13 @@ type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">
 });
 interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
     /**
-     * The absolute path of the page to prefetch.
+     * A [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
+     * attribute to render on the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
+     * element
+     */
+    nonce?: string | undefined;
+    /**
+     * The absolute path of the page to prefetch, e.g. `/absolute/path`.
      */
     page: string;
 }
@@ -1651,7 +1904,7 @@ type ClientDataFunctionArgs<Params> = {
      * from your route middlewares.  You may pass in initial context values in your
      * `<HydratedRouter unstable_getContext>` prop
      */
-    context: unstable_RouterContextProvider;
+    context: Readonly<unstable_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. */
@@ -1683,7 +1936,7 @@ type ServerDataFunctionArgs<Params> = {
      * server adapter, you may provide an initial set of context values from your
      * `getLoadContext` function.
      */
-    context: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext;
+    context: MiddlewareEnabled extends true ? Readonly<unstable_RouterContextProvider> : AppLoadContext;
 };
 type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
     ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
@@ -1804,7 +2057,9 @@ interface LinksFunction {
 interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
     id: RouteId;
     pathname: DataRouteMatch["pathname"];
+    /** @deprecated Use `MetaMatch.loaderData` instead */
     data: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
+    loaderData: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
     handle?: RouteHandle;
     params: DataRouteMatch["params"];
     meta: MetaDescriptor[];
@@ -1814,7 +2069,9 @@ type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoad
     [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
 }[keyof MatchLoaders]>;
 interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
+    /** @deprecated Use `MetaArgs.loaderData` instead */
     data: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
+    loaderData: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
     params: Params;
     location: Location;
     matches: MetaMatches<MatchLoaders>;
@@ -1913,4 +2170,4 @@ type RouteComponent = ComponentType<{}>;
  */
 type RouteHandle = unknown;
 
-export { type GetScrollRestorationKeyFunction as $, Action as A, type BlockerFunction as B, type ClientDataFunctionArgs as C, type DataStrategyFunction as D, type unstable_InitialContext as E, type Equal as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type ClientActionFunction as J, type ClientLoaderFunction as K, type LinkDescriptor as L, type MetaDescriptor as M, type Normalize as N, type HeadersFunction as O, type Pretty as P, type ShouldRevalidateFunction as Q, type RouteModule$1 as R, type ServerDataFunctionArgs as S, type To as T, type UIMatch as U, type RouterInit as V, type RouterState as W, type PatchRoutesOnNavigationFunction as X, type DataRouteObject as Y, type StaticHandler as Z, type GetScrollPositionFunction as _, type Location as a, type ServerRouteModule as a$, type StaticHandlerContext as a0, type Fetcher as a1, type NavigationStates as a2, type RouterSubscriber as a3, type RouterNavigateOptions as a4, type RouterFetchOptions as a5, type RevalidationState as a6, type ActionFunctionArgs as a7, type DataStrategyFunctionArgs as a8, type DataStrategyMatch as a9, replace as aA, resolvePath as aB, type DataRouteMatch as aC, type Navigator as aD, type PatchRoutesOnNavigationFunctionArgs as aE, type RouteMatch as aF, type ClientActionFunctionArgs as aG, type ClientLoaderFunctionArgs as aH, type HeadersArgs as aI, type MetaArgs as aJ, type PageLinkDescriptor as aK, type HtmlLinkDescriptor as aL, type Future as aM, type unstable_SerializesTo as aN, createBrowserHistory as aO, invariant as aP, createRouter as aQ, ErrorResponseImpl as aR, DataRouterContext as aS, DataRouterStateContext as aT, FetchersContext as aU, LocationContext as aV, NavigationContext as aW, RouteContext as aX, ViewTransitionContext as aY, type FutureConfig as aZ, type RouteManifest as a_, type DataStrategyResult as aa, DataWithResponseInit as ab, type ErrorResponse as ac, type FormEncType as ad, type FormMethod as ae, type HTMLFormMethod as af, type LazyRouteFunction as ag, type LoaderFunctionArgs as ah, type unstable_MiddlewareFunction as ai, type PathParam as aj, type RedirectFunction as ak, type unstable_RouterContext as al, type ShouldRevalidateFunctionArgs as am, unstable_createContext as an, createPath as ao, parsePath as ap, IDLE_NAVIGATION as aq, IDLE_FETCHER as ar, IDLE_BLOCKER as as, data as at, generatePath as au, isRouteErrorResponse as av, matchPath as aw, matchRoutes as ax, redirect as ay, redirectDocument as az, type ServerDataFrom as b, type History as b0, type CreateStaticHandlerOptions as b1, type GetActionData as c, type Router as d, type RouteModules as e, type NavigateOptions as f, type Blocker as g, type SerializeFrom as h, type RelativeRoutingType as i, type ParamParseKey as j, type Path as k, type PathPattern as l, type PathMatch as m, type Navigation as n, type Params as o, type RouteObject as p, type IndexRouteObject as q, type LoaderFunction as r, type ActionFunction as s, type MetaFunction as t, type unstable_MiddlewareNextFunction as u, type LinksFunction as v, type NonIndexRouteObject as w, type AppLoadContext as x, unstable_RouterContextProvider as y, type MiddlewareEnabled as z };
+export { type StaticHandlerContext as $, Action as A, type BlockerFunction as B, type ClientDataFunctionArgs as C, type DataStrategyFunction as D, type Equal as E, type ClientActionFunction as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type ClientLoaderFunction as J, type HeadersFunction as K, type LinkDescriptor as L, type MetaDescriptor as M, type Normalize as N, type ShouldRevalidateFunction as O, type Pretty as P, type RouterInit as Q, type RouteModule$1 as R, type ServerDataFunctionArgs as S, type To as T, type UIMatch as U, type RouterState as V, type PatchRoutesOnNavigationFunction as W, type DataRouteObject as X, type StaticHandler as Y, type GetScrollPositionFunction as Z, type GetScrollRestorationKeyFunction as _, type Location as a, type History as a$, type Fetcher as a0, type NavigationStates as a1, type RouterSubscriber as a2, type RouterNavigateOptions as a3, type RouterFetchOptions as a4, type RevalidationState as a5, type ActionFunctionArgs as a6, type DataStrategyFunctionArgs as a7, type DataStrategyMatch as a8, type DataStrategyResult as a9, resolvePath as aA, type DataRouteMatch as aB, type Navigator as aC, type PatchRoutesOnNavigationFunctionArgs as aD, type RouteMatch as aE, type ClientActionFunctionArgs as aF, type ClientLoaderFunctionArgs as aG, type HeadersArgs as aH, type MetaArgs as aI, type PageLinkDescriptor as aJ, type HtmlLinkDescriptor as aK, type Future as aL, type unstable_SerializesTo as aM, createBrowserHistory as aN, invariant as aO, createRouter as aP, ErrorResponseImpl as aQ, DataRouterContext as aR, DataRouterStateContext as aS, FetchersContext as aT, LocationContext as aU, NavigationContext as aV, RouteContext as aW, ViewTransitionContext as aX, type FutureConfig as aY, type RouteManifest as aZ, type ServerRouteModule as a_, DataWithResponseInit as aa, type ErrorResponse as ab, type FormEncType as ac, type FormMethod as ad, type HTMLFormMethod as ae, type LazyRouteFunction as af, type LoaderFunctionArgs as ag, type unstable_MiddlewareFunction as ah, type PathParam as ai, type RedirectFunction as aj, type unstable_RouterContext as ak, type ShouldRevalidateFunctionArgs as al, unstable_createContext as am, createPath as an, parsePath as ao, IDLE_NAVIGATION as ap, IDLE_FETCHER as aq, IDLE_BLOCKER as ar, data as as, generatePath as at, isRouteErrorResponse as au, matchPath as av, matchRoutes as aw, redirect as ax, redirectDocument as ay, replace as az, type ServerDataFrom as b, type CreateStaticHandlerOptions as b0, type GetActionData as c, type Router as d, type RouteModules as e, type NavigateOptions as f, type Blocker as g, type SerializeFrom as h, type RelativeRoutingType as i, type ParamParseKey as j, type Path as k, type PathPattern as l, type PathMatch as m, type Navigation as n, type Params as o, type RouteObject as p, type IndexRouteObject as q, type LoaderFunction as r, type ActionFunction as s, type MetaFunction as t, type unstable_MiddlewareNextFunction as u, type LinksFunction as v, type NonIndexRouteObject as w, type AppLoadContext as x, unstable_RouterContextProvider as y, type MiddlewareEnabled as z };

package/package.json

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