clear-react-router 1.0.20 → 1.1.0

package/dist/hooks/useHandleNavigation.d.ts

@@ -3,7 +3,7 @@ type UseHandleNavigation = {
     routeList: RouteItem[];
     setLocation: (arg: Location) => void;
     context: Record<string, unknown>;
-    revalidateCache(routeItem?: RouteItem): Promise<void>;
+    revalidateCache(routeItem?: RouteItem, isCurrentRoute?: boolean): Promise<void>;
 };
 export declare const useHandleNavigation: ({ setLocation, routeList, context, revalidateCache }: UseHandleNavigation) => {
     blockerState: BlockerState;

package/dist/hooks/useLoader.d.ts

@@ -3,6 +3,6 @@ export declare const useLoader: (routeList: RouteItem[]) => {
     loaderCache: unknown;
     loaderError: boolean;
     prefetchLoader: (pathname: string) => Promise<void>;
-    revalidateCache: (routeItem?: RouteItem) => Promise<void>;
+    revalidateCache: (routeItem?: RouteItem, isCurrentRoute?: boolean) => Promise<void>;
     isLoading: boolean;
 };

package/dist/index.js

@@ -195,7 +195,7 @@ var useHandleNavigation = ({ setLocation, routeList, context, revalidateCache })
 				history.pushState(null, "", nextLocation.pathname);
 				prevPathname.current = nextLocation.pathname;
 			}
-			await revalidateCache(nextItem);
+			await revalidateCache(nextItem, true);
 			if (nextItem?.afterLoad) await nextItem?.afterLoad(context);
 		} catch (redirect) {
 			if (!(redirect instanceof Redirect)) return redirect;
@@ -267,60 +267,52 @@ var useHandleNavigation = ({ setLocation, routeList, context, revalidateCache })
 //#endregion
 //#region hooks/useLoader.ts
 var useLoader = (routeList) => {
-	const [loaderCache, setLoaderCache] = useState({});
+	const [loaderCache, setLoaderCache] = useState();
 	const [loaderError, setLoaderError] = useState(false);
-	const [isLoadingMap, setIsLoadingMap] = useState({});
+	const [isLoading, setIsLoading] = useState(false);
 	const cacheTimestampsRef = useRef({});
-	const updateCache = useCallback(({ key, value }) => setLoaderCache((prevState) => ({
-		...prevState,
-		[key]: value
-	})), []);
+	const loaderCacheRef = useRef({});
 	const isCacheItemFresh = useCallback((routeItem) => {
 		if (!routeItem) return true;
 		const currentCacheTimestamp = cacheTimestampsRef.current[routeItem.path];
 		return Boolean(currentCacheTimestamp && Date.now() - currentCacheTimestamp < (routeItem.staleTime || 0));
 	}, []);
-	const revalidateCache = useCallback(async (routeItem) => {
+	const revalidateCache = useCallback(async (routeItem, isCurrentRoute) => {
 		if (!routeItem?.loader) return;
+		if (isCacheItemFresh(routeItem) && isCurrentRoute) setLoaderCache(loaderCacheRef.current[routeItem.path]);
 		if (isCacheItemFresh(routeItem)) return;
-		setIsLoadingMap((prev) => ({
-			...prev,
-			[routeItem.path]: true
-		}));
-		setLoaderCache((prevState) => Object.keys(prevState).filter((el) => el !== routeItem.path).reduce((acc, cur) => ({
+		if (isCurrentRoute) setIsLoading(true);
+		loaderCacheRef.current = Object.keys(loaderCacheRef.current).filter((el) => el !== routeItem.path).reduce((acc, cur) => ({
 			...acc,
-			[cur]: prevState[cur]
-		}), {}));
+			[cur]: loaderCacheRef.current[cur]
+		}), {});
 		try {
-			setLoaderError(false);
+			if (isCurrentRoute) setLoaderError(false);
 			const result = await routeItem?.loader();
 			cacheTimestampsRef.current = {
 				...cacheTimestampsRef.current,
 				[routeItem.path]: Date.now()
 			};
-			updateCache({
-				key: routeItem.path,
-				value: result
-			});
+			loaderCacheRef.current = {
+				...loaderCacheRef.current,
+				[routeItem.path]: result
+			};
+			if (isCurrentRoute) setLoaderCache(result);
 		} catch {
-			setLoaderError(true);
+			if (isCurrentRoute) setLoaderError(true);
 		} finally {
-			setIsLoadingMap((prev) => ({
-				...prev,
-				[routeItem.path]: false
-			}));
+			if (isCurrentRoute) setIsLoading(false);
 		}
-	}, [isCacheItemFresh, updateCache]);
-	const prefetchLoader = useCallback(async (pathname) => {
-		const item = routeList.find((el) => comparePaths(el, pathname));
-		if (item) await revalidateCache(item);
-	}, [revalidateCache, routeList]);
+	}, [isCacheItemFresh]);
 	return {
-		loaderCache: loaderCache[window.location.pathname],
+		loaderCache,
 		loaderError,
-		prefetchLoader,
+		prefetchLoader: useCallback(async (pathname) => {
+			const item = routeList.find((el) => comparePaths(el, pathname));
+			if (item) await revalidateCache(item);
+		}, [revalidateCache, routeList]),
 		revalidateCache,
-		isLoading: isLoadingMap[window.location.pathname]
+		isLoading
 	};
 };
 //#endregion

package/package.json

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