clear-react-router 1.0.19 → 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.d.ts

@@ -9,3 +9,4 @@ export { useBeforeUnload } from './hooks/useBeforeUnload';
 export { useRouterContext } from './hooks/useRouterContext';
 export { createRouter } from './utils/utils';
 export { redirect } from './utils/redirect';
+export type { RouteItem, BlockerState } from './types/global';

package/dist/index.js

@@ -128,8 +128,58 @@ var useLatest = (value) => {
 	return ref;
 };
 //#endregion
+//#region \0@oxc-project+runtime@0.132.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.132.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.132.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.132.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region utils/redirect.ts
+var Redirect = class {
+	constructor(url, search) {
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "search", void 0);
+		_defineProperty(this, "cause", void 0);
+		this.url = url;
+		this.search = search;
+		this.cause = "redirect";
+	}
+};
+var redirect = (url, search) => Promise.reject(new Redirect(url, search));
+//#endregion
 //#region hooks/useHandleNavigation.ts
-var isRedirect = (error) => typeof error === "object" && error !== null && error.cause === "redirect";
 var useHandleNavigation = ({ setLocation, routeList, context, revalidateCache }) => {
 	const [blockedRoute, setBlockedRoute] = useState({
 		from: "",
@@ -145,12 +195,11 @@ 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 (error) {
-			const redirect = error;
-			if (!isRedirect(redirect)) return redirect;
-			history.replaceState(null, "", redirect.url);
+		} catch (redirect) {
+			if (!(redirect instanceof Redirect)) return redirect;
+			history.replaceState(null, "", `${redirect.url}${redirect.search || ""}`);
 			setLocation({
 				pathname: redirect.url,
 				search: redirect.search
@@ -218,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
@@ -425,14 +466,4 @@ var useRouterContext = () => {
 	};
 };
 //#endregion
-//#region utils/redirect.ts
-var redirect = (url, search) => {
-	const error = /* @__PURE__ */ new Error();
-	error.cause = "redirect";
-	throw Object.assign(error, {
-		url,
-		search: search || ""
-	});
-};
-//#endregion
 export { Link, Router, createRouter, redirect, useBeforeUnload, useBlocker, useLoaderState, useLocation, useNavigate, useParams, useRouterContext };

package/dist/utils/redirect.d.ts

@@ -1 +1,7 @@
-export declare const redirect: (url: string, search?: string) => never;
+export declare class Redirect {
+    url: string;
+    search?: string;
+    cause: 'redirect';
+    constructor(url: string, search?: string);
+}
+export declare const redirect: (url: string, search?: string) => Promise<never>;

package/package.json

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