react-router 7.15.1 → 8.3.0

package/dist/development/lib/types/internal.d.ts

@@ -1,184 +1,33 @@
-import { R as RouteModule, v as LinkDescriptor, L as Location, w as Func, x as Pretty, y as MetaDescriptor, G as GetLoaderData, z as ServerDataFunctionArgs, B as MiddlewareNextFunction, E as ClientDataFunctionArgs, I as DataStrategyResult, J as ServerDataFrom, N as Normalize, K as GetActionData } from '../../data-BqZ2x964.js';
-import { R as RouteFiles, P as Pages } from '../../register-Bsscfj79.js';
-import 'react';
 
-type MaybePromise<T> = T | Promise<T>;
-type Props = {
-    params: unknown;
-    loaderData: unknown;
-    actionData: unknown;
-};
-type RouteInfo = Props & {
-    module: RouteModule;
-    matches: Array<MatchInfo>;
-};
-type MatchInfo = {
-    id: string;
-    module: RouteModule;
-};
-type MetaMatch<T extends MatchInfo> = Pretty<{
-    id: T["id"];
-    params: Record<string, string | undefined>;
-    pathname: string;
-    meta: MetaDescriptor[];
-    /** @deprecated Use `MetaMatch.loaderData` instead */
-    data: GetLoaderData<T["module"]>;
-    loaderData: GetLoaderData<T["module"]>;
-    handle?: unknown;
-    error?: unknown;
+import { Normalize } from "./utils.js";
+import { RouteModule } from "./route-module.js";
+import { GetActionData, GetLoaderData } from "./route-data.js";
+import { GetAnnotations } from "./route-module-annotations.js";
+import { Register } from "react-router";
+
+//#region lib/types/internal.d.ts
+type AnyParams = Record<string, string | undefined>;
+type AnyPages = Record<string, {
+  params: AnyParams;
 }>;
-type MetaMatches<T extends Array<MatchInfo>> = T extends [infer F extends MatchInfo, ...infer R extends Array<MatchInfo>] ? [MetaMatch<F>, ...MetaMatches<R>] : Array<MetaMatch<MatchInfo> | undefined>;
-type HasErrorBoundary<T extends RouteInfo> = T["module"] extends {
-    ErrorBoundary: Func;
-} ? true : false;
-type CreateMetaArgs<T extends RouteInfo> = {
-    /** This is the current router `Location` object. This is useful for generating tags for routes at specific paths or query parameters. */
-    location: Location;
-    /** {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route. */
-    params: T["params"];
-    /**
-     * The return value for this route's server loader function
-     *
-     * @deprecated Use `Route.MetaArgs.loaderData` instead
-     */
-    data: T["loaderData"] | (HasErrorBoundary<T> extends true ? undefined : never);
-    /** The return value for this route's server loader function */
-    loaderData: T["loaderData"] | (HasErrorBoundary<T> extends true ? undefined : never);
-    /** Thrown errors that trigger error boundaries will be passed to the meta function. This is useful for generating metadata for error pages. */
-    error?: unknown;
-    /** An array of the current {@link https://api.reactrouter.com/v7/interfaces/react-router.UIMatch.html route matches}, including parent route matches. */
-    matches: MetaMatches<T["matches"]>;
-};
-type MetaDescriptors = MetaDescriptor[];
-type HeadersArgs = {
-    loaderHeaders: Headers;
-    parentHeaders: Headers;
-    actionHeaders: Headers;
-    errorHeaders: Headers | undefined;
-};
-type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T["params"]>, next: MiddlewareNextFunction<Response>) => MaybePromise<Response | void>;
-type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T["params"]>, next: MiddlewareNextFunction<Record<string, DataStrategyResult>>) => MaybePromise<Record<string, DataStrategyResult> | void>;
-type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<T["params"]>;
-type CreateClientLoaderArgs<T extends RouteInfo> = ClientDataFunctionArgs<T["params"]> & {
-    /** This is an asynchronous function to get the data from the server loader for this route. On client-side navigations, this will make a {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server loader. If you opt-into running your clientLoader on hydration, then this function will return the data that was already loaded on the server (via Promise.resolve). */
-    serverLoader: () => Promise<ServerDataFrom<T["module"]["loader"]>>;
-};
-type CreateServerActionArgs<T extends RouteInfo> = ServerDataFunctionArgs<T["params"]>;
-type CreateClientActionArgs<T extends RouteInfo> = ClientDataFunctionArgs<T["params"]> & {
-    /** This is an asynchronous function that makes the {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server action for this route. */
-    serverAction: () => Promise<ServerDataFrom<T["module"]["action"]>>;
-};
-type CreateHydrateFallbackProps<T extends RouteInfo, RSCEnabled extends boolean> = {
-    params: T["params"];
-} & (RSCEnabled extends true ? {
-    /** The data returned from the `loader` */
-    loaderData?: ServerDataFrom<T["module"]["loader"]>;
-    /** The data returned from the `action` following an action submission. */
-    actionData?: ServerDataFrom<T["module"]["action"]>;
-} : {
-    /** The data returned from the `loader` or `clientLoader` */
-    loaderData?: T["loaderData"];
-    /** The data returned from the `action` or `clientAction` following an action submission. */
-    actionData?: T["actionData"];
-});
-type Match<T extends MatchInfo> = Pretty<{
-    id: T["id"];
-    params: Record<string, string | undefined>;
-    pathname: string;
-    /** @deprecated Use `Match.loaderData` instead */
-    data: GetLoaderData<T["module"]>;
-    loaderData: GetLoaderData<T["module"]>;
-    handle: unknown;
+type Pages = Register extends {
+  pages: infer Registered extends AnyPages;
+} ? Registered : AnyPages;
+type AnyRouteFiles = Record<string, {
+  id: string;
+  page: string;
 }>;
-type Matches<T extends Array<MatchInfo>> = T extends [infer F extends MatchInfo, ...infer R extends Array<MatchInfo>] ? [Match<F>, ...Matches<R>] : Array<Match<MatchInfo> | undefined>;
-type CreateComponentProps<T extends RouteInfo, RSCEnabled extends boolean> = {
-    /**
-     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
-     * @example
-     * // app/routes.ts
-     * route("teams/:teamId", "./team.tsx"),
-     *
-     * // app/team.tsx
-     * export default function Component({
-     *   params,
-     * }: Route.ComponentProps) {
-     *   params.teamId;
-     *   //        ^ string
-     * }
-     **/
-    params: T["params"];
-    /** An array of the current {@link https://api.reactrouter.com/v7/interfaces/react-router.UIMatch.html route matches}, including parent route matches. */
-    matches: Matches<T["matches"]>;
-} & (RSCEnabled extends true ? {
-    /** The data returned from the `loader` */
-    loaderData: ServerDataFrom<T["module"]["loader"]>;
-    /** The data returned from the `action` following an action submission. */
-    actionData?: ServerDataFrom<T["module"]["action"]>;
-} : {
-    /** The data returned from the `loader` or `clientLoader` */
-    loaderData: T["loaderData"];
-    /** The data returned from the `action` or `clientAction` following an action submission. */
-    actionData?: T["actionData"];
-});
-type CreateErrorBoundaryProps<T extends RouteInfo, RSCEnabled extends boolean> = {
-    /**
-     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
-     * @example
-     * // app/routes.ts
-     * route("teams/:teamId", "./team.tsx"),
-     *
-     * // app/team.tsx
-     * export function ErrorBoundary({
-     *   params,
-     * }: Route.ErrorBoundaryProps) {
-     *   params.teamId;
-     *   //        ^ string
-     * }
-     **/
-    params: T["params"];
-    error: unknown;
-} & (RSCEnabled extends true ? {
-    /** The data returned from the `loader` */
-    loaderData?: ServerDataFrom<T["module"]["loader"]>;
-    /** The data returned from the `action` following an action submission. */
-    actionData?: ServerDataFrom<T["module"]["action"]>;
-} : {
-    /** The data returned from the `loader` or `clientLoader` */
-    loaderData?: T["loaderData"];
-    /** The data returned from the `action` or `clientAction` following an action submission. */
-    actionData?: T["actionData"];
-});
-type GetAnnotations<Info extends RouteInfo> = {
-    LinkDescriptors: LinkDescriptor[];
-    LinksFunction: () => LinkDescriptor[];
-    MetaArgs: CreateMetaArgs<Info>;
-    MetaDescriptors: MetaDescriptors;
-    MetaFunction: (args: CreateMetaArgs<Info>) => MetaDescriptors;
-    HeadersArgs: HeadersArgs;
-    HeadersFunction: (args: HeadersArgs) => Headers | HeadersInit;
-    MiddlewareFunction: CreateServerMiddlewareFunction<Info>;
-    ClientMiddlewareFunction: CreateClientMiddlewareFunction<Info>;
-    LoaderArgs: CreateServerLoaderArgs<Info>;
-    ClientLoaderArgs: CreateClientLoaderArgs<Info>;
-    ActionArgs: CreateServerActionArgs<Info>;
-    ClientActionArgs: CreateClientActionArgs<Info>;
-    HydrateFallbackProps: CreateHydrateFallbackProps<Info, false>;
-    ServerHydrateFallbackProps: CreateHydrateFallbackProps<Info, true>;
-    ComponentProps: CreateComponentProps<Info, false>;
-    ServerComponentProps: CreateComponentProps<Info, true>;
-    ErrorBoundaryProps: CreateErrorBoundaryProps<Info, false>;
-    ServerErrorBoundaryProps: CreateErrorBoundaryProps<Info, true>;
-};
-
+type RouteFiles = Register extends {
+  routeFiles: infer Registered extends AnyRouteFiles;
+} ? Registered : AnyRouteFiles;
 type Params<RouteFile extends keyof RouteFiles> = Normalize<Pages[RouteFiles[RouteFile]["page"]]["params"]>;
-
 type GetInfo<T extends {
-    file: keyof RouteFiles;
-    module: RouteModule;
+  file: keyof RouteFiles;
+  module: RouteModule;
 }> = {
-    params: Params<T["file"]>;
-    loaderData: GetLoaderData<T["module"]>;
-    actionData: GetActionData<T["module"]>;
+  params: Params<T["file"]>;
+  loaderData: GetLoaderData<T["module"]>;
+  actionData: GetActionData<T["module"]>;
 };
-
-export type { GetAnnotations, GetInfo };
+//#endregion
+export { type GetAnnotations, GetInfo };

package/dist/development/lib/types/internal.js

@@ -1,5 +1,5 @@
-"use strict";/**
- * react-router v7.15.1
+/**
+ * react-router v8.3.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,3 +8,4 @@
  *
  * @license MIT
  */
+export {};

package/dist/{production/register-Bsscfj79.d.ts → development/lib/types/register.d.ts}

@@ -1,30 +1,24 @@
-import { R as RouteModule } from './data-BqZ2x964.js';
 
+import { RouteModule } from "./route-module.js";
+
+//#region lib/types/register.d.ts
 /**
  * Apps can use this interface to "register" app-wide types for React Router via interface declaration merging and module augmentation.
  * React Router should handle this for you via type generation.
  *
  * For more on declaration merging and module augmentation, see https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation .
  */
-interface Register {
-}
+interface Register {}
 type AnyParams = Record<string, string | undefined>;
 type AnyPages = Record<string, {
-    params: AnyParams;
+  params: AnyParams;
 }>;
 type Pages = Register extends {
-    pages: infer Registered extends AnyPages;
+  pages: infer Registered extends AnyPages;
 } ? Registered : AnyPages;
-type AnyRouteFiles = Record<string, {
-    id: string;
-    page: string;
-}>;
-type RouteFiles = Register extends {
-    routeFiles: infer Registered extends AnyRouteFiles;
-} ? Registered : AnyRouteFiles;
 type AnyRouteModules = Record<string, RouteModule>;
 type RouteModules = Register extends {
-    routeModules: infer Registered extends AnyRouteModules;
+  routeModules: infer Registered extends AnyRouteModules;
 } ? Registered : AnyRouteModules;
-
-export type { Pages as P, RouteFiles as R, RouteModules as a, Register as b };
+//#endregion
+export { Pages, Register, RouteModules };

package/dist/development/lib/types/route-data.d.ts

@@ -0,0 +1,113 @@
+
+import { DataWithResponseInit, RouterContextProvider } from "../router/utils.js";
+import { Equal, Func, IsAny } from "./utils.js";
+import { RouteModule } from "./route-module.js";
+import { unstable_SerializesTo } from "./serializes-to.js";
+import { Serializable } from "../server-runtime/single-fetch.js";
+import { ClientActionFunctionArgs, ClientLoaderFunctionArgs } from "../dom/ssr/routeModules.js";
+
+//#region lib/types/route-data.d.ts
+type Serialize<T> = T extends unstable_SerializesTo<infer To> ? To : T extends Serializable ? T : T extends ((...args: any[]) => unknown) ? undefined : T extends Promise<infer U> ? Promise<Serialize<U>> : T extends Map<infer K, infer V> ? Map<Serialize<K>, Serialize<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Serialize<K>, Serialize<V>> : T extends Set<infer U> ? Set<Serialize<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? { [K in keyof T]: Serialize<T[K]> } : undefined;
+type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
+type DataFrom<T> = IsAny<T> extends true ? undefined : T extends Func ? VoidToUndefined<Awaited<ReturnType<T>>> : undefined;
+type ClientData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? U : T;
+type ServerData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? Serialize<U> : Serialize<T>;
+type ServerDataFrom<T> = ServerData<DataFrom<T>>;
+type ClientDataFrom<T> = ClientData<DataFrom<T>>;
+type ClientDataFunctionArgs<Params> = {
+  /**
+   * A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the URL, the method, the "content-type" header, and the request body from the request.
+   *
+   * @note Because client data functions are called before a network request is made, the Request object does not include the headers which the browser automatically adds. React Router infers the "content-type" header from the enc-type of the form that performed the submission.
+   **/
+  request: Request;
+  /**
+   * A URL instance representing the application location being navigated to or
+   * fetched.
+   *
+   * In Framework mode, this is a normalized URL with React-Router-specific
+   * implementation details removed (`.data` suffixes, `index`/`_routes` search
+   * params). For the raw incoming URL, use `request.url`.
+   */
+  url: URL;
+  /**
+   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+   * @example
+   * // app/routes.ts
+   * route("teams/:teamId", "./team.tsx"),
+   *
+   * // app/team.tsx
+   * export function clientLoader({
+   *   params,
+   * }: Route.ClientLoaderArgs) {
+   *   params.teamId;
+   *   //        ^ string
+   * }
+   **/
+  params: Params;
+  /**
+   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+   */
+  pattern: string;
+  /**
+   * An instance of `RouterContextProvider` that can be used to access context
+   * values from your route middlewares.  You may pass in initial context values
+   * in your `<HydratedRouter getContext>` prop.
+   */
+  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. */request: Request;
+  /**
+   * A URL instance representing the application location being navigated to or
+   * fetched.
+   *
+   * In Framework mode, this is a normalized URL with React-Router-specific
+   * implementation details removed (`.data` suffixes, `index`/`_routes` search
+   * params). For the raw incoming URL, use `request.url`.
+   */
+  url: URL;
+  /**
+   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+   * @example
+   * // app/routes.ts
+   * route("teams/:teamId", "./team.tsx"),
+   *
+   * // app/team.tsx
+   * export function loader({
+   *   params,
+   * }: Route.LoaderArgs) {
+   *   params.teamId;
+   *   //        ^ string
+   * }
+   **/
+  params: Params;
+  /**
+   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+   */
+  pattern: string;
+  /**
+   * An instance of `RouterContextProvider` that can be used for type-safe
+   * access to context values 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: Readonly<RouterContextProvider>;
+};
+type SerializeFrom<T> = T extends ((...args: infer Args) => unknown) ? Args extends [ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
+type IsDefined<T> = Equal<T, undefined> extends true ? false : true;
+type IsHydrate<ClientLoader> = ClientLoader extends {
+  hydrate: true;
+} ? true : ClientLoader extends {
+  hydrate: false;
+} ? false : false;
+type GetLoaderData<T extends RouteModule> = _DataLoaderData<ServerDataFrom<T["loader"]>, ClientDataFrom<T["clientLoader"]>, IsHydrate<T["clientLoader"]>, T extends {
+  HydrateFallback: Func;
+} ? true : false>;
+type _DataLoaderData<ServerLoaderData, ClientLoaderData, ClientLoaderHydrate extends boolean, HasHydrateFallback> = [HasHydrateFallback, ClientLoaderHydrate] extends [true, true] ? IsDefined<ClientLoaderData> extends true ? ClientLoaderData : undefined : [IsDefined<ClientLoaderData>, IsDefined<ServerLoaderData>] extends [true, true] ? ServerLoaderData | ClientLoaderData : IsDefined<ClientLoaderData> extends true ? ClientLoaderData : IsDefined<ServerLoaderData> extends true ? ServerLoaderData : undefined;
+type GetActionData<T extends RouteModule> = _DataActionData<ServerDataFrom<T["action"]>, ClientDataFrom<T["clientAction"]>>;
+type _DataActionData<ServerActionData, ClientActionData> = Awaited<[IsDefined<ServerActionData>, IsDefined<ClientActionData>] extends [true, true] ? ServerActionData | ClientActionData : IsDefined<ClientActionData> extends true ? ClientActionData : IsDefined<ServerActionData> extends true ? ServerActionData : undefined>;
+//#endregion
+export { ClientDataFunctionArgs, GetActionData, GetLoaderData, SerializeFrom, ServerDataFrom, ServerDataFunctionArgs };

package/dist/development/lib/types/route-module-annotations.d.ts

@@ -0,0 +1,149 @@
+
+import { Location } from "../router/history.js";
+import { DataStrategyResult, MiddlewareNextFunction } from "../router/utils.js";
+import { LinkDescriptor } from "../router/links.js";
+import { Func, Pretty } from "./utils.js";
+import { RouteModule } from "./route-module.js";
+import { ClientDataFunctionArgs, GetLoaderData, ServerDataFrom, ServerDataFunctionArgs } from "./route-data.js";
+import { MetaDescriptor } from "../dom/ssr/routeModules.js";
+
+//#region lib/types/route-module-annotations.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type Props = {
+  params: unknown;
+  loaderData: unknown;
+  actionData: unknown;
+};
+type RouteInfo = Props & {
+  module: RouteModule;
+  matches: Array<MatchInfo>;
+};
+type MatchInfo = {
+  id: string;
+  module: RouteModule;
+};
+type MetaMatch<T extends MatchInfo> = Pretty<{
+  id: T["id"];
+  params: Record<string, string | undefined>;
+  pathname: string;
+  meta: MetaDescriptor[];
+  loaderData: GetLoaderData<T["module"]>;
+  handle?: unknown;
+  error?: unknown;
+}>;
+type MetaMatches<T extends Array<MatchInfo>> = T extends [infer F extends MatchInfo, ...infer R extends Array<MatchInfo>] ? [MetaMatch<F>, ...MetaMatches<R>] : Array<MetaMatch<MatchInfo> | undefined>;
+type HasErrorBoundary<T extends RouteInfo> = T["module"] extends {
+  ErrorBoundary: Func;
+} ? true : false;
+type CreateMetaArgs<T extends RouteInfo> = {
+  /** This is the current router `Location` object. This is useful for generating tags for routes at specific paths or query parameters. */location: Location; /** {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route. */
+  params: T["params"]; /** The return value for this route's server loader function */
+  loaderData: T["loaderData"] | (HasErrorBoundary<T> extends true ? undefined : never); /** Thrown errors that trigger error boundaries will be passed to the meta function. This is useful for generating metadata for error pages. */
+  error?: unknown; /** An array of the current {@link https://api.reactrouter.com/v7/interfaces/react-router.UIMatch.html route matches}, including parent route matches. */
+  matches: MetaMatches<T["matches"]>;
+};
+type MetaDescriptors = MetaDescriptor[];
+type HeadersArgs = {
+  loaderHeaders: Headers;
+  parentHeaders: Headers;
+  actionHeaders: Headers;
+  errorHeaders: Headers | undefined;
+};
+type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T["params"]>, next: MiddlewareNextFunction<Response>) => MaybePromise<Response | void>;
+type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T["params"]>, next: MiddlewareNextFunction<Record<string, DataStrategyResult>>) => MaybePromise<Record<string, DataStrategyResult> | void>;
+type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<T["params"]>;
+type CreateClientLoaderArgs<T extends RouteInfo> = ClientDataFunctionArgs<T["params"]> & {
+  /** This is an asynchronous function to get the data from the server loader for this route. On client-side navigations, this will make a {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server loader. If you opt-into running your clientLoader on hydration, then this function will return the data that was already loaded on the server (via Promise.resolve). */serverLoader: () => Promise<ServerDataFrom<T["module"]["loader"]>>;
+};
+type CreateServerActionArgs<T extends RouteInfo> = ServerDataFunctionArgs<T["params"]>;
+type CreateClientActionArgs<T extends RouteInfo> = ClientDataFunctionArgs<T["params"]> & {
+  /** This is an asynchronous function that makes the {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server action for this route. */serverAction: () => Promise<ServerDataFrom<T["module"]["action"]>>;
+};
+type CreateHydrateFallbackProps<T extends RouteInfo, RSCEnabled extends boolean> = {
+  params: T["params"];
+} & (RSCEnabled extends true ? {
+  /** The data returned from the `loader` */loaderData?: ServerDataFrom<T["module"]["loader"]>; /** The data returned from the `action` following an action submission. */
+  actionData?: ServerDataFrom<T["module"]["action"]>;
+} : {
+  /** The data returned from the `loader` or `clientLoader` */loaderData?: T["loaderData"]; /** The data returned from the `action` or `clientAction` following an action submission. */
+  actionData?: T["actionData"];
+});
+type Match<T extends MatchInfo> = Pretty<{
+  id: T["id"];
+  params: Record<string, string | undefined>;
+  pathname: string;
+  loaderData: GetLoaderData<T["module"]>;
+  handle: unknown;
+}>;
+type Matches<T extends Array<MatchInfo>> = T extends [infer F extends MatchInfo, ...infer R extends Array<MatchInfo>] ? [Match<F>, ...Matches<R>] : Array<Match<MatchInfo> | undefined>;
+type CreateComponentProps<T extends RouteInfo, RSCEnabled extends boolean> = {
+  /**
+   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+   * @example
+   * // app/routes.ts
+   * route("teams/:teamId", "./team.tsx"),
+   *
+   * // app/team.tsx
+   * export default function Component({
+   *   params,
+   * }: Route.ComponentProps) {
+   *   params.teamId;
+   *   //        ^ string
+   * }
+   **/
+  params: T["params"]; /** An array of the current {@link https://api.reactrouter.com/v7/interfaces/react-router.UIMatch.html route matches}, including parent route matches. */
+  matches: Matches<T["matches"]>;
+} & (RSCEnabled extends true ? {
+  /** The data returned from the `loader` */loaderData: ServerDataFrom<T["module"]["loader"]>; /** The data returned from the `action` following an action submission. */
+  actionData?: ServerDataFrom<T["module"]["action"]>;
+} : {
+  /** The data returned from the `loader` or `clientLoader` */loaderData: T["loaderData"]; /** The data returned from the `action` or `clientAction` following an action submission. */
+  actionData?: T["actionData"];
+});
+type CreateErrorBoundaryProps<T extends RouteInfo, RSCEnabled extends boolean> = {
+  /**
+   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+   * @example
+   * // app/routes.ts
+   * route("teams/:teamId", "./team.tsx"),
+   *
+   * // app/team.tsx
+   * export function ErrorBoundary({
+   *   params,
+   * }: Route.ErrorBoundaryProps) {
+   *   params.teamId;
+   *   //        ^ string
+   * }
+   **/
+  params: T["params"];
+  error: unknown;
+} & (RSCEnabled extends true ? {
+  /** The data returned from the `loader` */loaderData?: ServerDataFrom<T["module"]["loader"]>; /** The data returned from the `action` following an action submission. */
+  actionData?: ServerDataFrom<T["module"]["action"]>;
+} : {
+  /** The data returned from the `loader` or `clientLoader` */loaderData?: T["loaderData"]; /** The data returned from the `action` or `clientAction` following an action submission. */
+  actionData?: T["actionData"];
+});
+type GetAnnotations<Info extends RouteInfo> = {
+  LinkDescriptors: LinkDescriptor[];
+  LinksFunction: () => LinkDescriptor[];
+  MetaArgs: CreateMetaArgs<Info>;
+  MetaDescriptors: MetaDescriptors;
+  MetaFunction: (args: CreateMetaArgs<Info>) => MetaDescriptors;
+  HeadersArgs: HeadersArgs;
+  HeadersFunction: (args: HeadersArgs) => Headers | HeadersInit;
+  MiddlewareFunction: CreateServerMiddlewareFunction<Info>;
+  ClientMiddlewareFunction: CreateClientMiddlewareFunction<Info>;
+  LoaderArgs: CreateServerLoaderArgs<Info>;
+  ClientLoaderArgs: CreateClientLoaderArgs<Info>;
+  ActionArgs: CreateServerActionArgs<Info>;
+  ClientActionArgs: CreateClientActionArgs<Info>;
+  HydrateFallbackProps: CreateHydrateFallbackProps<Info, false>;
+  ServerHydrateFallbackProps: CreateHydrateFallbackProps<Info, true>;
+  ComponentProps: CreateComponentProps<Info, false>;
+  ServerComponentProps: CreateComponentProps<Info, true>;
+  ErrorBoundaryProps: CreateErrorBoundaryProps<Info, false>;
+  ServerErrorBoundaryProps: CreateErrorBoundaryProps<Info, true>;
+};
+//#endregion
+export { GetAnnotations };

package/dist/development/lib/types/route-module.d.ts

@@ -0,0 +1,19 @@
+
+import { Func } from "./utils.js";
+
+//#region lib/types/route-module.d.ts
+type RouteModule = {
+  meta?: Func;
+  links?: Func;
+  headers?: Func;
+  loader?: Func;
+  clientLoader?: Func;
+  action?: Func;
+  clientAction?: Func;
+  HydrateFallback?: Func;
+  default?: Func;
+  ErrorBoundary?: Func;
+  [key: string]: unknown;
+};
+//#endregion
+export { RouteModule };

package/dist/development/lib/types/serializes-to.d.ts

@@ -0,0 +1,13 @@
+
+//#region lib/types/serializes-to.d.ts
+/**
+ * A brand that can be applied to a type to indicate that it will serialize
+ * to a specific type when transported to the client from a loader.
+ * Only use this if you have additional serialization/deserialization logic
+ * in your application.
+ */
+type unstable_SerializesTo<T> = {
+  unstable__ReactRouter_SerializesTo: [T];
+};
+//#endregion
+export { unstable_SerializesTo };

package/dist/development/lib/types/utils.d.ts

@@ -0,0 +1,11 @@
+
+//#region lib/types/utils.d.ts
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Func = (...args: any[]) => unknown;
+type Pretty<T> = { [K in keyof T]: T[K] } & {};
+type Normalize<T> = _Normalize<UnionKeys<T>, T>;
+type _Normalize<Key extends keyof any, T> = T extends infer U ? Pretty<{ [K in Key as K extends keyof U ? undefined extends U[K] ? never : K : never]: K extends keyof U ? U[K] : never } & { [K in Key as K extends keyof U ? undefined extends U[K] ? K : never : never]?: K extends keyof U ? U[K] : never } & { [K in Key as K extends keyof U ? never : K]?: undefined }> : never;
+type UnionKeys<T> = T extends any ? keyof T : never;
+//#endregion
+export { Equal, Func, IsAny, Normalize, Pretty };