clear-react-router 1.9.8 → 2.0.1

package/README.md

@@ -572,6 +572,8 @@ const UserProfile = () => {
   staleTime: 60000, // 1 minute — cache is fresh for 60 seconds
 }
 ```
+ - Stale cache entries are cleaned up incrementally on every navigation, keeping the loader cache from growing unbounded over long sessions.
+
 
 ### `useInvalidate()`
 

package/dist/index.js

@@ -113,13 +113,12 @@ var createCommitNavigation = (navigationExecutor, routeItemDataState) => (nextLo
 };
 //#endregion
 //#region utils/isCacheItemFresh.ts
-var createIsCacheItemFresh = (loaderMap) => ({ routeItem, pathname }) => {
-	if (!routeItem) return true;
-	const item = loaderMap.get(pathname);
+var createIsCacheItemFresh = (loaderMap) => (path) => {
+	const item = loaderMap.get(path);
 	if (item === void 0) return false;
-	const staleTime = routeItem.staleTime ?? routerConfig.defaultStaleTime;
-	if (staleTime === void 0) return true;
-	return Date.now() - item.timestamp <= staleTime;
+	const resolvedStaleTime = item.staleTime ?? routerConfig.defaultStaleTime;
+	if (resolvedStaleTime === void 0) return true;
+	return Date.now() - item.timestamp <= resolvedStaleTime;
 };
 //#endregion
 //#region ../../node_modules/react/cjs/react-jsx-runtime.production.js
@@ -273,29 +272,28 @@ var createNavigate = (routerState, revalidateCache) => {
 				[prevPathname]: scrollPosition
 			};
 		});
-		if (routeItem?.optimistic && loaderMap.has(location.pathname)) {
+		const path = `${location.pathname}${location.search}`;
+		if (routeItem?.optimistic && loaderMap.has(path)) {
 			routeItemDataState.setState({
 				routeItem,
 				location
 			});
-			const currentLoaderState = loaderMap.get(location.pathname)?.state;
+			const currentLoaderState = loaderMap.get(path)?.state;
 			if (currentLoaderState) loaderStateRef.set(currentLoaderState);
 		} else {
-			const pendingShouldExist = routeItem?.loader && !isCacheItemFresh({
-				routeItem,
-				pathname: location.pathname
-			});
+			const pendingShouldExist = routeItem?.loader && !isCacheItemFresh(path);
 			pendingState.setState(pendingShouldExist ? {
 				routeItem,
 				location
 			} : void 0);
 		}
 	};
-	const afterEachLoad = (routeItem, location) => {
+	const polling = (routeItem, location) => {
 		if (!routeItem?.pollingInterval) return;
 		interval = window.setInterval(() => revalidateCache({
 			routeItem,
-			pathname: location.pathname
+			pathname: location.pathname,
+			search: location.search
 		}), routeItem.pollingInterval);
 	};
 	const loader = async (routeItem, location) => {
@@ -306,7 +304,7 @@ var createNavigate = (routerState, revalidateCache) => {
 			pathname: location.pathname,
 			search: location.search
 		});
-		afterEachLoad(routeItem, location);
+		polling(routeItem, location);
 	};
 	const afterLoad = async (routeItem, params) => {
 		const { defaultAfterLoad } = routerConfig;
@@ -423,15 +421,21 @@ var getRetry = (routeItem) => {
 var sleep = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var createRevalidateCache = (routerState) => {
 	const { loaderStateRef, contextState, loaderMap } = routerState;
+	const removeFirstStaleItem = () => {
+		const deletedItem = [...loaderMap.entries()].find(([, item]) => {
+			const staleTime = item.staleTime ?? routerConfig.defaultStaleTime;
+			return staleTime && staleTime + item.timestamp < Date.now();
+		});
+		if (deletedItem) loaderMap.delete(deletedItem[0]);
+	};
 	const revalidateCache = async ({ routeItem, pathname, search = "" }, retried = 0) => {
 		if (!routeItem?.loader) return;
 		const isCacheItemFresh = createIsCacheItemFresh(loaderMap);
-		if (loadingPromises.has(pathname)) return loadingPromises.get(pathname);
-		if (isCacheItemFresh({
-			routeItem,
-			pathname
-		})) {
-			const item = loaderMap.get(pathname);
+		removeFirstStaleItem();
+		const path = `${pathname}${search}`;
+		if (loadingPromises.has(path)) return loadingPromises.get(path);
+		if (isCacheItemFresh(path)) {
+			const item = loaderMap.get(path);
 			if (item?.state) loaderStateRef.set(item.state);
 			return;
 		}
@@ -453,9 +457,10 @@ var createRevalidateCache = (routerState) => {
 					data: result,
 					loaderError: null
 				}));
-				loaderMap.set(`${pathname}${search}`, {
+				loaderMap.set(path, {
 					state: loaderStateRef.value,
-					timestamp: Date.now()
+					timestamp: Date.now(),
+					staleTime: routeItem.staleTime
 				});
 				return {
 					data: result,
@@ -464,7 +469,7 @@ var createRevalidateCache = (routerState) => {
 			} catch (error) {
 				const retry = getRetry(routeItem);
 				if (retry && retry.count > retried) {
-					loadingPromises.delete(`${pathname}${search}`);
+					loadingPromises.delete(path);
 					if (retry.delay) await sleep(retry.delay);
 					await revalidateCache({
 						routeItem,
@@ -487,10 +492,10 @@ var createRevalidateCache = (routerState) => {
 					};
 				}
 			} finally {
-				loadingPromises.delete(`${pathname}${search}`);
+				loadingPromises.delete(path);
 			}
 		})();
-		loadingPromises.set(`${pathname}${search}`, promise);
+		loadingPromises.set(path, promise);
 		return promise;
 	};
 	return revalidateCache;

package/dist/types.d.ts

@@ -102,6 +102,7 @@ export type RouterProps = {
 export type LoaderStateItem = {
     state: LoaderState;
     timestamp: number;
+    staleTime: number | undefined;
 };
 export type RouterState = {
     routeItemDataState: Store<RouteItemData>;
@@ -146,7 +147,7 @@ export type InvalidateOptions = {
     withChildren?: boolean;
     withBeforeLoad?: boolean;
 };
-export type RevalidateCache = ({ routeItem, pathname, }: RevalidateCacheArgs) => Promise<{
+export type RevalidateCache = (args: RevalidateCacheArgs) => Promise<{
     data: unknown;
     error: unknown;
 }>;

package/dist/utils/isCacheItemFresh.d.ts

@@ -1,5 +1,2 @@
-import { LoaderStateItem, RouteItem } from '../types';
-export declare const createIsCacheItemFresh: (loaderMap: Map<string, LoaderStateItem>) => ({ routeItem, pathname }: {
-    routeItem?: RouteItem;
-    pathname: string;
-}) => boolean;
+import { LoaderStateItem } from '../types';
+export declare const createIsCacheItemFresh: (loaderMap: Map<string, LoaderStateItem>) => (path: string) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clear-react-router",
-  "version": "1.9.8",
+  "version": "2.0.1",
   "description": "A lightweight, type-safe routing library for React applications",
   "author": "Andrew Bubnov",
   "scripts": {