react-router 7.16.0 → 8.0.0-pre.0

package/dist/production/lib/server-runtime/server.js

@@ -0,0 +1,351 @@
+/**
+ * react-router v8.0.0-pre.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, RouterContextProvider, defaultMapRouteProperties, isRouteErrorResponse, stripBasename } from "../router/utils.js";
+import { instrumentHandler } from "../router/instrumentation.js";
+import { createStaticHandler, getStaticContextFromError, isMutationMethod, isRedirectResponse, isResponse } from "../router/router.js";
+import { getManifestPath } from "../dom/ssr/fog-of-war.js";
+import { createEntryRouteModules } from "./entry.js";
+import { isServerMode } from "./mode.js";
+import { sanitizeErrors, serializeError, serializeErrors } from "./errors.js";
+import { matchServerRoutes } from "./routeMatching.js";
+import { getBuildTimeHeader, getDevServerHooks } from "./dev.js";
+import { createStaticHandlerDataRoutes } from "./routes.js";
+import { createServerHandoffString } from "./serverHandoff.js";
+import { getDocumentHeaders } from "./headers.js";
+import { throwIfPotentialCSRFAttack } from "../actions.js";
+import { getNormalizedPath } from "./urls.js";
+import { SERVER_NO_BODY_STATUS_CODES, encodeViaTurboStream, generateSingleFetchRedirectResponse, singleFetchAction, singleFetchLoaders } from "./single-fetch.js";
+//#region lib/server-runtime/server.ts
+function derive(build, mode) {
+	let dataRoutes = createStaticHandlerDataRoutes(build.routes);
+	let serverMode = isServerMode(mode) ? mode : "production";
+	let staticHandler = createStaticHandler(dataRoutes, {
+		basename: build.basename,
+		mapRouteProperties: defaultMapRouteProperties,
+		instrumentations: build.entry.module.instrumentations,
+		future: build.future
+	});
+	let errorHandler = build.entry.module.handleError || ((error, { request }) => {
+		if (serverMode !== "test" && !request.signal.aborted) console.error(isRouteErrorResponse(error) && error.error ? error.error : error);
+	});
+	let requestHandler = async (request, initialContext) => {
+		let params = {};
+		let loadContext;
+		let handleError = (error) => {
+			if (mode === "development") getDevServerHooks()?.processRequestError?.(error);
+			errorHandler(error, {
+				context: loadContext,
+				params,
+				request
+			});
+		};
+		if (initialContext && !(initialContext instanceof RouterContextProvider)) {
+			let error = /* @__PURE__ */ new Error("Invalid `context` value provided to `handleRequest`. You must return an instance of `RouterContextProvider` from your `getLoadContext` function.");
+			handleError(error);
+			return returnLastResortErrorResponse(error, serverMode);
+		}
+		loadContext = initialContext || new RouterContextProvider();
+		let requestUrl = new URL(request.url);
+		let normalizedPathname = getNormalizedPath(request, build.basename).pathname;
+		let isSpaMode = getBuildTimeHeader(request, "X-React-Router-SPA-Mode") === "yes";
+		if (!build.ssr) {
+			let decodedPath = decodeURI(normalizedPathname);
+			if (build.basename && build.basename !== "/") {
+				let strippedPath = stripBasename(decodedPath, build.basename);
+				if (strippedPath == null) {
+					errorHandler(new ErrorResponseImpl(404, "Not Found", `Refusing to prerender the \`${decodedPath}\` path because it does not start with the basename \`${build.basename}\``), {
+						context: loadContext,
+						params,
+						request
+					});
+					return new Response("Not Found", {
+						status: 404,
+						statusText: "Not Found"
+					});
+				}
+				decodedPath = strippedPath;
+			}
+			if (build.prerender.length === 0) isSpaMode = true;
+			else if (!build.prerender.includes(decodedPath) && !build.prerender.includes(decodedPath + "/")) if (requestUrl.pathname.endsWith(".data")) {
+				errorHandler(new ErrorResponseImpl(404, "Not Found", `Refusing to SSR the path \`${decodedPath}\` because \`ssr:false\` is set and the path is not included in the \`prerender\` config, so in production the path will be a 404.`), {
+					context: loadContext,
+					params,
+					request
+				});
+				return new Response("Not Found", {
+					status: 404,
+					statusText: "Not Found"
+				});
+			} else isSpaMode = true;
+		}
+		let manifestUrl = getManifestPath(build.routeDiscovery.manifestPath, build.basename);
+		if (build.routeDiscovery.mode === "lazy" && requestUrl.pathname === manifestUrl) try {
+			return await handleManifestRequest(build, staticHandler.dataRoutes, staticHandler._internalRouteBranches, requestUrl);
+		} catch (e) {
+			handleError(e);
+			return new Response("Unknown Server Error", { status: 500 });
+		}
+		let matches = matchServerRoutes(build.routes, staticHandler.dataRoutes, staticHandler._internalRouteBranches, normalizedPathname, build.basename);
+		if (matches && matches.length > 0) Object.assign(params, matches[0].params);
+		let response;
+		if (requestUrl.pathname.endsWith(".data")) {
+			response = await handleSingleFetchRequest(serverMode, build, staticHandler, request, loadContext, handleError);
+			if (isRedirectResponse(response)) response = generateSingleFetchRedirectResponse(response, request, build, serverMode);
+			if (build.entry.module.handleDataRequest) {
+				response = await build.entry.module.handleDataRequest(response, {
+					context: loadContext,
+					params: matches ? matches[0].params : {},
+					request
+				});
+				if (isRedirectResponse(response)) response = generateSingleFetchRedirectResponse(response, request, build, serverMode);
+			}
+		} else if (!isSpaMode && matches && matches[matches.length - 1].route.module.default == null && matches[matches.length - 1].route.module.ErrorBoundary == null) response = await handleResourceRequest(serverMode, build, staticHandler, matches.slice(-1)[0].route.id, request, loadContext, handleError);
+		else {
+			let { pathname } = requestUrl;
+			let criticalCss = void 0;
+			if (build.unstable_getCriticalCss) criticalCss = await build.unstable_getCriticalCss({ pathname });
+			else if (mode === "development" && getDevServerHooks()?.getCriticalCss) criticalCss = await getDevServerHooks()?.getCriticalCss?.(pathname);
+			response = await handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss);
+		}
+		if (request.method === "HEAD") return new Response(null, {
+			headers: response.headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+		return response;
+	};
+	if (build.entry.module.instrumentations) requestHandler = instrumentHandler(requestHandler, build.entry.module.instrumentations.map((i) => i.handler).filter(Boolean));
+	return {
+		serverMode,
+		staticHandler,
+		errorHandler,
+		requestHandler
+	};
+}
+const createRequestHandler = (build, mode) => {
+	let _build;
+	let serverMode;
+	let staticHandler;
+	let errorHandler;
+	let _requestHandler;
+	return async function requestHandler(request, initialContext) {
+		_build = typeof build === "function" ? await build() : build;
+		if (typeof build === "function") {
+			let derived = derive(_build, mode);
+			serverMode = derived.serverMode;
+			staticHandler = derived.staticHandler;
+			errorHandler = derived.errorHandler;
+			_requestHandler = derived.requestHandler;
+		} else if (!serverMode || !staticHandler || !errorHandler || !_requestHandler) {
+			let derived = derive(_build, mode);
+			serverMode = derived.serverMode;
+			staticHandler = derived.staticHandler;
+			errorHandler = derived.errorHandler;
+			_requestHandler = derived.requestHandler;
+		}
+		return _requestHandler(request, initialContext);
+	};
+};
+async function handleManifestRequest(build, dataRoutes, branches, url) {
+	if (build.assets.version !== url.searchParams.get("version")) return new Response(null, {
+		status: 204,
+		headers: { "X-Remix-Reload-Document": "true" }
+	});
+	if (url.toString().length > 7680) return new Response(null, {
+		statusText: "Bad Request",
+		status: 400
+	});
+	let patches = {};
+	if (url.searchParams.has("paths")) {
+		let paths = /* @__PURE__ */ new Set();
+		(url.searchParams.get("paths") || "").split(",").filter(Boolean).forEach((path) => {
+			if (!path.startsWith("/")) path = `/${path}`;
+			let segments = path.split("/").slice(1);
+			segments.forEach((_, i) => {
+				let partialPath = segments.slice(0, i + 1).join("/");
+				paths.add(`/${partialPath}`);
+			});
+		});
+		for (let path of paths) {
+			let matches = matchServerRoutes(build.routes, dataRoutes, branches, path, build.basename);
+			if (matches) for (let match of matches) {
+				let routeId = match.route.id;
+				let route = build.assets.routes[routeId];
+				if (route) patches[routeId] = route;
+			}
+		}
+		return Response.json(patches, { headers: { "Cache-Control": "public, max-age=31536000, immutable" } });
+	}
+	return new Response("Invalid Request", { status: 400 });
+}
+async function handleSingleFetchRequest(serverMode, build, staticHandler, request, loadContext, handleError) {
+	return isMutationMethod(request.method) ? await singleFetchAction(build, serverMode, staticHandler, request, loadContext, handleError) : await singleFetchLoaders(build, serverMode, staticHandler, request, loadContext, handleError);
+}
+async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss) {
+	try {
+		if (isMutationMethod(request.method)) try {
+			throwIfPotentialCSRFAttack(request.headers, Array.isArray(build.allowedActionOrigins) ? build.allowedActionOrigins : []);
+		} catch (e) {
+			handleError(e);
+			return new Response("Bad Request", { status: 400 });
+		}
+		let result = await staticHandler.query(request, {
+			requestContext: loadContext,
+			generateMiddlewareResponse: async (query) => {
+				try {
+					let innerResult = await query(request);
+					if (!isResponse(innerResult)) innerResult = await renderHtml(innerResult, isSpaMode);
+					return innerResult;
+				} catch (error) {
+					handleError(error);
+					return new Response(null, { status: 500 });
+				}
+			},
+			normalizePath: (r) => getNormalizedPath(r, build.basename)
+		});
+		if (!isResponse(result)) result = await renderHtml(result, isSpaMode);
+		return result;
+	} catch (error) {
+		handleError(error);
+		return new Response(null, { status: 500 });
+	}
+	async function renderHtml(context, isSpaMode) {
+		let headers = getDocumentHeaders(context, build);
+		if (SERVER_NO_BODY_STATUS_CODES.has(context.statusCode)) 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 state = {
+			loaderData: context.loaderData,
+			actionData: context.actionData,
+			errors: serializeErrors(context.errors, serverMode)
+		};
+		let baseServerHandoff = {
+			basename: build.basename,
+			future: build.future,
+			routeDiscovery: build.routeDiscovery,
+			ssr: build.ssr,
+			isSpaMode
+		};
+		let entryContext = {
+			manifest: build.assets,
+			branches: staticHandler._internalRouteBranches,
+			routeModules: createEntryRouteModules(build.routes),
+			staticHandlerContext: context,
+			criticalCss,
+			serverHandoffString: createServerHandoffString({
+				...baseServerHandoff,
+				criticalCss
+			}),
+			serverHandoffStream: encodeViaTurboStream(state, request.signal, build.entry.module.streamTimeout, serverMode),
+			renderMeta: {},
+			future: build.future,
+			ssr: build.ssr,
+			routeDiscovery: build.routeDiscovery,
+			isSpaMode,
+			serializeError: (err) => serializeError(err, serverMode)
+		};
+		let handleDocumentRequestFunction = build.entry.module.default;
+		try {
+			return await handleDocumentRequestFunction(request, context.statusCode, headers, entryContext, loadContext);
+		} catch (error) {
+			handleError(error);
+			let errorForSecondRender = error;
+			if (isResponse(error)) try {
+				let data = await unwrapResponse(error);
+				errorForSecondRender = new ErrorResponseImpl(error.status, error.statusText, data);
+			} catch (e) {}
+			context = getStaticContextFromError(staticHandler.dataRoutes, context, errorForSecondRender);
+			if (context.errors) context.errors = sanitizeErrors(context.errors, serverMode);
+			let state = {
+				loaderData: context.loaderData,
+				actionData: context.actionData,
+				errors: serializeErrors(context.errors, serverMode)
+			};
+			entryContext = {
+				...entryContext,
+				staticHandlerContext: context,
+				serverHandoffString: createServerHandoffString(baseServerHandoff),
+				serverHandoffStream: encodeViaTurboStream(state, request.signal, build.entry.module.streamTimeout, serverMode),
+				renderMeta: {}
+			};
+			try {
+				return await handleDocumentRequestFunction(request, context.statusCode, headers, entryContext, loadContext);
+			} catch (error) {
+				handleError(error);
+				return returnLastResortErrorResponse(error, serverMode);
+			}
+		}
+	}
+}
+async function handleResourceRequest(serverMode, build, staticHandler, routeId, request, loadContext, handleError) {
+	try {
+		return handleQueryRouteResult(await staticHandler.queryRoute(request, {
+			routeId,
+			requestContext: loadContext,
+			generateMiddlewareResponse: async (queryRoute) => {
+				try {
+					return handleQueryRouteResult(await queryRoute(request));
+				} catch (error) {
+					return handleQueryRouteError(error);
+				}
+			},
+			normalizePath: (r) => getNormalizedPath(r, build.basename)
+		}));
+	} catch (error) {
+		return handleQueryRouteError(error);
+	}
+	function handleQueryRouteResult(result) {
+		if (isResponse(result)) return result;
+		if (typeof result === "string") return new Response(result);
+		return Response.json(result);
+	}
+	function handleQueryRouteError(error) {
+		if (isResponse(error)) return error;
+		if (isRouteErrorResponse(error)) {
+			handleError(error);
+			return errorResponseToJson(error, serverMode);
+		}
+		if (error instanceof Error && error.message === "Expected a response from queryRoute") {
+			let newError = /* @__PURE__ */ new Error("Expected a Response to be returned from resource route handler");
+			handleError(newError);
+			return returnLastResortErrorResponse(newError, serverMode);
+		}
+		handleError(error);
+		return returnLastResortErrorResponse(error, serverMode);
+	}
+}
+function errorResponseToJson(errorResponse, serverMode) {
+	return Response.json(serializeError(errorResponse.error || /* @__PURE__ */ new Error("Unexpected Server Error"), serverMode), {
+		status: errorResponse.status,
+		statusText: errorResponse.statusText
+	});
+}
+function returnLastResortErrorResponse(error, serverMode) {
+	let message = "Unexpected Server Error";
+	if (serverMode !== "production") message += `\n\n${String(error)}`;
+	return new Response(message, {
+		status: 500,
+		headers: { "Content-Type": "text/plain" }
+	});
+}
+function unwrapResponse(response) {
+	let contentType = response.headers.get("Content-Type");
+	return contentType && /\bapplication\/json\b/.test(contentType) ? response.body == null ? null : response.json() : response.text();
+}
+//#endregion
+export { createRequestHandler };

package/dist/production/lib/server-runtime/serverHandoff.js

@@ -0,0 +1,17 @@
+/**
+ * react-router v8.0.0-pre.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 { escapeHtml } from "../dom/ssr/markup.js";
+//#region lib/server-runtime/serverHandoff.ts
+function createServerHandoffString(serverHandoff) {
+	return escapeHtml(JSON.stringify(serverHandoff));
+}
+//#endregion
+export { createServerHandoffString };

package/dist/production/lib/server-runtime/sessions/cookieStorage.d.ts

@@ -0,0 +1,25 @@
+
+import { SessionData, SessionIdStorageStrategy, SessionStorage } from "../sessions.js";
+
+//#region lib/server-runtime/sessions/cookieStorage.d.ts
+interface CookieSessionStorageOptions {
+  /**
+   * The Cookie used to store the session data on the client, or options used
+   * to automatically create one.
+   */
+  cookie?: SessionIdStorageStrategy["cookie"];
+}
+/**
+ * Creates and returns a SessionStorage object that stores all session data
+ * directly in the session cookie itself.
+ *
+ * This has the advantage that no database or other backend services are
+ * needed, and can help to simplify some load-balanced scenarios. However, it
+ * also has the limitation that serialized session data may not exceed the
+ * browser's maximum cookie size. Trade-offs!
+ */
+declare function createCookieSessionStorage<Data = SessionData, FlashData = Data>({
+  cookie: cookieArg
+}?: CookieSessionStorageOptions): SessionStorage<Data, FlashData>;
+//#endregion
+export { createCookieSessionStorage };

package/dist/production/lib/server-runtime/sessions/cookieStorage.js

@@ -0,0 +1,45 @@
+/**
+ * react-router v8.0.0-pre.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 { createCookie, isCookie } from "../cookies.js";
+import { createSession, warnOnceAboutSigningSessionCookie } from "../sessions.js";
+//#region lib/server-runtime/sessions/cookieStorage.ts
+/**
+* Creates and returns a SessionStorage object that stores all session data
+* directly in the session cookie itself.
+*
+* This has the advantage that no database or other backend services are
+* needed, and can help to simplify some load-balanced scenarios. However, it
+* also has the limitation that serialized session data may not exceed the
+* browser's maximum cookie size. Trade-offs!
+*/
+function createCookieSessionStorage({ cookie: cookieArg } = {}) {
+	let cookie = isCookie(cookieArg) ? cookieArg : createCookie(cookieArg?.name || "__session", cookieArg);
+	warnOnceAboutSigningSessionCookie(cookie);
+	return {
+		async getSession(cookieHeader, options) {
+			return createSession(cookieHeader && await cookie.parse(cookieHeader, options) || {});
+		},
+		async commitSession(session, options) {
+			let serializedCookie = await cookie.serialize(session.data, options);
+			if (serializedCookie.length > 4096) throw new Error("Cookie length will exceed browser maximum. Length: " + serializedCookie.length);
+			return serializedCookie;
+		},
+		async destroySession(_session, options) {
+			return cookie.serialize("", {
+				...options,
+				maxAge: void 0,
+				expires: /* @__PURE__ */ new Date(0)
+			});
+		}
+	};
+}
+//#endregion
+export { createCookieSessionStorage };

package/dist/production/lib/server-runtime/sessions/memoryStorage.d.ts

@@ -0,0 +1,23 @@
+
+import { SessionData, SessionIdStorageStrategy, SessionStorage } from "../sessions.js";
+
+//#region lib/server-runtime/sessions/memoryStorage.d.ts
+interface MemorySessionStorageOptions {
+  /**
+   * The Cookie used to store the session id on the client, or options used
+   * to automatically create one.
+   */
+  cookie?: SessionIdStorageStrategy["cookie"];
+}
+/**
+ * Creates and returns a simple in-memory SessionStorage object, mostly useful
+ * for testing and as a reference implementation.
+ *
+ * Note: This storage does not scale beyond a single process, so it is not
+ * suitable for most production scenarios.
+ */
+declare function createMemorySessionStorage<Data = SessionData, FlashData = Data>({
+  cookie
+}?: MemorySessionStorageOptions): SessionStorage<Data, FlashData>;
+//#endregion
+export { createMemorySessionStorage };

package/dist/production/lib/server-runtime/sessions/memoryStorage.js

@@ -0,0 +1,52 @@
+/**
+ * react-router v8.0.0-pre.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 { createSessionStorage } from "../sessions.js";
+//#region lib/server-runtime/sessions/memoryStorage.ts
+/**
+* Creates and returns a simple in-memory SessionStorage object, mostly useful
+* for testing and as a reference implementation.
+*
+* Note: This storage does not scale beyond a single process, so it is not
+* suitable for most production scenarios.
+*/
+function createMemorySessionStorage({ cookie } = {}) {
+	let map = /* @__PURE__ */ new Map();
+	return createSessionStorage({
+		cookie,
+		async createData(data, expires) {
+			let id = Math.random().toString(36).substring(2, 10);
+			map.set(id, {
+				data,
+				expires
+			});
+			return id;
+		},
+		async readData(id) {
+			if (map.has(id)) {
+				let { data, expires } = map.get(id);
+				if (!expires || expires > /* @__PURE__ */ new Date()) return data;
+				if (expires) map.delete(id);
+			}
+			return null;
+		},
+		async updateData(id, data, expires) {
+			map.set(id, {
+				data,
+				expires
+			});
+		},
+		async deleteData(id) {
+			map.delete(id);
+		}
+	});
+}
+//#endregion
+export { createMemorySessionStorage };

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

@@ -0,0 +1,145 @@
+
+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.
+ */
+declare const createSession: CreateSessionFunction;
+type IsSessionFunction = (object: any) => object is Session;
+/**
+ * Returns true if an object is a React Router session.
+ *
+ * @see https://reactrouter.com/api/utils/isSession
+ */
+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.
+ */
+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 };