react-router 7.15.1 → 8.3.0

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

@@ -0,0 +1,174 @@
+
+import { Cookie, CookieOptions } from "./cookies.js";
+import { CookieParseOptions, CookieSerializeOptions } from "cookie-es";
+
+//#region lib/server-runtime/sessions.d.ts
+/**
+ * An object of name/value pairs to be used in the session.
+ */
+interface SessionData {
+  [name: string]: any;
+}
+/**
+ * Session persists data across HTTP requests.
+ *
+ * @see https://reactrouter.com/explanation/sessions-and-cookies#sessions
+ */
+interface Session<Data = SessionData, FlashData = Data> {
+  /**
+   * A unique identifier for this session.
+   *
+   * Note: This will be the empty string for newly created sessions and
+   * sessions that are not backed by a database (i.e. cookie-based sessions).
+   */
+  readonly id: string;
+  /**
+   * The raw data contained in this session.
+   *
+   * This is useful mostly for SessionStorage internally to access the raw
+   * session data to persist.
+   */
+  readonly data: FlashSessionData<Data, FlashData>;
+  /**
+   * Returns `true` if the session has a value for the given `name`, `false`
+   * otherwise.
+   */
+  has(name: (keyof Data | keyof FlashData) & string): boolean;
+  /**
+   * Returns the value for the given `name` in this session.
+   */
+  get<Key extends (keyof Data | keyof FlashData) & string>(name: Key): (Key extends keyof Data ? Data[Key] : undefined) | (Key extends keyof FlashData ? FlashData[Key] : undefined) | undefined;
+  /**
+   * Sets a value in the session for the given `name`.
+   */
+  set<Key extends keyof Data & string>(name: Key, value: Data[Key]): void;
+  /**
+   * Sets a value in the session that is only valid until the next `get()`.
+   * This can be useful for temporary values, like error messages.
+   */
+  flash<Key extends keyof FlashData & string>(name: Key, value: FlashData[Key]): void;
+  /**
+   * Removes a value from the session.
+   */
+  unset(name: keyof Data & string): void;
+}
+type FlashSessionData<Data, FlashData> = Partial<Data & { [Key in keyof FlashData as FlashDataKey<Key & string>]: FlashData[Key] }>;
+type FlashDataKey<Key extends string> = `__flash_${Key}__`;
+type CreateSessionFunction = <Data = SessionData, FlashData = Data>(initialData?: Data, id?: string) => Session<Data, FlashData>;
+/**
+ * Creates a new Session object.
+ *
+ * Note: This function is typically not invoked directly by application code.
+ * Instead, use a `SessionStorage` object's `getSession` method.
+ *
+ * @category Utils
+ * @param initialData The initial data for the session.
+ * @param id The identifier for the session. Defaults to an empty string for a
+ * new session.
+ * @returns A new {@link Session} object.
+ */
+declare const createSession: CreateSessionFunction;
+/**
+ * A function that determines whether a value is a React Router {@link Session}
+ * object.
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
+ * @param object The value to check.
+ * @returns `true` if the value is a React Router {@link Session} object;
+ * otherwise, `false`.
+ */
+type IsSessionFunction = (object: any) => object is Session;
+/**
+ * Returns `true` if a value is a React Router {@link Session} object.
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
+ * @param object The value to check.
+ * @returns `true` if the value is a React Router {@link Session} object;
+ * otherwise, `false`.
+ */
+declare const isSession: IsSessionFunction;
+/**
+ * SessionStorage stores session data between HTTP requests and knows how to
+ * parse and create cookies.
+ *
+ * A SessionStorage creates Session objects using a `Cookie` header as input.
+ * Then, later it generates the `Set-Cookie` header to be used in the response.
+ */
+interface SessionStorage<Data = SessionData, FlashData = Data> {
+  /**
+   * Parses a Cookie header from a HTTP request and returns the associated
+   * Session. If there is no session associated with the cookie, this will
+   * return a new Session with no data.
+   */
+  getSession: (cookieHeader?: string | null, options?: CookieParseOptions) => Promise<Session<Data, FlashData>>;
+  /**
+   * Stores all data in the Session and returns the Set-Cookie header to be
+   * used in the HTTP response.
+   */
+  commitSession: (session: Session<Data, FlashData>, options?: CookieSerializeOptions) => Promise<string>;
+  /**
+   * Deletes all data associated with the Session and returns the Set-Cookie
+   * header to be used in the HTTP response.
+   */
+  destroySession: (session: Session<Data, FlashData>, options?: CookieSerializeOptions) => Promise<string>;
+}
+/**
+ * SessionIdStorageStrategy is designed to allow anyone to easily build their
+ * own SessionStorage using `createSessionStorage(strategy)`.
+ *
+ * This strategy describes a common scenario where the session id is stored in
+ * a cookie but the actual session data is stored elsewhere, usually in a
+ * database or on disk. A set of create, read, update, and delete operations
+ * are provided for managing the session data.
+ */
+interface SessionIdStorageStrategy<Data = SessionData, FlashData = Data> {
+  /**
+   * The Cookie used to store the session id, or options used to automatically
+   * create one.
+   */
+  cookie?: Cookie | (CookieOptions & {
+    name?: string;
+  });
+  /**
+   * Creates a new record with the given data and returns the session id.
+   */
+  createData: (data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<string>;
+  /**
+   * Returns data for a given session id, or `null` if there isn't any.
+   */
+  readData: (id: string) => Promise<FlashSessionData<Data, FlashData> | null>;
+  /**
+   * Updates data for the given session id.
+   */
+  updateData: (id: string, data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<void>;
+  /**
+   * Deletes data for a given session id from the data store.
+   */
+  deleteData: (id: string) => Promise<void>;
+}
+/**
+ * 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.
+ *
+ * @category Utils
+ * @param strategy The strategy used to store session identifiers and data.
+ * @returns A {@link SessionStorage} object that persists session data using the
+ * provided strategy.
+ */
+declare function createSessionStorage<Data = SessionData, FlashData = Data>({
+  cookie: cookieArg,
+  createData,
+  readData,
+  updateData,
+  deleteData
+}: SessionIdStorageStrategy<Data, FlashData>): SessionStorage<Data, FlashData>;
+//#endregion
+export { FlashSessionData, IsSessionFunction, Session, SessionData, SessionIdStorageStrategy, SessionStorage, createSession, createSessionStorage, isSession };

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

@@ -0,0 +1,115 @@
+/**
+ * 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 { 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.
+*
+* @category Utils
+* @param initialData The initial data for the session.
+* @param id The identifier for the session. Defaults to an empty string for a
+* new session.
+* @returns A new {@link Session} object.
+*/
+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 a value is a React Router {@link Session} object.
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param object The value to check.
+* @returns `true` if the value is a React Router {@link Session} object;
+* otherwise, `false`.
+*/
+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.
+*
+* @category Utils
+* @param strategy The strategy used to store session identifiers and data.
+* @returns A {@link SessionStorage} object that persists session data using the
+* provided strategy.
+*/
+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.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 { 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.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/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.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/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 };