react-router 7.15.1 → 8.3.0

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

@@ -0,0 +1,92 @@
+
+import { CookieParseOptions as CookieParseOptions$1, CookieSerializeOptions as CookieSerializeOptions$1 } from "cookie-es";
+
+//#region lib/server-runtime/cookies.d.ts
+interface CookieSignatureOptions {
+  /**
+   * An array of secrets that may be used to sign/unsign the value of a cookie.
+   *
+   * The array makes it easy to rotate secrets. New secrets should be added to
+   * the beginning of the array. `cookie.serialize()` will always use the first
+   * value in the array, but `cookie.parse()` may use any of them so that
+   * cookies that were signed with older secrets still work.
+   */
+  secrets?: string[];
+}
+type CookieOptions = CookieParseOptions$1 & CookieSerializeOptions$1 & CookieSignatureOptions;
+/**
+ * A HTTP cookie.
+ *
+ * A Cookie is a logical container for metadata about a HTTP cookie; its name
+ * and options. But it doesn't contain a value. Instead, it has `parse()` and
+ * `serialize()` methods that allow a single instance to be reused for
+ * parsing/encoding multiple different values.
+ *
+ * @see https://remix.run/utils/cookies#cookie-api
+ */
+interface Cookie {
+  /**
+   * The name of the cookie, used in the `Cookie` and `Set-Cookie` headers.
+   */
+  readonly name: string;
+  /**
+   * True if this cookie uses one or more secrets for verification.
+   */
+  readonly isSigned: boolean;
+  /**
+   * The Date this cookie expires.
+   *
+   * Note: This is calculated at access time using `maxAge` when no `expires`
+   * option is provided to `createCookie()`.
+   */
+  readonly expires?: Date;
+  /**
+   * Parses a raw `Cookie` header and returns the value of this cookie or
+   * `null` if it's not present.
+   */
+  parse(cookieHeader: string | null, options?: CookieParseOptions$1): Promise<any>;
+  /**
+   * Serializes the given value to a string and returns the `Set-Cookie`
+   * header.
+   */
+  serialize(value: any, options?: CookieSerializeOptions$1): Promise<string>;
+}
+/**
+ * Creates a logical container for managing a browser cookie from the server.
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
+ * @param name The name of the cookie.
+ * @param cookieOptions Options for parsing and serializing the cookie.
+ * @returns A {@link Cookie} object for parsing and serializing the cookie.
+ */
+declare const createCookie: (name: string, cookieOptions?: CookieOptions) => Cookie;
+/**
+ * A function that determines whether a value is a React Router {@link Cookie}
+ * object.
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
+ * @param object The value to check.
+ * @returns `true` if the value is a React Router {@link Cookie} object;
+ * otherwise, `false`.
+ */
+type IsCookieFunction = (object: any) => object is Cookie;
+/**
+ * Returns `true` if a value is a React Router {@link Cookie} object.
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
+ * @param object The value to check.
+ * @returns `true` if the value is a React Router {@link Cookie} object;
+ * otherwise, `false`.
+ */
+declare const isCookie: IsCookieFunction;
+//#endregion
+export { Cookie, CookieOptions, type CookieParseOptions$1 as CookieParseOptions, type CookieSerializeOptions$1 as CookieSerializeOptions, CookieSignatureOptions, IsCookieFunction, createCookie, isCookie };

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

@@ -0,0 +1,153 @@
+/**
+ * react-router v8.3.0
+ *
+ * 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 { sign, unsign } from "./crypto.js";
+import { parse, serialize } from "cookie-es";
+//#region lib/server-runtime/cookies.ts
+/**
+* Creates a logical container for managing a browser cookie from the server.
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param name The name of the cookie.
+* @param cookieOptions Options for parsing and serializing the cookie.
+* @returns A {@link Cookie} object for parsing and serializing the cookie.
+*/
+const createCookie = (name, cookieOptions = {}) => {
+	let { secrets = [], ...options } = {
+		path: "/",
+		sameSite: "lax",
+		...cookieOptions
+	};
+	warnOnceAboutExpiresCookie(name, options.expires);
+	return {
+		get name() {
+			return name;
+		},
+		get isSigned() {
+			return secrets.length > 0;
+		},
+		get expires() {
+			return typeof options.maxAge !== "undefined" ? new Date(Date.now() + options.maxAge * 1e3) : options.expires;
+		},
+		async parse(cookieHeader, parseOptions) {
+			if (!cookieHeader) return null;
+			let cookies = parse(cookieHeader, {
+				...options,
+				...parseOptions
+			});
+			if (name in cookies) {
+				let value = cookies[name];
+				if (typeof value === "string" && value !== "") return await decodeCookieValue(value, secrets);
+				else return "";
+			} else return null;
+		},
+		async serialize(value, serializeOptions) {
+			return serialize(name, value === "" ? "" : await encodeCookieValue(value, secrets), {
+				...options,
+				...serializeOptions
+			});
+		}
+	};
+};
+/**
+* Returns `true` if a value is a React Router {@link Cookie} object.
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param object The value to check.
+* @returns `true` if the value is a React Router {@link Cookie} object;
+* otherwise, `false`.
+*/
+const isCookie = (object) => {
+	return object != null && typeof object.name === "string" && typeof object.isSigned === "boolean" && typeof object.parse === "function" && typeof object.serialize === "function";
+};
+async function encodeCookieValue(value, secrets) {
+	let encoded = encodeData(value);
+	if (secrets.length > 0) encoded = await sign(encoded, secrets[0]);
+	return encoded;
+}
+async function decodeCookieValue(value, secrets) {
+	if (secrets.length > 0) {
+		for (let secret of secrets) {
+			let unsignedValue = await unsign(value, secret);
+			if (unsignedValue !== false) return decodeData(unsignedValue);
+		}
+		return null;
+	}
+	return decodeData(value);
+}
+function encodeData(value) {
+	return btoa(myUnescape(encodeURIComponent(JSON.stringify(value))));
+}
+function decodeData(value) {
+	try {
+		return JSON.parse(decodeURIComponent(myEscape(atob(value))));
+	} catch (e) {
+		return {};
+	}
+}
+function myEscape(value) {
+	let str = value.toString();
+	let result = "";
+	let index = 0;
+	let chr, code;
+	while (index < str.length) {
+		chr = str.charAt(index++);
+		if (/[\w*+\-./@]/.exec(chr)) result += chr;
+		else {
+			code = chr.charCodeAt(0);
+			if (code < 256) result += "%" + hex(code, 2);
+			else result += "%u" + hex(code, 4).toUpperCase();
+		}
+	}
+	return result;
+}
+function hex(code, length) {
+	let result = code.toString(16);
+	while (result.length < length) result = "0" + result;
+	return result;
+}
+function myUnescape(value) {
+	let str = value.toString();
+	let result = "";
+	let index = 0;
+	let chr, part;
+	while (index < str.length) {
+		chr = str.charAt(index++);
+		if (chr === "%") if (str.charAt(index) === "u") {
+			part = str.slice(index + 1, index + 5);
+			if (/^[\da-f]{4}$/i.exec(part)) {
+				result += String.fromCharCode(parseInt(part, 16));
+				index += 5;
+				continue;
+			}
+		} else {
+			part = str.slice(index, index + 2);
+			if (/^[\da-f]{2}$/i.exec(part)) {
+				result += String.fromCharCode(parseInt(part, 16));
+				index += 2;
+				continue;
+			}
+		}
+		result += chr;
+	}
+	return result;
+}
+function warnOnceAboutExpiresCookie(name, expires) {
+	warnOnce(!expires, `The "${name}" cookie has an "expires" property set. This will cause the expires value to not be updated when the session is committed. Instead, you should set the expires value when serializing the cookie. You can use \`commitSession(session, { expires })\` if using a session storage object, or \`cookie.serialize("value", { expires })\` if you're using the cookie directly.`);
+}
+//#endregion
+export { createCookie, isCookie };

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

@@ -0,0 +1,43 @@
+/**
+ * react-router v8.3.0
+ *
+ * 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.js

@@ -0,0 +1,25 @@
+/**
+ * react-router v8.3.0
+ *
+ * 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.3.0
+ *
+ * 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.3.0
+ *
+ * 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.3.0
+ *
+ * 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.3.0
+ *
+ * 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.3.0
+ *
+ * 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.3.0
+ *
+ * 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.3.0
+ *
+ * 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 };