react-router 7.6.0 → 7.6.1-pre.0

package/dist/development/internal-export.d.mts

@@ -0,0 +1,504 @@
+import { RouteFiles, Pages } from 'react-router';
+
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+interface Path {
+    /**
+     * A URL pathname, beginning with a /.
+     */
+    pathname: string;
+    /**
+     * A URL search string, beginning with a ?.
+     */
+    search: string;
+    /**
+     * A URL fragment identifier, beginning with a #.
+     */
+    hash: string;
+}
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+interface Location<State = any> extends Path {
+    /**
+     * A value of arbitrary data associated with this location.
+     */
+    state: State;
+    /**
+     * A unique string associated with this location. May be used to safely store
+     * and retrieve data in some other storage API, like `localStorage`.
+     *
+     * Note: This value is always "default" on the initial location.
+     */
+    key: string;
+}
+
+/**
+ * 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;
+
+type MaybePromise$1<T> = T | Promise<T>;
+interface unstable_RouterContext<T = unknown> {
+    defaultValue?: 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.
+ */
+declare class unstable_RouterContextProvider {
+    #private;
+    constructor(init?: unstable_InitialContext);
+    get<T>(context: unstable_RouterContext<T>): T;
+    set<C extends unstable_RouterContext>(context: C, value: C extends unstable_RouterContext<infer T> ? T : never): void;
+}
+/**
+ * Route middleware `next` function to call downstream handlers and then complete
+ * middlewares from the bottom-up
+ */
+interface unstable_MiddlewareNextFunction<Result = unknown> {
+    (): MaybePromise$1<Result>;
+}
+declare class DataWithResponseInit<D> {
+    type: string;
+    data: D;
+    init: ResponseInit | null;
+    constructor(data: D, init?: ResponseInit);
+}
+
+/**
+ * An object of unknown type for route loaders and actions provided by the
+ * server's `getLoadContext()` function.  This is defined as an empty interface
+ * specifically so apps can leverage declaration merging to augment this type
+ * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
+ */
+interface AppLoadContext {
+    [key: string]: unknown;
+}
+
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+interface HtmlLinkProps {
+    /**
+     * Address of the hyperlink
+     */
+    href?: string;
+    /**
+     * How the element handles crossorigin requests
+     */
+    crossOrigin?: "anonymous" | "use-credentials";
+    /**
+     * Relationship between the document containing the hyperlink and the destination resource
+     */
+    rel: LiteralUnion<"alternate" | "dns-prefetch" | "icon" | "manifest" | "modulepreload" | "next" | "pingback" | "preconnect" | "prefetch" | "preload" | "prerender" | "search" | "stylesheet", string>;
+    /**
+     * Applicable media: "screen", "print", "(max-width: 764px)"
+     */
+    media?: string;
+    /**
+     * Integrity metadata used in Subresource Integrity checks
+     */
+    integrity?: string;
+    /**
+     * Language of the linked resource
+     */
+    hrefLang?: string;
+    /**
+     * Hint for the type of the referenced resource
+     */
+    type?: string;
+    /**
+     * Referrer policy for fetches initiated by the element
+     */
+    referrerPolicy?: "" | "no-referrer" | "no-referrer-when-downgrade" | "same-origin" | "origin" | "strict-origin" | "origin-when-cross-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
+    /**
+     * Sizes of the icons (for rel="icon")
+     */
+    sizes?: string;
+    /**
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+     */
+    as?: LiteralUnion<"audio" | "audioworklet" | "document" | "embed" | "fetch" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "serviceworker" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt", string>;
+    /**
+     * Color to use when customizing a site's icon (for rel="mask-icon")
+     */
+    color?: string;
+    /**
+     * Whether the link is disabled
+     */
+    disabled?: boolean;
+    /**
+     * The title attribute has special semantics on this element: Title of the link; CSS style sheet set name.
+     */
+    title?: string;
+    /**
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
+     */
+    imageSrcSet?: string;
+    /**
+     * Image sizes for different page layouts (for rel="preload")
+     */
+    imageSizes?: string;
+}
+interface HtmlLinkPreloadImage extends HtmlLinkProps {
+    /**
+     * Relationship between the document containing the hyperlink and the destination resource
+     */
+    rel: "preload";
+    /**
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+     */
+    as: "image";
+    /**
+     * Address of the hyperlink
+     */
+    href?: string;
+    /**
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
+     */
+    imageSrcSet: string;
+    /**
+     * Image sizes for different page layouts (for rel="preload")
+     */
+    imageSizes?: string;
+}
+/**
+ * Represents a `<link>` element.
+ *
+ * WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
+ */
+type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
+    imageSizes?: never;
+});
+interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
+    /**
+     * The absolute path of the page to prefetch.
+     */
+    page: string;
+}
+type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
+
+type MetaDescriptor = {
+    charSet: "utf-8";
+} | {
+    title: string;
+} | {
+    name: string;
+    content: string;
+} | {
+    property: string;
+    content: string;
+} | {
+    httpEquiv: string;
+    content: string;
+} | {
+    "script:ld+json": LdJsonObject;
+} | {
+    tagName: "meta" | "link";
+    [name: string]: string;
+} | {
+    [name: string]: unknown;
+};
+type LdJsonObject = {
+    [Key in string]: LdJsonValue;
+} & {
+    [Key in string]?: LdJsonValue | undefined;
+};
+type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
+type LdJsonPrimitive = string | number | boolean | null;
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
+
+type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
+    [key: PropertyKey]: Serializable;
+} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
+
+/**
+ * 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];
+};
+
+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;
+
+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;
+};
+
+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 Set<infer U> ? Set<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 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>;
+
+type Params<RouteFile extends keyof RouteFiles> = Normalize<Pages[RouteFiles[RouteFile]["page"]]["params"]>;
+
+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[];
+    data: 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 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 */
+    data: T["loaderData"] | undefined;
+    /** 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 ClientDataFunctionArgs<T extends RouteInfo> = {
+    /**
+     * 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;
+    /**
+     * {@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: T["params"];
+    /**
+     * When `future.unstable_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
+     * from your route middlewares.  You may pass in initial context values in your
+     * `<HydratedRouter unstable_getContext>` prop
+     */
+    context: unstable_RouterContextProvider;
+};
+type ServerDataFunctionArgs<T extends RouteInfo> = {
+    /** 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;
+    /**
+     * {@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: T["params"];
+    /**
+     * Without `future.unstable_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
+     * 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 ? unstable_RouterContextProvider : AppLoadContext;
+};
+type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<Response>) => MaybePromise<Response | void>;
+type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T>, next: unstable_MiddlewareNextFunction<undefined>) => MaybePromise<void>;
+type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<T>;
+type CreateClientLoaderArgs<T extends RouteInfo> = ClientDataFunctionArgs<T> & {
+    /** 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>;
+type CreateClientActionArgs<T extends RouteInfo> = ClientDataFunctionArgs<T> & {
+    /** 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> = {
+    params: T["params"];
+    loaderData?: T["loaderData"];
+    actionData?: T["actionData"];
+};
+type Match<T extends MatchInfo> = Pretty<{
+    id: T["id"];
+    params: Record<string, string | undefined>;
+    pathname: string;
+    data: 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> = {
+    /**
+     * {@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"];
+    /** 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"];
+    /** 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"]>;
+};
+type CreateErrorBoundaryProps<T extends RouteInfo> = {
+    /**
+     * {@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;
+    loaderData?: T["loaderData"];
+    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;
+    unstable_MiddlewareFunction: CreateServerMiddlewareFunction<Info>;
+    unstable_ClientMiddlewareFunction: CreateClientMiddlewareFunction<Info>;
+    LoaderArgs: CreateServerLoaderArgs<Info>;
+    ClientLoaderArgs: CreateClientLoaderArgs<Info>;
+    ActionArgs: CreateServerActionArgs<Info>;
+    ClientActionArgs: CreateClientActionArgs<Info>;
+    HydrateFallbackProps: CreateHydrateFallbackProps<Info>;
+    ComponentProps: CreateComponentProps<Info>;
+    ErrorBoundaryProps: CreateErrorBoundaryProps<Info>;
+};
+
+type GetInfo<T extends {
+    file: keyof RouteFiles;
+    module: RouteModule;
+}> = {
+    params: Params<T["file"]>;
+    loaderData: GetLoaderData<T["module"]>;
+    actionData: GetActionData<T["module"]>;
+};
+
+export type { GetAnnotations, GetInfo };