react-router 0.0.0-experimental-e5dac68cb → 0.0.0-experimental-7a7fadb20

package/dist/development/browser-DYcG-QSM.d.mts

@@ -0,0 +1,141 @@
+import * as React from 'react';
+import { p as ActionFunction, C as ClientActionFunction, q as ClientLoaderFunction, r as HeadersFunction, s as LinksFunction, t as LoaderFunction, M as MetaFunction, u as ShouldRevalidateFunction, L as Location, g as Params, h as Router } from './route-data-Csr8hE3v.mjs';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+type ServerContext = {
+    redirect?: Response;
+};
+declare global {
+    var ___reactRouterServerStorage___: AsyncLocalStorage<ServerContext> | undefined;
+}
+type ServerRouteObjectBase = {
+    action?: ActionFunction;
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    ErrorBoundary?: React.ComponentType<any>;
+    handle?: any;
+    headers?: HeadersFunction;
+    HydrateFallback?: React.ComponentType<any>;
+    Layout?: React.ComponentType<any>;
+    links?: LinksFunction;
+    loader?: LoaderFunction;
+    meta?: MetaFunction;
+    shouldRevalidate?: ShouldRevalidateFunction;
+};
+type ServerRouteObject = ServerRouteObjectBase & {
+    id: string;
+    path?: string;
+    Component?: React.ComponentType<any>;
+    lazy?: () => Promise<ServerRouteObjectBase & ({
+        default?: React.ComponentType<any>;
+        Component?: never;
+    } | {
+        default?: never;
+        Component?: React.ComponentType<any>;
+    })>;
+} & ({
+    index: true;
+} | {
+    children?: ServerRouteObject[];
+});
+type RenderedRoute = {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    element?: React.ReactElement | false;
+    errorElement?: React.ReactElement;
+    handle?: any;
+    hasAction: boolean;
+    hasComponent: boolean;
+    hasErrorBoundary: boolean;
+    hasLoader: boolean;
+    hydrateFallbackElement?: React.ReactElement;
+    id: string;
+    index?: boolean;
+    links?: LinksFunction;
+    meta?: MetaFunction;
+    parentId?: string;
+    path?: string;
+    shouldRevalidate?: ShouldRevalidateFunction;
+};
+type ServerRouteMatch = RenderedRoute & {
+    params: Params;
+    pathname: string;
+    pathnameBase: string;
+};
+type ServerRenderPayload = {
+    type: "render";
+    actionData: Record<string, any> | null;
+    basename?: string;
+    errors: Record<string, any> | null;
+    loaderData: Record<string, any>;
+    location: Location;
+    matches: ServerRouteMatch[];
+    patches?: RenderedRoute[];
+    nonce?: string;
+    formState?: unknown;
+};
+type ServerManifestPayload = {
+    type: "manifest";
+    patches: RenderedRoute[];
+};
+type ServerActionPayload = {
+    type: "action";
+    actionResult: Promise<unknown>;
+    rerender?: Promise<ServerRenderPayload | ServerRedirectPayload>;
+};
+type ServerRedirectPayload = {
+    type: "redirect";
+    status: number;
+    location: string;
+    replace: boolean;
+    reload: boolean;
+    actionResult?: Promise<unknown>;
+};
+type ServerPayload = ServerRenderPayload | ServerManifestPayload | ServerActionPayload | ServerRedirectPayload;
+type ServerMatch = {
+    statusCode: number;
+    headers: Headers;
+    payload: ServerPayload;
+};
+type DecodeCallServerFunction = (id: string, reply: FormData | string) => Promise<() => Promise<unknown>>;
+type DecodeFormActionFunction = (formData: FormData) => Promise<() => Promise<void>>;
+type DecodeFormStateFunction = (result: unknown, formData: FormData) => unknown;
+declare function matchRSCServerRequest({ decodeCallServer, decodeFormAction, decodeFormState, onError, request, routes, generateResponse, }: {
+    decodeCallServer?: DecodeCallServerFunction;
+    decodeFormAction?: DecodeFormActionFunction;
+    decodeFormState?: DecodeFormStateFunction;
+    onError?: (error: unknown) => void;
+    request: Request;
+    routes: ServerRouteObject[];
+    generateResponse: (match: ServerMatch) => Response;
+}): Promise<Response>;
+
+type DecodeServerResponseFunction = (body: ReadableStream<Uint8Array>) => Promise<ServerPayload>;
+type EncodeActionFunction = (args: unknown[]) => Promise<BodyInit>;
+declare global {
+    interface Window {
+        __router: Router;
+        __routerInitialized: boolean;
+        __routerActionID: number;
+    }
+}
+declare function createCallServer({ decode, encodeAction, fetch: fetchImplementation, }: {
+    decode: DecodeServerResponseFunction;
+    encodeAction: EncodeActionFunction;
+    fetch?: (request: Request) => Promise<Response>;
+}): (id: string, args: unknown[]) => Promise<unknown>;
+declare function RSCHydratedRouter({ decode, fetch: fetchImplementation, payload, routeDiscovery, }: {
+    decode: DecodeServerResponseFunction;
+    fetch?: (request: Request) => Promise<Response>;
+    payload: ServerPayload;
+    routeDiscovery?: "eager" | "lazy";
+}): React.JSX.Element;
+
+declare global {
+    interface Window {
+        __FLIGHT_DATA: any[];
+    }
+}
+declare function getServerStream(): ReadableStream<any>;
+
+export { type DecodeServerResponseFunction as D, type EncodeActionFunction as E, RSCHydratedRouter as R, type ServerPayload as S, type DecodeCallServerFunction as a, type DecodeFormActionFunction as b, createCallServer as c, type ServerManifestPayload as d, type ServerMatch as e, type ServerRenderPayload as f, getServerStream as g, type RenderedRoute as h, type ServerRouteMatch as i, type ServerRouteObject as j, matchRSCServerRequest as m };