react-router 7.18.0 → 8.0.0-pre.1

package/dist/development/lib/server-runtime/sessions.js

@@ -0,0 +1,98 @@
+/**
+ * react-router v8.0.0-pre.1
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { warnOnce } from "./warnings.js";
+import { createCookie, isCookie } from "./cookies.js";
+//#region lib/server-runtime/sessions.ts
+function flash(name) {
+	return `__flash_${name}__`;
+}
+/**
+* Creates a new Session object.
+*
+* Note: This function is typically not invoked directly by application code.
+* Instead, use a `SessionStorage` object's `getSession` method.
+*/
+const createSession = (initialData = {}, id = "") => {
+	let map = new Map(Object.entries(initialData));
+	return {
+		get id() {
+			return id;
+		},
+		get data() {
+			return Object.fromEntries(map);
+		},
+		has(name) {
+			return map.has(name) || map.has(flash(name));
+		},
+		get(name) {
+			if (map.has(name)) return map.get(name);
+			let flashName = flash(name);
+			if (map.has(flashName)) {
+				let value = map.get(flashName);
+				map.delete(flashName);
+				return value;
+			}
+		},
+		set(name, value) {
+			map.set(name, value);
+		},
+		flash(name, value) {
+			map.set(flash(name), value);
+		},
+		unset(name) {
+			map.delete(name);
+		}
+	};
+};
+/**
+* Returns true if an object is a React Router session.
+*
+* @see https://reactrouter.com/api/utils/isSession
+*/
+const isSession = (object) => {
+	return object != null && typeof object.id === "string" && typeof object.data !== "undefined" && typeof object.has === "function" && typeof object.get === "function" && typeof object.set === "function" && typeof object.flash === "function" && typeof object.unset === "function";
+};
+/**
+* Creates a SessionStorage object using a SessionIdStorageStrategy.
+*
+* Note: This is a low-level API that should only be used if none of the
+* existing session storage options meet your requirements.
+*/
+function createSessionStorage({ cookie: cookieArg, createData, readData, updateData, deleteData }) {
+	let cookie = isCookie(cookieArg) ? cookieArg : createCookie(cookieArg?.name || "__session", cookieArg);
+	warnOnceAboutSigningSessionCookie(cookie);
+	return {
+		async getSession(cookieHeader, options) {
+			let id = cookieHeader && await cookie.parse(cookieHeader, options);
+			return createSession(id && await readData(id) || {}, id || "");
+		},
+		async commitSession(session, options) {
+			let { id, data } = session;
+			let expires = options?.maxAge != null ? new Date(Date.now() + options.maxAge * 1e3) : options?.expires != null ? options.expires : cookie.expires;
+			if (id) await updateData(id, data, expires);
+			else id = await createData(data, expires);
+			return cookie.serialize(id, options);
+		},
+		async destroySession(session, options) {
+			await deleteData(session.id);
+			return cookie.serialize("", {
+				...options,
+				maxAge: void 0,
+				expires: /* @__PURE__ */ new Date(0)
+			});
+		}
+	};
+}
+function warnOnceAboutSigningSessionCookie(cookie) {
+	warnOnce(cookie.isSigned, `The "${cookie.name}" cookie is not signed, but session cookies should be signed to prevent tampering on the client before they are sent back to the server. See https://reactrouter.com/explanation/sessions-and-cookies#signing-cookies for more information.`);
+}
+//#endregion
+export { createSession, createSessionStorage, isSession, warnOnceAboutSigningSessionCookie };

package/dist/development/lib/server-runtime/single-fetch.d.ts

@@ -0,0 +1,7 @@
+
+//#region lib/server-runtime/single-fetch.d.ts
+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>;
+//#endregion
+export { Serializable };

package/dist/development/lib/server-runtime/single-fetch.js

@@ -0,0 +1,215 @@
+/**
+ * react-router v8.0.0-pre.1
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { ErrorResponseImpl, isRouteErrorResponse, stripBasename } from "../router/utils.js";
+import { isRedirectStatusCode, isResponse } from "../router/router.js";
+import { encode } from "../../vendor/turbo-stream-v2/turbo-stream.js";
+import { NO_BODY_STATUS_CODES, SingleFetchRedirectSymbol } from "../dom/ssr/single-fetch.js";
+import "./mode.js";
+import { sanitizeError, sanitizeErrors } from "./errors.js";
+import { getDocumentHeaders } from "./headers.js";
+import { throwIfPotentialCSRFAttack } from "../actions.js";
+import { getNormalizedPath } from "./urls.js";
+//#region lib/server-runtime/single-fetch.ts
+const SERVER_NO_BODY_STATUS_CODES = new Set([...NO_BODY_STATUS_CODES, 304]);
+async function singleFetchAction(build, serverMode, staticHandler, request, loadContext, handleError) {
+	try {
+		try {
+			throwIfPotentialCSRFAttack(request, Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []);
+		} catch (e) {
+			return handleQueryError(/* @__PURE__ */ new Error("Bad Request"), 400);
+		}
+		return handleQueryResult(await staticHandler.query(request, {
+			requestContext: loadContext,
+			skipLoaderErrorBubbling: true,
+			skipRevalidation: true,
+			generateMiddlewareResponse: async (query) => {
+				try {
+					return handleQueryResult(await query(request));
+				} catch (error) {
+					return handleQueryError(error);
+				}
+			},
+			normalizePath: (r) => getNormalizedPath(r)
+		}));
+	} catch (error) {
+		return handleQueryError(error);
+	}
+	function handleQueryResult(result) {
+		return isResponse(result) ? result : staticContextToResponse(result);
+	}
+	function handleQueryError(error, status = 500) {
+		handleError(error);
+		return generateSingleFetchResponse(request, build, serverMode, {
+			result: { error },
+			headers: new Headers(),
+			status
+		});
+	}
+	function staticContextToResponse(context) {
+		let headers = getDocumentHeaders(context, build);
+		if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) return new Response(null, {
+			status: context.statusCode,
+			headers
+		});
+		if (context.errors) {
+			Object.values(context.errors).forEach((err) => {
+				if (!isRouteErrorResponse(err) || err.error) handleError(err);
+			});
+			context.errors = sanitizeErrors(context.errors, serverMode);
+		}
+		let singleFetchResult;
+		if (context.errors) singleFetchResult = { error: Object.values(context.errors)[0] };
+		else singleFetchResult = { data: Object.values(context.actionData || {})[0] };
+		return generateSingleFetchResponse(request, build, serverMode, {
+			result: singleFetchResult,
+			headers,
+			status: context.statusCode
+		});
+	}
+}
+async function singleFetchLoaders(build, serverMode, staticHandler, request, loadContext, handleError) {
+	let routesParam = new URL(request.url).searchParams.get("_routes");
+	let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
+	try {
+		return handleQueryResult(await staticHandler.query(request, {
+			requestContext: loadContext,
+			filterMatchesToLoad: (m) => !loadRouteIds || loadRouteIds.has(m.route.id),
+			skipLoaderErrorBubbling: true,
+			generateMiddlewareResponse: async (query) => {
+				try {
+					return handleQueryResult(await query(request));
+				} catch (error) {
+					return handleQueryError(error);
+				}
+			},
+			normalizePath: (r) => getNormalizedPath(r)
+		}));
+	} catch (error) {
+		return handleQueryError(error);
+	}
+	function handleQueryResult(result) {
+		return isResponse(result) ? result : staticContextToResponse(result);
+	}
+	function handleQueryError(error) {
+		handleError(error);
+		return generateSingleFetchResponse(request, build, serverMode, {
+			result: { error },
+			headers: new Headers(),
+			status: 500
+		});
+	}
+	function staticContextToResponse(context) {
+		let headers = getDocumentHeaders(context, build);
+		if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) return new Response(null, {
+			status: context.statusCode,
+			headers
+		});
+		if (context.errors) {
+			Object.values(context.errors).forEach((err) => {
+				if (!isRouteErrorResponse(err) || err.error) handleError(err);
+			});
+			context.errors = sanitizeErrors(context.errors, serverMode);
+		}
+		let results = {};
+		let loadedMatches = new Set(context.matches.filter((m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null).map((m) => m.route.id));
+		if (context.errors) for (let [id, error] of Object.entries(context.errors)) results[id] = { error };
+		for (let [id, data] of Object.entries(context.loaderData)) if (!(id in results) && loadedMatches.has(id)) results[id] = { data };
+		return generateSingleFetchResponse(request, build, serverMode, {
+			result: results,
+			headers,
+			status: context.statusCode
+		});
+	}
+}
+function generateSingleFetchResponse(request, build, serverMode, { result, headers, status }) {
+	let resultHeaders = new Headers(headers);
+	resultHeaders.set("X-Remix-Response", "yes");
+	if (SERVER_NO_BODY_STATUS_CODES.has(status)) return new Response(null, {
+		status,
+		headers: resultHeaders
+	});
+	resultHeaders.set("Content-Type", "text/x-script");
+	resultHeaders.delete("Content-Length");
+	return new Response(encodeViaTurboStream(result, request.signal, build.entry.module.streamTimeout, serverMode), {
+		status: status || 200,
+		headers: resultHeaders
+	});
+}
+function generateSingleFetchRedirectResponse(redirectResponse, request, build, serverMode) {
+	let redirect = getSingleFetchRedirect(redirectResponse.status, redirectResponse.headers, build.basename);
+	let headers = new Headers(redirectResponse.headers);
+	headers.delete("Location");
+	headers.set("Content-Type", "text/x-script");
+	return generateSingleFetchResponse(request, build, serverMode, {
+		result: request.method === "GET" ? { [SingleFetchRedirectSymbol]: redirect } : redirect,
+		headers,
+		status: 202
+	});
+}
+function getSingleFetchRedirect(status, headers, basename) {
+	let redirect = headers.get("Location");
+	if (basename) redirect = stripBasename(redirect, basename) || redirect;
+	return {
+		redirect,
+		status,
+		revalidate: headers.has("X-Remix-Revalidate") || headers.has("Set-Cookie"),
+		reload: headers.has("X-Remix-Reload-Document"),
+		replace: headers.has("X-Remix-Replace")
+	};
+}
+function encodeViaTurboStream(data, requestSignal, streamTimeout, serverMode) {
+	let controller = new AbortController();
+	let timeoutId = setTimeout(() => {
+		controller.abort(/* @__PURE__ */ new Error("Server Timeout"));
+		cleanupCallbacks();
+	}, typeof streamTimeout === "number" ? streamTimeout : 4950);
+	let abortControllerOnRequestAbort = () => {
+		controller.abort(requestSignal.reason);
+		cleanupCallbacks();
+	};
+	requestSignal.addEventListener("abort", abortControllerOnRequestAbort);
+	let cleanupCallbacks = () => {
+		clearTimeout(timeoutId);
+		requestSignal.removeEventListener("abort", abortControllerOnRequestAbort);
+	};
+	return encode(data, {
+		signal: controller.signal,
+		onComplete: cleanupCallbacks,
+		plugins: [(value) => {
+			if (value instanceof Error) {
+				let { name, message, stack } = serverMode === "production" ? sanitizeError(value, serverMode) : value;
+				return [
+					"SanitizedError",
+					name,
+					message,
+					stack
+				];
+			}
+			if (value instanceof ErrorResponseImpl) {
+				let { data, status, statusText } = value;
+				return [
+					"ErrorResponse",
+					data,
+					status,
+					statusText
+				];
+			}
+			if (value && typeof value === "object" && SingleFetchRedirectSymbol in value) return ["SingleFetchRedirect", value[SingleFetchRedirectSymbol]];
+		}],
+		postPlugins: [(value) => {
+			if (!value) return;
+			if (typeof value !== "object") return;
+			return ["SingleFetchClassInstance", Object.fromEntries(Object.entries(value))];
+		}, () => ["SingleFetchFallback"]]
+	});
+}
+//#endregion
+export { SERVER_NO_BODY_STATUS_CODES, encodeViaTurboStream, generateSingleFetchRedirectResponse, singleFetchAction, singleFetchLoaders };

package/dist/development/lib/server-runtime/urls.js

@@ -0,0 +1,28 @@
+/**
+ * react-router v8.0.0-pre.1
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+//#region lib/server-runtime/urls.ts
+function getNormalizedPath(request) {
+	let url = new URL(request.url);
+	let pathname = url.pathname;
+	if (pathname.endsWith("/_.data")) pathname = pathname.replace(/_\.data$/, "");
+	else pathname = pathname.replace(/\.data$/, "");
+	let searchParams = new URLSearchParams(url.search);
+	searchParams.delete("_routes");
+	let search = searchParams.toString();
+	if (search) search = `?${search}`;
+	return {
+		pathname,
+		search,
+		hash: ""
+	};
+}
+//#endregion
+export { getNormalizedPath };

package/dist/development/lib/server-runtime/warnings.js

@@ -0,0 +1,20 @@
+/**
+ * react-router v8.0.0-pre.1
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+//#region lib/server-runtime/warnings.ts
+const alreadyWarned = {};
+function warnOnce(condition, message) {
+	if (!condition && !alreadyWarned[message]) {
+		alreadyWarned[message] = true;
+		console.warn(message);
+	}
+}
+//#endregion
+export { warnOnce };

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

@@ -0,0 +1,9 @@
+
+//#region lib/types/future.d.ts
+/**
+ * An augmentable interface users can modify in their app-code to opt into
+ * future-flag-specific types
+ */
+interface Future {}
+//#endregion
+export { Future };

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-CjO11-hU.js';
-import { R as RouteFiles, P as Pages } from '../../register-roq_0qYo.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.18.0
+/**
+ * react-router v8.0.0-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,3 +8,4 @@
  *
  * @license MIT
  */
+export {};

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

@@ -1,30 +1,24 @@
-import { R as RouteModule } from './data-CjO11-hU.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 };