tanstack-router-cache 0.1.7 → 0.1.8

package/dist/contexts/router-cache.cjs

@@ -0,0 +1,237 @@
+const require_pathname = require("../pathname.cjs");
+const require_route_cache_static_data = require("../route-cache-static-data.cjs");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/contexts/router-cache.tsx
+const DEFAULT_MAX_ENTRIES = Number.POSITIVE_INFINITY;
+const EMPTY_CACHED_ROUTES = {};
+const RouterCacheContext = (0, react.createContext)(null);
+function shallowEqualRouteStaticData(current, next) {
+	if (current === next) return true;
+	const currentEntries = Object.entries({ ...current });
+	const nextEntries = Object.entries({ ...next });
+	if (currentEntries.length !== nextEntries.length) return false;
+	const nextValuesByKey = new Map(nextEntries);
+	for (const [key, value] of currentEntries) if (!Object.is(value, nextValuesByKey.get(key))) return false;
+	return true;
+}
+function filterRouterCacheRoutes(routes) {
+	const now = Date.now();
+	return Object.fromEntries(Object.entries(routes).flatMap(([pathname, route]) => require_route_cache_static_data.isRouteCacheEnabled(route.staticData) && !require_route_cache_static_data.isCachedRouteStale(route, now) ? [[require_pathname.normalizeCachedRoutePathname(pathname), route]] : []));
+}
+function pruneStaleCachedRoutes(routes) {
+	const now = Date.now();
+	const nextRoutes = {};
+	let changed = false;
+	for (const [pathname, route] of Object.entries(routes)) {
+		if (require_route_cache_static_data.isCachedRouteStale(route, now)) {
+			changed = true;
+			continue;
+		}
+		nextRoutes[pathname] = route;
+	}
+	return changed ? nextRoutes : routes;
+}
+function isSameCachedRouteData(current, next) {
+	if (!current) return false;
+	return current.routeId === next.routeId && current.href === next.href && current.matchId === next.matchId && current.ready === next.ready && current.routerSnapshot === next.routerSnapshot && shallowEqualRouteStaticData(current.staticData, next.staticData);
+}
+function normalizeLimit(limit) {
+	if (typeof limit !== "number" || Number.isNaN(limit)) return DEFAULT_MAX_ENTRIES;
+	if (!Number.isFinite(limit)) return DEFAULT_MAX_ENTRIES;
+	return Math.max(Math.trunc(limit), 0);
+}
+function getCachedRouteTimestamp(route) {
+	return route.lastVisibleAt ?? route.createdAt ?? 0;
+}
+function sortCachedRouteEntries([leftPathname, leftRoute], [rightPathname, rightRoute]) {
+	const timestampDifference = getCachedRouteTimestamp(leftRoute) - getCachedRouteTimestamp(rightRoute);
+	if (timestampDifference !== 0) return timestampDifference;
+	return leftPathname.localeCompare(rightPathname);
+}
+function getUnmarkedCachedRouteEntries(routes, keysToDelete) {
+	return Object.entries(routes).filter(([pathname]) => !keysToDelete.has(pathname));
+}
+function getEntriesByRouteId(entries) {
+	const entriesByRouteId = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const routeId = entry[1].routeId;
+		if (!routeId) continue;
+		const existingEntries = entriesByRouteId.get(routeId);
+		if (existingEntries) {
+			existingEntries.push(entry);
+			continue;
+		}
+		entriesByRouteId.set(routeId, [entry]);
+	}
+	return entriesByRouteId;
+}
+function markEntriesForDeletion(entries, keysToDelete, protectedKeys, excessEntryCount) {
+	if (excessEntryCount <= 0) return;
+	const evictableEntries = entries.filter(([pathname]) => !protectedKeys.has(pathname)).sort(sortCachedRouteEntries);
+	let remainingExcess = excessEntryCount;
+	for (const [pathname] of evictableEntries) {
+		if (remainingExcess <= 0) break;
+		if (!keysToDelete.has(pathname)) {
+			keysToDelete.add(pathname);
+			remainingExcess -= 1;
+		}
+	}
+}
+function applyPerRouteEntryLimit(routes, maxEntriesPerRouteId, keysToDelete, protectedKeys) {
+	if (maxEntriesPerRouteId === DEFAULT_MAX_ENTRIES) return;
+	const entriesByRouteId = getEntriesByRouteId(getUnmarkedCachedRouteEntries(routes, keysToDelete));
+	for (const entries of entriesByRouteId.values()) markEntriesForDeletion(entries, keysToDelete, protectedKeys, entries.length - maxEntriesPerRouteId);
+}
+function applyGlobalEntryLimit(routes, maxEntries, keysToDelete, protectedKeys) {
+	if (maxEntries === DEFAULT_MAX_ENTRIES) return;
+	const remainingEntries = getUnmarkedCachedRouteEntries(routes, keysToDelete);
+	markEntriesForDeletion(remainingEntries, keysToDelete, protectedKeys, remainingEntries.length - maxEntries);
+}
+function applyCachedRouteLimits(routes, config, protectedKeys) {
+	if (config.maxEntries === DEFAULT_MAX_ENTRIES && config.maxEntriesPerRouteId === DEFAULT_MAX_ENTRIES) return routes;
+	const keysToDelete = /* @__PURE__ */ new Set();
+	applyPerRouteEntryLimit(routes, config.maxEntriesPerRouteId, keysToDelete, protectedKeys);
+	applyGlobalEntryLimit(routes, config.maxEntries, keysToDelete, protectedKeys);
+	if (keysToDelete.size === 0) return routes;
+	const nextRoutes = { ...routes };
+	for (const pathname of keysToDelete) delete nextRoutes[pathname];
+	return nextRoutes;
+}
+function createCachedRouteData(current, next) {
+	const now = Date.now();
+	return {
+		...next,
+		createdAt: current?.createdAt ?? next.createdAt ?? now,
+		lastVisibleAt: next.lastVisibleAt ?? now
+	};
+}
+function getNextCachedRoutesState(params) {
+	const normalizedKey = require_pathname.normalizeCachedRoutePathname(params.key);
+	const state = pruneStaleCachedRoutes(params.state);
+	if (params.cacheConfig.maxEntries === 0) return state === EMPTY_CACHED_ROUTES ? state : EMPTY_CACHED_ROUTES;
+	if (!require_route_cache_static_data.isRouteCacheEnabled(params.value.staticData)) {
+		if (!Object.hasOwn(state, normalizedKey)) return state;
+		const nextState = { ...state };
+		delete nextState[normalizedKey];
+		return nextState;
+	}
+	const nextRouteData = createCachedRouteData(state[normalizedKey], params.value);
+	if (isSameCachedRouteData(state[normalizedKey], nextRouteData)) return state;
+	return applyCachedRouteLimits({
+		...state,
+		[normalizedKey]: nextRouteData
+	}, params.cacheConfig, /* @__PURE__ */ new Set([normalizedKey]));
+}
+function RouterCacheProvider({ cacheScopeKey = "__default__", children, defaultCachedRoutes = EMPTY_CACHED_ROUTES, maxEntries = DEFAULT_MAX_ENTRIES, maxEntriesPerRouteId = DEFAULT_MAX_ENTRIES }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouterCacheProviderScope, {
+		defaultCachedRoutes,
+		maxEntries,
+		maxEntriesPerRouteId,
+		children
+	}, cacheScopeKey ?? "__default__");
+}
+function RouterCacheProviderScope({ children, defaultCachedRoutes = EMPTY_CACHED_ROUTES, maxEntries, maxEntriesPerRouteId }) {
+	const cacheConfigRef = (0, react.useRef)({
+		maxEntries: normalizeLimit(maxEntries),
+		maxEntriesPerRouteId: normalizeLimit(maxEntriesPerRouteId)
+	});
+	const initialCachedRoutesRef = (0, react.useRef)(null);
+	if (initialCachedRoutesRef.current === null) initialCachedRoutesRef.current = applyCachedRouteLimits(filterRouterCacheRoutes(defaultCachedRoutes), cacheConfigRef.current, /* @__PURE__ */ new Set());
+	const [cachedRoutes, setCachedRoutes] = (0, react.useState)(() => initialCachedRoutesRef.current ?? EMPTY_CACHED_ROUTES);
+	const [erroredRouteCounts, setErroredRouteCounts] = (0, react.useState)({});
+	const updateCachedRoutes = (key, value) => {
+		setCachedRoutes((state) => getNextCachedRoutesState({
+			cacheConfig: cacheConfigRef.current,
+			key,
+			state,
+			value
+		}));
+	};
+	const deleteCachedRoutes = (keys) => {
+		setCachedRoutes((state) => {
+			let changed = false;
+			const newState = { ...state };
+			for (const key of keys) {
+				const normalizedKey = require_pathname.normalizeCachedRoutePathname(key);
+				if (Object.hasOwn(newState, normalizedKey)) {
+					delete newState[normalizedKey];
+					changed = true;
+				}
+			}
+			return changed ? newState : state;
+		});
+	};
+	const touchCachedRoutes = (keys) => {
+		setCachedRoutes((state) => {
+			let changed = false;
+			const touchedAt = Date.now();
+			const nextState = { ...state };
+			for (const key of keys) {
+				const normalizedKey = require_pathname.normalizeCachedRoutePathname(key);
+				const route = nextState[normalizedKey];
+				if (!route || route.lastVisibleAt === touchedAt) continue;
+				nextState[normalizedKey] = {
+					...route,
+					lastVisibleAt: touchedAt
+				};
+				changed = true;
+			}
+			return changed ? nextState : state;
+		});
+	};
+	const retainErroredRoute = (pathname) => {
+		const normalizedPathname = require_pathname.normalizeCachedRoutePathname(pathname);
+		setErroredRouteCounts((state) => ({
+			...state,
+			[normalizedPathname]: (state[normalizedPathname] ?? 0) + 1
+		}));
+		setCachedRoutes((state) => {
+			if (!Object.hasOwn(state, normalizedPathname)) return state;
+			const nextState = { ...state };
+			delete nextState[normalizedPathname];
+			return nextState;
+		});
+	};
+	const releaseErroredRoute = (pathname) => {
+		const normalizedPathname = require_pathname.normalizeCachedRoutePathname(pathname);
+		setErroredRouteCounts((state) => {
+			const currentCount = state[normalizedPathname] ?? 0;
+			if (currentCount <= 1) {
+				if (!Object.hasOwn(state, normalizedPathname)) return state;
+				const nextState = { ...state };
+				delete nextState[normalizedPathname];
+				return nextState;
+			}
+			return {
+				...state,
+				[normalizedPathname]: currentCount - 1
+			};
+		});
+	};
+	const contextValue = {
+		cachedRoutes,
+		erroredRouteCounts,
+		setCachedRoutes: updateCachedRoutes,
+		deleteCachedRoutes,
+		touchCachedRoutes,
+		retainErroredRoute,
+		releaseErroredRoute
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouterCacheContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+function useRouterCacheContext() {
+	const context = (0, react.use)(RouterCacheContext);
+	if (!context) throw new Error("RouterCacheContext is not available");
+	return context;
+}
+function useOptionalRouterCacheContext() {
+	return (0, react.use)(RouterCacheContext);
+}
+//#endregion
+exports.RouterCacheProvider = RouterCacheProvider;
+exports.useOptionalRouterCacheContext = useOptionalRouterCacheContext;
+exports.useRouterCacheContext = useRouterCacheContext;

package/dist/contexts/router-cache.d.ts

@@ -1,23 +1,63 @@
 import type { RouterContextProvider, StaticDataRouteOption } from "@tanstack/react-router";
 import type { ComponentProps, ReactNode } from "react";
 type RouterCacheProviderProps = {
+    /**
+     * Clears all cached routes when the key changes.
+     *
+     * Use this for user, tenant, workspace, locale, or environment boundaries.
+     *
+     * @defaultValue `"__default__"`
+     */
     cacheScopeKey?: string | number | null;
+    /** Outlet and surrounding UI that can access the route cache. */
     children: ReactNode;
+    /**
+     * Initial cached route entries.
+     *
+     * Most apps do not need this. Entries without enabled `staticData.routeCache`
+     * or entries older than their `maxAge` are ignored.
+     *
+     * @defaultValue `{}`
+     */
     defaultCachedRoutes?: CachedRoutes;
+    /**
+     * Maximum cached route entries across this provider.
+     *
+     * Set to `0` to disable caching.
+     *
+     * @defaultValue `Infinity`
+     */
     maxEntries?: number;
+    /**
+     * Maximum cached entries for the same TanStack route id.
+     *
+     * Useful for dynamic routes where each pathname can create a separate cached
+     * view.
+     *
+     * @defaultValue `Infinity`
+     */
     maxEntriesPerRouteId?: number;
 };
 type RouterSnapshot = ComponentProps<typeof RouterContextProvider>["router"];
 export type CachedRouteData = {
+    /** First time this cache entry was stored, as `Date.now()`. */
     createdAt?: number;
+    /** Full cached href, including search and hash when available. */
     href?: string;
+    /** Last time this cached route became visible, as `Date.now()`. */
     lastVisibleAt?: number;
+    /** TanStack Router route id used for per-route entry limits. */
     routeId?: string;
+    /** Static data from the deepest cache-enabled route match. */
     staticData: StaticDataRouteOption;
+    /** TanStack Router match id rendered by the cached outlet. */
     matchId?: string;
+    /** Router snapshot used to keep the cached route tree isolated while hidden. */
     routerSnapshot?: RouterSnapshot;
+    /** Whether the cached route has a complete snapshot and can be restored. */
     ready?: boolean;
 };
+/** Cached route entries keyed by normalized pathname. */
 export type CachedRoutes = {
     [key: string]: CachedRouteData;
 };

package/dist/contexts/router-cache.js

@@ -0,0 +1,235 @@
+import { normalizeCachedRoutePathname } from "../pathname.js";
+import { isCachedRouteStale, isRouteCacheEnabled } from "../route-cache-static-data.js";
+import { createContext, use, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/contexts/router-cache.tsx
+const DEFAULT_MAX_ENTRIES = Number.POSITIVE_INFINITY;
+const EMPTY_CACHED_ROUTES = {};
+const RouterCacheContext = createContext(null);
+function shallowEqualRouteStaticData(current, next) {
+	if (current === next) return true;
+	const currentEntries = Object.entries({ ...current });
+	const nextEntries = Object.entries({ ...next });
+	if (currentEntries.length !== nextEntries.length) return false;
+	const nextValuesByKey = new Map(nextEntries);
+	for (const [key, value] of currentEntries) if (!Object.is(value, nextValuesByKey.get(key))) return false;
+	return true;
+}
+function filterRouterCacheRoutes(routes) {
+	const now = Date.now();
+	return Object.fromEntries(Object.entries(routes).flatMap(([pathname, route]) => isRouteCacheEnabled(route.staticData) && !isCachedRouteStale(route, now) ? [[normalizeCachedRoutePathname(pathname), route]] : []));
+}
+function pruneStaleCachedRoutes(routes) {
+	const now = Date.now();
+	const nextRoutes = {};
+	let changed = false;
+	for (const [pathname, route] of Object.entries(routes)) {
+		if (isCachedRouteStale(route, now)) {
+			changed = true;
+			continue;
+		}
+		nextRoutes[pathname] = route;
+	}
+	return changed ? nextRoutes : routes;
+}
+function isSameCachedRouteData(current, next) {
+	if (!current) return false;
+	return current.routeId === next.routeId && current.href === next.href && current.matchId === next.matchId && current.ready === next.ready && current.routerSnapshot === next.routerSnapshot && shallowEqualRouteStaticData(current.staticData, next.staticData);
+}
+function normalizeLimit(limit) {
+	if (typeof limit !== "number" || Number.isNaN(limit)) return DEFAULT_MAX_ENTRIES;
+	if (!Number.isFinite(limit)) return DEFAULT_MAX_ENTRIES;
+	return Math.max(Math.trunc(limit), 0);
+}
+function getCachedRouteTimestamp(route) {
+	return route.lastVisibleAt ?? route.createdAt ?? 0;
+}
+function sortCachedRouteEntries([leftPathname, leftRoute], [rightPathname, rightRoute]) {
+	const timestampDifference = getCachedRouteTimestamp(leftRoute) - getCachedRouteTimestamp(rightRoute);
+	if (timestampDifference !== 0) return timestampDifference;
+	return leftPathname.localeCompare(rightPathname);
+}
+function getUnmarkedCachedRouteEntries(routes, keysToDelete) {
+	return Object.entries(routes).filter(([pathname]) => !keysToDelete.has(pathname));
+}
+function getEntriesByRouteId(entries) {
+	const entriesByRouteId = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const routeId = entry[1].routeId;
+		if (!routeId) continue;
+		const existingEntries = entriesByRouteId.get(routeId);
+		if (existingEntries) {
+			existingEntries.push(entry);
+			continue;
+		}
+		entriesByRouteId.set(routeId, [entry]);
+	}
+	return entriesByRouteId;
+}
+function markEntriesForDeletion(entries, keysToDelete, protectedKeys, excessEntryCount) {
+	if (excessEntryCount <= 0) return;
+	const evictableEntries = entries.filter(([pathname]) => !protectedKeys.has(pathname)).sort(sortCachedRouteEntries);
+	let remainingExcess = excessEntryCount;
+	for (const [pathname] of evictableEntries) {
+		if (remainingExcess <= 0) break;
+		if (!keysToDelete.has(pathname)) {
+			keysToDelete.add(pathname);
+			remainingExcess -= 1;
+		}
+	}
+}
+function applyPerRouteEntryLimit(routes, maxEntriesPerRouteId, keysToDelete, protectedKeys) {
+	if (maxEntriesPerRouteId === DEFAULT_MAX_ENTRIES) return;
+	const entriesByRouteId = getEntriesByRouteId(getUnmarkedCachedRouteEntries(routes, keysToDelete));
+	for (const entries of entriesByRouteId.values()) markEntriesForDeletion(entries, keysToDelete, protectedKeys, entries.length - maxEntriesPerRouteId);
+}
+function applyGlobalEntryLimit(routes, maxEntries, keysToDelete, protectedKeys) {
+	if (maxEntries === DEFAULT_MAX_ENTRIES) return;
+	const remainingEntries = getUnmarkedCachedRouteEntries(routes, keysToDelete);
+	markEntriesForDeletion(remainingEntries, keysToDelete, protectedKeys, remainingEntries.length - maxEntries);
+}
+function applyCachedRouteLimits(routes, config, protectedKeys) {
+	if (config.maxEntries === DEFAULT_MAX_ENTRIES && config.maxEntriesPerRouteId === DEFAULT_MAX_ENTRIES) return routes;
+	const keysToDelete = /* @__PURE__ */ new Set();
+	applyPerRouteEntryLimit(routes, config.maxEntriesPerRouteId, keysToDelete, protectedKeys);
+	applyGlobalEntryLimit(routes, config.maxEntries, keysToDelete, protectedKeys);
+	if (keysToDelete.size === 0) return routes;
+	const nextRoutes = { ...routes };
+	for (const pathname of keysToDelete) delete nextRoutes[pathname];
+	return nextRoutes;
+}
+function createCachedRouteData(current, next) {
+	const now = Date.now();
+	return {
+		...next,
+		createdAt: current?.createdAt ?? next.createdAt ?? now,
+		lastVisibleAt: next.lastVisibleAt ?? now
+	};
+}
+function getNextCachedRoutesState(params) {
+	const normalizedKey = normalizeCachedRoutePathname(params.key);
+	const state = pruneStaleCachedRoutes(params.state);
+	if (params.cacheConfig.maxEntries === 0) return state === EMPTY_CACHED_ROUTES ? state : EMPTY_CACHED_ROUTES;
+	if (!isRouteCacheEnabled(params.value.staticData)) {
+		if (!Object.hasOwn(state, normalizedKey)) return state;
+		const nextState = { ...state };
+		delete nextState[normalizedKey];
+		return nextState;
+	}
+	const nextRouteData = createCachedRouteData(state[normalizedKey], params.value);
+	if (isSameCachedRouteData(state[normalizedKey], nextRouteData)) return state;
+	return applyCachedRouteLimits({
+		...state,
+		[normalizedKey]: nextRouteData
+	}, params.cacheConfig, /* @__PURE__ */ new Set([normalizedKey]));
+}
+function RouterCacheProvider({ cacheScopeKey = "__default__", children, defaultCachedRoutes = EMPTY_CACHED_ROUTES, maxEntries = DEFAULT_MAX_ENTRIES, maxEntriesPerRouteId = DEFAULT_MAX_ENTRIES }) {
+	return /* @__PURE__ */ jsx(RouterCacheProviderScope, {
+		defaultCachedRoutes,
+		maxEntries,
+		maxEntriesPerRouteId,
+		children
+	}, cacheScopeKey ?? "__default__");
+}
+function RouterCacheProviderScope({ children, defaultCachedRoutes = EMPTY_CACHED_ROUTES, maxEntries, maxEntriesPerRouteId }) {
+	const cacheConfigRef = useRef({
+		maxEntries: normalizeLimit(maxEntries),
+		maxEntriesPerRouteId: normalizeLimit(maxEntriesPerRouteId)
+	});
+	const initialCachedRoutesRef = useRef(null);
+	if (initialCachedRoutesRef.current === null) initialCachedRoutesRef.current = applyCachedRouteLimits(filterRouterCacheRoutes(defaultCachedRoutes), cacheConfigRef.current, /* @__PURE__ */ new Set());
+	const [cachedRoutes, setCachedRoutes] = useState(() => initialCachedRoutesRef.current ?? EMPTY_CACHED_ROUTES);
+	const [erroredRouteCounts, setErroredRouteCounts] = useState({});
+	const updateCachedRoutes = (key, value) => {
+		setCachedRoutes((state) => getNextCachedRoutesState({
+			cacheConfig: cacheConfigRef.current,
+			key,
+			state,
+			value
+		}));
+	};
+	const deleteCachedRoutes = (keys) => {
+		setCachedRoutes((state) => {
+			let changed = false;
+			const newState = { ...state };
+			for (const key of keys) {
+				const normalizedKey = normalizeCachedRoutePathname(key);
+				if (Object.hasOwn(newState, normalizedKey)) {
+					delete newState[normalizedKey];
+					changed = true;
+				}
+			}
+			return changed ? newState : state;
+		});
+	};
+	const touchCachedRoutes = (keys) => {
+		setCachedRoutes((state) => {
+			let changed = false;
+			const touchedAt = Date.now();
+			const nextState = { ...state };
+			for (const key of keys) {
+				const normalizedKey = normalizeCachedRoutePathname(key);
+				const route = nextState[normalizedKey];
+				if (!route || route.lastVisibleAt === touchedAt) continue;
+				nextState[normalizedKey] = {
+					...route,
+					lastVisibleAt: touchedAt
+				};
+				changed = true;
+			}
+			return changed ? nextState : state;
+		});
+	};
+	const retainErroredRoute = (pathname) => {
+		const normalizedPathname = normalizeCachedRoutePathname(pathname);
+		setErroredRouteCounts((state) => ({
+			...state,
+			[normalizedPathname]: (state[normalizedPathname] ?? 0) + 1
+		}));
+		setCachedRoutes((state) => {
+			if (!Object.hasOwn(state, normalizedPathname)) return state;
+			const nextState = { ...state };
+			delete nextState[normalizedPathname];
+			return nextState;
+		});
+	};
+	const releaseErroredRoute = (pathname) => {
+		const normalizedPathname = normalizeCachedRoutePathname(pathname);
+		setErroredRouteCounts((state) => {
+			const currentCount = state[normalizedPathname] ?? 0;
+			if (currentCount <= 1) {
+				if (!Object.hasOwn(state, normalizedPathname)) return state;
+				const nextState = { ...state };
+				delete nextState[normalizedPathname];
+				return nextState;
+			}
+			return {
+				...state,
+				[normalizedPathname]: currentCount - 1
+			};
+		});
+	};
+	const contextValue = {
+		cachedRoutes,
+		erroredRouteCounts,
+		setCachedRoutes: updateCachedRoutes,
+		deleteCachedRoutes,
+		touchCachedRoutes,
+		retainErroredRoute,
+		releaseErroredRoute
+	};
+	return /* @__PURE__ */ jsx(RouterCacheContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+function useRouterCacheContext() {
+	const context = use(RouterCacheContext);
+	if (!context) throw new Error("RouterCacheContext is not available");
+	return context;
+}
+function useOptionalRouterCacheContext() {
+	return use(RouterCacheContext);
+}
+//#endregion
+export { RouterCacheProvider, useOptionalRouterCacheContext, useRouterCacheContext };