react-router 7.18.0 → 8.0.0-pre.1

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

@@ -0,0 +1,43 @@
+/**
+ * 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/crypto.ts
+const encoder = /* @__PURE__ */ new TextEncoder();
+const sign = async (value, secret) => {
+	let data = encoder.encode(value);
+	let key = await createKey(secret, ["sign"]);
+	let signature = await crypto.subtle.sign("HMAC", key, data);
+	let hash = btoa(String.fromCharCode(...new Uint8Array(signature))).replace(/=+$/, "");
+	return value + "." + hash;
+};
+const unsign = async (cookie, secret) => {
+	let index = cookie.lastIndexOf(".");
+	let value = cookie.slice(0, index);
+	let hash = cookie.slice(index + 1);
+	let data = encoder.encode(value);
+	let key = await createKey(secret, ["verify"]);
+	try {
+		let signature = byteStringToUint8Array(atob(hash));
+		return await crypto.subtle.verify("HMAC", key, signature, data) ? value : false;
+	} catch (e) {
+		return false;
+	}
+};
+const createKey = async (secret, usages) => crypto.subtle.importKey("raw", encoder.encode(secret), {
+	name: "HMAC",
+	hash: "SHA-256"
+}, false, usages);
+function byteStringToUint8Array(byteString) {
+	let array = new Uint8Array(byteString.length);
+	for (let i = 0; i < byteString.length; i++) array[i] = byteString.charCodeAt(i);
+	return array;
+}
+//#endregion
+export { sign, unsign };

package/dist/development/lib/server-runtime/data.d.ts

@@ -0,0 +1,13 @@
+
+//#region lib/server-runtime/data.d.ts
+/**
+ * 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;
+}
+//#endregion
+export { AppLoadContext };

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

@@ -0,0 +1,25 @@
+/**
+ * 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 { isDataWithResponseInit, isRedirectStatusCode } from "../router/router.js";
+//#region lib/server-runtime/data.ts
+async function callRouteHandler(handler, args) {
+	let result = await handler({
+		request: args.request,
+		url: args.url,
+		params: args.params,
+		context: args.context,
+		pattern: args.pattern
+	});
+	if (isDataWithResponseInit(result) && result.init && result.init.status && isRedirectStatusCode(result.init.status)) throw new Response(null, result.init);
+	return result;
+}
+//#endregion
+export { callRouteHandler };

package/dist/development/lib/server-runtime/dev.d.ts

@@ -0,0 +1,9 @@
+
+//#region lib/server-runtime/dev.d.ts
+type DevServerHooks = {
+  getCriticalCss?: (pathname: string) => Promise<string | undefined>;
+  processRequestError?: (error: unknown) => void;
+};
+declare function setDevServerHooks(devServerHooks: DevServerHooks): void;
+//#endregion
+export { setDevServerHooks };

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

@@ -0,0 +1,26 @@
+/**
+ * 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/dev.ts
+const globalDevServerHooksKey = "__reactRouterDevServerHooks";
+function setDevServerHooks(devServerHooks) {
+	globalThis[globalDevServerHooksKey] = devServerHooks;
+}
+function getDevServerHooks() {
+	return globalThis[globalDevServerHooksKey];
+}
+function getBuildTimeHeader(request, headerName) {
+	if (typeof process !== "undefined") try {
+		if (process.env.hasOwnProperty("IS_RR_BUILD_REQUEST") && process.env.IS_RR_BUILD_REQUEST === "yes") return request.headers.get(headerName);
+	} catch (e) {}
+	return null;
+}
+//#endregion
+export { getBuildTimeHeader, getDevServerHooks, setDevServerHooks };

package/dist/development/lib/server-runtime/entry.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/entry.ts
+function createEntryRouteModules(manifest) {
+	return Object.keys(manifest).reduce((memo, routeId) => {
+		let route = manifest[routeId];
+		if (route) memo[routeId] = route.module;
+		return memo;
+	}, {});
+}
+//#endregion
+export { createEntryRouteModules };

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

@@ -0,0 +1,75 @@
+/**
+ * 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 "./mode.js";
+//#region lib/server-runtime/errors.ts
+/**
+* This thing probably warrants some explanation.
+*
+* The whole point here is to emulate componentDidCatch for server rendering and
+* data loading. It can get tricky. React can do this on component boundaries
+* but doesn't support it for server rendering or data loading. We know enough
+* with nested routes to be able to emulate the behavior (because we know them
+* statically before rendering.)
+*
+* Each route can export an `ErrorBoundary`.
+*
+* - When rendering throws an error, the nearest error boundary will render
+*   (normal react componentDidCatch). This will be the route's own boundary, but
+*   if none is provided, it will bubble up to the parents.
+* - When data loading throws an error, the nearest error boundary will render
+* - When performing an action, the nearest error boundary for the action's
+*   route tree will render (no redirect happens)
+*
+* During normal react rendering, we do nothing special, just normal
+* componentDidCatch.
+*
+* For server rendering, we mutate `renderBoundaryRouteId` to know the last
+* layout that has an error boundary that tried to render. This emulates which
+* layout would catch a thrown error. If the rendering fails, we catch the error
+* on the server, and go again a second time with the emulator holding on to the
+* information it needs to render the same error boundary as a dynamically
+* thrown render error.
+*
+* When data loading, server or client side, we use the emulator to likewise
+* hang on to the error and re-render at the appropriate layout (where a thrown
+* error would have been caught by cDC).
+*
+* When actions throw, it all works the same. There's an edge case to be aware
+* of though. Actions normally are required to redirect, but in the case of
+* errors, we render the action's route with the emulator holding on to the
+* error. If during this render a parent route/loader throws we ignore that new
+* error and render the action's original error as deeply as possible. In other
+* words, we simply ignore the new error and use the action's error in place
+* because it came first, and that just wouldn't be fair to let errors cut in
+* line.
+*/
+function sanitizeError(error, serverMode) {
+	if (error instanceof Error && serverMode !== "development") {
+		let sanitized = /* @__PURE__ */ new Error("Unexpected Server Error");
+		sanitized.stack = void 0;
+		return sanitized;
+	}
+	return error;
+}
+function sanitizeErrors(errors, serverMode) {
+	return Object.entries(errors).reduce((acc, [routeId, error]) => {
+		return Object.assign(acc, { [routeId]: sanitizeError(error, serverMode) });
+	}, {});
+}
+function serializeError(error, serverMode) {
+	let sanitized = sanitizeError(error, serverMode);
+	return {
+		message: sanitized.message,
+		stack: sanitized.stack
+	};
+}
+//#endregion
+export { sanitizeError, sanitizeErrors, serializeError };

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

@@ -0,0 +1,73 @@
+/**
+ * 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 invariant from "./invariant.js";
+import { splitSetCookieString } from "cookie-es";
+//#region lib/server-runtime/headers.ts
+function getDocumentHeaders(context, build) {
+	return getDocumentHeadersImpl(context, (m) => {
+		let route = build.routes[m.route.id];
+		invariant(route, `Route with id "${m.route.id}" not found in build`);
+		return route.module.headers;
+	});
+}
+function getDocumentHeadersImpl(context, getRouteHeadersFn, _defaultHeaders) {
+	let boundaryIdx = context.errors ? context.matches.findIndex((m) => context.errors[m.route.id]) : -1;
+	let matches = boundaryIdx >= 0 ? context.matches.slice(0, boundaryIdx + 1) : context.matches;
+	let errorHeaders;
+	if (boundaryIdx >= 0) {
+		let { actionHeaders, actionData, loaderHeaders, loaderData } = context;
+		context.matches.slice(boundaryIdx).some((match) => {
+			let id = match.route.id;
+			if (actionHeaders[id] && (!actionData || !actionData.hasOwnProperty(id))) errorHeaders = actionHeaders[id];
+			else if (loaderHeaders[id] && !loaderData.hasOwnProperty(id)) errorHeaders = loaderHeaders[id];
+			return errorHeaders != null;
+		});
+	}
+	const defaultHeaders = new Headers(_defaultHeaders);
+	return matches.reduce((parentHeaders, match, idx) => {
+		let { id } = match.route;
+		let loaderHeaders = context.loaderHeaders[id] || new Headers();
+		let actionHeaders = context.actionHeaders[id] || new Headers();
+		let includeErrorHeaders = errorHeaders != null && idx === matches.length - 1;
+		let includeErrorCookies = includeErrorHeaders && errorHeaders !== loaderHeaders && errorHeaders !== actionHeaders;
+		let headersFn = getRouteHeadersFn(match);
+		if (headersFn == null) {
+			let headers = new Headers(parentHeaders);
+			if (includeErrorCookies) prependCookies(errorHeaders, headers);
+			prependCookies(actionHeaders, headers);
+			prependCookies(loaderHeaders, headers);
+			return headers;
+		}
+		let headers = new Headers(typeof headersFn === "function" ? headersFn({
+			loaderHeaders,
+			parentHeaders,
+			actionHeaders,
+			errorHeaders: includeErrorHeaders ? errorHeaders : void 0
+		}) : headersFn);
+		if (includeErrorCookies) prependCookies(errorHeaders, headers);
+		prependCookies(actionHeaders, headers);
+		prependCookies(loaderHeaders, headers);
+		prependCookies(parentHeaders, headers);
+		return headers;
+	}, new Headers(defaultHeaders));
+}
+function prependCookies(parentHeaders, childHeaders) {
+	let parentSetCookieString = parentHeaders.get("Set-Cookie");
+	if (parentSetCookieString) {
+		let cookies = splitSetCookieString(parentSetCookieString);
+		let childCookies = new Set(childHeaders.getSetCookie());
+		cookies.forEach((cookie) => {
+			if (!childCookies.has(cookie)) childHeaders.append("Set-Cookie", cookie);
+		});
+	}
+}
+//#endregion
+export { getDocumentHeaders };

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

@@ -0,0 +1,19 @@
+/**
+ * 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/invariant.ts
+function invariant(value, message) {
+	if (value === false || value === null || typeof value === "undefined") {
+		console.error("The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose");
+		throw new Error(message);
+	}
+}
+//#endregion
+export { invariant as default };

package/dist/development/lib/server-runtime/mode.d.ts

@@ -0,0 +1,12 @@
+
+//#region lib/server-runtime/mode.d.ts
+/**
+ * The mode to use when running the server.
+ */
+declare enum ServerMode {
+  Development = "development",
+  Production = "production",
+  Test = "test"
+}
+//#endregion
+export { ServerMode };

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

@@ -0,0 +1,25 @@
+/**
+ * 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/mode.ts
+/**
+* The mode to use when running the server.
+*/
+let ServerMode = /* @__PURE__ */ function(ServerMode) {
+	ServerMode["Development"] = "development";
+	ServerMode["Production"] = "production";
+	ServerMode["Test"] = "test";
+	return ServerMode;
+}({});
+function isServerMode(value) {
+	return value === "development" || value === "production" || value === "test";
+}
+//#endregion
+export { ServerMode, isServerMode };

package/dist/development/lib/server-runtime/routeMatching.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
+ */
+import { matchRoutesImpl } from "../router/utils.js";
+import invariant from "./invariant.js";
+//#region lib/server-runtime/routeMatching.ts
+function matchServerRoutes(manifest, dataRoutes, branches, pathname, basename) {
+	let matches = matchRoutesImpl(dataRoutes, pathname, basename ?? "/", false, branches);
+	if (!matches) return null;
+	return matches.map((match) => {
+		let route = manifest[match.route.id];
+		invariant(route, `Route with id "${match.route.id}" not found in manifest.`);
+		return {
+			params: match.params,
+			pathname: match.pathname,
+			route
+		};
+	});
+}
+//#endregion
+export { matchServerRoutes };

package/dist/development/lib/server-runtime/routes.d.ts

@@ -0,0 +1,13 @@
+
+import { RouteManifest } from "../router/utils.js";
+import { ServerRouteModule } from "../dom/ssr/routeModules.js";
+import { Route } from "../dom/ssr/routes.js";
+
+//#region lib/server-runtime/routes.d.ts
+type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
+interface ServerRoute extends Route {
+  children: ServerRoute[];
+  module: ServerRouteModule;
+}
+//#endregion
+export { ServerRouteManifest };

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

@@ -0,0 +1,74 @@
+/**
+ * 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 { redirect, redirectDocument, replace } from "../router/utils.js";
+import { SingleFetchRedirectSymbol, decodeViaTurboStream } from "../dom/ssr/single-fetch.js";
+import invariant from "./invariant.js";
+import { callRouteHandler } from "./data.js";
+import { getBuildTimeHeader } from "./dev.js";
+//#region lib/server-runtime/routes.ts
+function groupRoutesByParentId(manifest) {
+	let routes = {};
+	Object.values(manifest).forEach((route) => {
+		if (route) {
+			let parentId = route.parentId || "";
+			if (!routes[parentId]) routes[parentId] = [];
+			routes[parentId].push(route);
+		}
+	});
+	return routes;
+}
+function createStaticHandlerDataRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
+	return (routesByParentId[parentId] || []).map((route) => {
+		let commonRoute = {
+			id: route.id,
+			path: route.path,
+			middleware: route.module.middleware,
+			loader: route.module.loader ? async (args) => {
+				let preRenderedData = getBuildTimeHeader(args.request, "X-React-Router-Prerender-Data");
+				if (preRenderedData != null) {
+					let encoded = preRenderedData ? decodeURI(preRenderedData) : preRenderedData;
+					invariant(encoded, "Missing prerendered data for route");
+					let uint8array = new TextEncoder().encode(encoded);
+					let data = (await decodeViaTurboStream(new ReadableStream({ start(controller) {
+						controller.enqueue(uint8array);
+						controller.close();
+					} }), global)).value;
+					if (data && SingleFetchRedirectSymbol in data) {
+						let result = data[SingleFetchRedirectSymbol];
+						let init = { status: result.status };
+						if (result.reload) throw redirectDocument(result.redirect, init);
+						else if (result.replace) throw replace(result.redirect, init);
+						else throw redirect(result.redirect, init);
+					} else {
+						invariant(data && route.id in data, "Unable to decode prerendered data");
+						let result = data[route.id];
+						invariant("data" in result, "Unable to process prerendered data");
+						return result.data;
+					}
+				}
+				return await callRouteHandler(route.module.loader, args);
+			} : void 0,
+			action: route.module.action ? (args) => callRouteHandler(route.module.action, args) : void 0,
+			ErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null ? () => null : void 0,
+			handle: route.module.handle
+		};
+		return route.index ? {
+			index: true,
+			...commonRoute
+		} : {
+			caseSensitive: route.caseSensitive,
+			children: createStaticHandlerDataRoutes(manifest, route.id, routesByParentId),
+			...commonRoute
+		};
+	});
+}
+//#endregion
+export { createStaticHandlerDataRoutes };

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

@@ -0,0 +1,10 @@
+
+import { RouterContextProvider } from "../router/utils.js";
+import { ServerBuild } from "./build.js";
+
+//#region lib/server-runtime/server.d.ts
+type RequestHandler = (request: Request, loadContext?: RouterContextProvider) => Promise<Response>;
+type CreateRequestHandlerFunction = (build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>), mode?: string) => RequestHandler;
+declare const createRequestHandler: CreateRequestHandlerFunction;
+//#endregion
+export { CreateRequestHandlerFunction, RequestHandler, createRequestHandler };