UNPKG

13.1 kBTypeScriptView Raw
1import * as React from 'react';
2import { R as RouterInit } from './instrumentation-CMVbvxj9.js';
3import { L as Location, C as ClientActionFunction, a as ClientLoaderFunction, b as LinksFunction, M as MetaFunction, S as ShouldRevalidateFunction, P as Params, c as RouterContextProvider, A as ActionFunction, H as HeadersFunction, d as LoaderFunction } from './routeModules-CM_clkdE.js';
4
5declare function getRequest(): Request;
6type RSCRouteConfigEntryBase = {
7 action?: ActionFunction;
8 clientAction?: ClientActionFunction;
9 clientLoader?: ClientLoaderFunction;
10 ErrorBoundary?: React.ComponentType<any>;
11 handle?: any;
12 headers?: HeadersFunction;
13 HydrateFallback?: React.ComponentType<any>;
14 Layout?: React.ComponentType<any>;
15 links?: LinksFunction;
16 loader?: LoaderFunction;
17 meta?: MetaFunction;
18 shouldRevalidate?: ShouldRevalidateFunction;
19};
20type RSCRouteConfigEntry = RSCRouteConfigEntryBase & {
21 id: string;
22 path?: string;
23 Component?: React.ComponentType<any>;
24 lazy?: () => Promise<RSCRouteConfigEntryBase & ({
25 default?: React.ComponentType<any>;
26 Component?: never;
27 } | {
28 default?: never;
29 Component?: React.ComponentType<any>;
30 })>;
31} & ({
32 index: true;
33} | {
34 children?: RSCRouteConfigEntry[];
35});
36type RSCRouteConfig = Array<RSCRouteConfigEntry>;
37type RSCRouteManifest = {
38 clientAction?: ClientActionFunction;
39 clientLoader?: ClientLoaderFunction;
40 element?: React.ReactElement | false;
41 errorElement?: React.ReactElement;
42 handle?: any;
43 hasAction: boolean;
44 hasComponent: boolean;
45 hasErrorBoundary: boolean;
46 hasLoader: boolean;
47 hydrateFallbackElement?: React.ReactElement;
48 id: string;
49 index?: boolean;
50 links?: LinksFunction;
51 meta?: MetaFunction;
52 parentId?: string;
53 path?: string;
54 shouldRevalidate?: ShouldRevalidateFunction;
55};
56type RSCRouteMatch = RSCRouteManifest & {
57 params: Params;
58 pathname: string;
59 pathnameBase: string;
60};
61type RSCRenderPayload = {
62 type: "render";
63 actionData: Record<string, any> | null;
64 basename: string | undefined;
65 errors: Record<string, any> | null;
66 loaderData: Record<string, any>;
67 location: Location;
68 routeDiscovery: RouteDiscovery;
69 matches: RSCRouteMatch[];
70 patches?: Promise<RSCRouteManifest[]>;
71 nonce?: string;
72 formState?: unknown;
73};
74type RSCManifestPayload = {
75 type: "manifest";
76 patches: Promise<RSCRouteManifest[]>;
77};
78type RSCActionPayload = {
79 type: "action";
80 actionResult: Promise<unknown>;
81 rerender?: Promise<RSCRenderPayload | RSCRedirectPayload>;
82};
83type RSCRedirectPayload = {
84 type: "redirect";
85 status: number;
86 location: string;
87 replace: boolean;
88 reload: boolean;
89 actionResult?: Promise<unknown>;
90};
91type RSCPayload = RSCRenderPayload | RSCManifestPayload | RSCActionPayload | RSCRedirectPayload;
92type RSCMatch = {
93 statusCode: number;
94 headers: Headers;
95 payload: RSCPayload;
96};
97type DecodeActionFunction = (formData: FormData) => Promise<() => Promise<unknown>>;
98type DecodeFormStateFunction = (result: unknown, formData: FormData) => unknown;
99type DecodeReplyFunction = (reply: FormData | string, options: {
100 temporaryReferences: unknown;
101}) => Promise<unknown[]>;
102type LoadServerActionFunction = (id: string) => Promise<Function>;
103type RouteDiscovery = {
104 mode: "lazy";
105 manifestPath?: string | undefined;
106} | {
107 mode: "initial";
108};
109/**
110 * Matches the given routes to a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
111 * and returns an [RSC](https://react.dev/reference/rsc/server-components)
112 * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
113 * encoding an {@link unstable_RSCPayload} for consumption by an [RSC](https://react.dev/reference/rsc/server-components)
114 * enabled client router.
115 *
116 * @example
117 * import {
118 * createTemporaryReferenceSet,
119 * decodeAction,
120 * decodeReply,
121 * loadServerAction,
122 * renderToReadableStream,
123 * } from "@vitejs/plugin-rsc/rsc";
124 * import { unstable_matchRSCServerRequest as matchRSCServerRequest } from "react-router";
125 *
126 * matchRSCServerRequest({
127 * createTemporaryReferenceSet,
128 * decodeAction,
129 * decodeFormState,
130 * decodeReply,
131 * loadServerAction,
132 * request,
133 * routes: routes(),
134 * generateResponse(match) {
135 * return new Response(
136 * renderToReadableStream(match.payload),
137 * {
138 * status: match.statusCode,
139 * headers: match.headers,
140 * }
141 * );
142 * },
143 * });
144 *
145 * @name unstable_matchRSCServerRequest
146 * @public
147 * @category RSC
148 * @mode data
149 * @param opts Options
150 * @param opts.allowedActionOrigins Origin patterns that are allowed to execute actions.
151 * @param opts.basename The basename to use when matching the request.
152 * @param opts.createTemporaryReferenceSet A function that returns a temporary
153 * reference set for the request, used to track temporary references in the [RSC](https://react.dev/reference/rsc/server-components)
154 * stream.
155 * @param opts.decodeAction Your `react-server-dom-xyz/server`'s `decodeAction`
156 * function, responsible for loading a server action.
157 * @param opts.decodeFormState A function responsible for decoding form state for
158 * progressively enhanceable forms with React's [`useActionState`](https://react.dev/reference/react/useActionState)
159 * using your `react-server-dom-xyz/server`'s `decodeFormState`.
160 * @param opts.decodeReply Your `react-server-dom-xyz/server`'s `decodeReply`
161 * function, used to decode the server function's arguments and bind them to the
162 * implementation for invocation by the router.
163 * @param opts.generateResponse A function responsible for using your
164 * `renderToReadableStream` to generate a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
165 * encoding the {@link unstable_RSCPayload}.
166 * @param opts.loadServerAction Your `react-server-dom-xyz/server`'s
167 * `loadServerAction` function, used to load a server action by ID.
168 * @param opts.onError An optional error handler that will be called with any
169 * errors that occur during the request processing.
170 * @param opts.request The [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
171 * to match against.
172 * @param opts.requestContext An instance of {@link RouterContextProvider}
173 * that should be created per request, to be passed to [`action`](../../start/data/route-object#action)s,
174 * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
175 * @param opts.routeDiscovery The route discovery configuration, used to determine how the router should discover new routes during navigations.
176 * @param opts.routes Your {@link unstable_RSCRouteConfigEntry | route definitions}.
177 * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
178 * that contains the [RSC](https://react.dev/reference/rsc/server-components)
179 * data for hydration.
180 */
181declare function matchRSCServerRequest({ allowedActionOrigins, createTemporaryReferenceSet, basename, decodeReply, requestContext, routeDiscovery, loadServerAction, decodeAction, decodeFormState, onError, request, routes, generateResponse, }: {
182 allowedActionOrigins?: string[];
183 createTemporaryReferenceSet: () => unknown;
184 basename?: string;
185 decodeReply?: DecodeReplyFunction;
186 decodeAction?: DecodeActionFunction;
187 decodeFormState?: DecodeFormStateFunction;
188 requestContext?: RouterContextProvider;
189 loadServerAction?: LoadServerActionFunction;
190 onError?: (error: unknown) => void;
191 request: Request;
192 routes: RSCRouteConfigEntry[];
193 routeDiscovery?: RouteDiscovery;
194 generateResponse: (match: RSCMatch, { onError, temporaryReferences, }: {
195 onError(error: unknown): string | undefined;
196 temporaryReferences: unknown;
197 }) => Response;
198}): Promise<Response>;
199
200type BrowserCreateFromReadableStreamFunction = (body: ReadableStream<Uint8Array>, { temporaryReferences, }: {
201 temporaryReferences: unknown;
202}) => Promise<unknown>;
203type EncodeReplyFunction = (args: unknown[], options: {
204 temporaryReferences: unknown;
205}) => Promise<BodyInit>;
206/**
207 * Create a React `callServer` implementation for React Router.
208 *
209 * @example
210 * import {
211 * createFromReadableStream,
212 * createTemporaryReferenceSet,
213 * encodeReply,
214 * setServerCallback,
215 * } from "@vitejs/plugin-rsc/browser";
216 * import { unstable_createCallServer as createCallServer } from "react-router";
217 *
218 * setServerCallback(
219 * createCallServer({
220 * createFromReadableStream,
221 * createTemporaryReferenceSet,
222 * encodeReply,
223 * })
224 * );
225 *
226 * @name unstable_createCallServer
227 * @public
228 * @category RSC
229 * @mode data
230 * @param opts Options
231 * @param opts.createFromReadableStream Your `react-server-dom-xyz/client`'s
232 * `createFromReadableStream`. Used to decode payloads from the server.
233 * @param opts.createTemporaryReferenceSet A function that creates a temporary
234 * reference set for the [RSC](https://react.dev/reference/rsc/server-components)
235 * payload.
236 * @param opts.encodeReply Your `react-server-dom-xyz/client`'s `encodeReply`.
237 * Used when sending payloads to the server.
238 * @param opts.fetch Optional [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
239 * implementation. Defaults to global [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch).
240 * @returns A function that can be used to call server actions.
241 */
242declare function createCallServer({ createFromReadableStream, createTemporaryReferenceSet, encodeReply, fetch: fetchImplementation, }: {
243 createFromReadableStream: BrowserCreateFromReadableStreamFunction;
244 createTemporaryReferenceSet: () => unknown;
245 encodeReply: EncodeReplyFunction;
246 fetch?: (request: Request) => Promise<Response>;
247}): (id: string, args: unknown[]) => Promise<unknown>;
248/**
249 * Props for the {@link unstable_RSCHydratedRouter} component.
250 *
251 * @name unstable_RSCHydratedRouterProps
252 * @category Types
253 */
254interface RSCHydratedRouterProps {
255 /**
256 * Your `react-server-dom-xyz/client`'s `createFromReadableStream` function,
257 * used to decode payloads from the server.
258 */
259 createFromReadableStream: BrowserCreateFromReadableStreamFunction;
260 /**
261 * Optional fetch implementation. Defaults to global [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch).
262 */
263 fetch?: (request: Request) => Promise<Response>;
264 /**
265 * The decoded {@link unstable_RSCPayload} to hydrate.
266 */
267 payload: RSCPayload;
268 /**
269 * A function that returns an {@link RouterContextProvider} instance
270 * which is provided as the `context` argument to client [`action`](../../start/data/route-object#action)s,
271 * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
272 * This function is called to generate a fresh `context` instance on each
273 * navigation or fetcher call.
274 */
275 getContext?: RouterInit["getContext"];
276}
277/**
278 * Hydrates a server rendered {@link unstable_RSCPayload} in the browser.
279 *
280 * @example
281 * import { startTransition, StrictMode } from "react";
282 * import { hydrateRoot } from "react-dom/client";
283 * import {
284 * unstable_getRSCStream as getRSCStream,
285 * unstable_RSCHydratedRouter as RSCHydratedRouter,
286 * } from "react-router";
287 * import type { unstable_RSCPayload as RSCPayload } from "react-router";
288 *
289 * createFromReadableStream(getRSCStream()).then((payload) =>
290 * startTransition(async () => {
291 * hydrateRoot(
292 * document,
293 * <StrictMode>
294 * <RSCHydratedRouter
295 * createFromReadableStream={createFromReadableStream}
296 * payload={payload}
297 * />
298 * </StrictMode>,
299 * { formState: await getFormState(payload) },
300 * );
301 * }),
302 * );
303 *
304 * @name unstable_RSCHydratedRouter
305 * @public
306 * @category RSC
307 * @mode data
308 * @param props Props
309 * @param {unstable_RSCHydratedRouterProps.createFromReadableStream} props.createFromReadableStream n/a
310 * @param {unstable_RSCHydratedRouterProps.fetch} props.fetch n/a
311 * @param {unstable_RSCHydratedRouterProps.getContext} props.getContext n/a
312 * @param {unstable_RSCHydratedRouterProps.payload} props.payload n/a
313 * @returns A hydrated {@link DataRouter} that can be used to navigate and
314 * render routes.
315 */
316declare function RSCHydratedRouter({ createFromReadableStream, fetch: fetchImplementation, payload, getContext, }: RSCHydratedRouterProps): React.JSX.Element;
317
318export { type BrowserCreateFromReadableStreamFunction as B, type DecodeActionFunction as D, type EncodeReplyFunction as E, type LoadServerActionFunction as L, RSCHydratedRouter as R, type DecodeFormStateFunction as a, type DecodeReplyFunction as b, createCallServer as c, type RSCManifestPayload as d, type RSCPayload as e, type RSCRenderPayload as f, getRequest as g, type RSCHydratedRouterProps as h, type RSCMatch as i, type RSCRouteManifest as j, type RSCRouteMatch as k, type RSCRouteConfigEntry as l, matchRSCServerRequest as m, type RSCRouteConfig as n };