clear-react-router 1.8.1 → 1.8.3

package/README.md

@@ -463,9 +463,7 @@ const UserProfile = () => {
 
 ### `useInvalidate()`
 
-Returns a function that revalidates cached route data by executing the route lifecycle again.
-
-Calling `invalidate()` clears the cached loader result and immediately runs both `beforeLoad` and `loader` for the specified route. This is useful after mutations or any operation that changes data used by the route.
+Returns a function that revalidates **cached** route data. Calling `invalidate()` clears cached route data and immediately runs the corresponding route loader again.
 
 #### Current route
 
@@ -490,12 +488,12 @@ await invalidate('/posts');
 You can revalidate several routes at once by passing an array of pathnames:
 
 ```tsx
-await invalidate([ '/posts', '/profile', '/settings' ]);
+await invalidate(['/posts', '/profile', '/settings']);
 ```
 
 #### Dynamic routes
 
-When a dynamic route pattern is provided, every cached route matching that pattern will be revalidated.
+When a dynamic route pattern is provided, every cached route that matches the pattern will be revalidated.
 
 For example:
 
@@ -526,7 +524,7 @@ await invalidate('/posts', { withChildren: true });
 await invalidate(['/posts', '/users'], { withChildren: true });
 ```
 
-This will recursively revalidate cached routes inside the route tree.
+This will recursively revalidate all cached child routes.
 
 For example, if the following routes have been visited:
 
@@ -550,17 +548,23 @@ will revalidate the cached child routes:
 /post/23
 /post/42/comments
 ```
+#### Including `beforeLoad`
+
+To include the `beforeLoad` function in the revalidation process, pass the `withBeforeLoad` option:
+
+```tsx
+await invalidate('/posts', { withBeforeLoad: true });
+await invalidate(['/posts', '/users'], { withBeforeLoad: true });
+```
+
 #### Notes
 
-* `invalidate()` re-executes both `beforeLoad` and `loader` for the invalidated route.
-* Only routes that already have cached data are revalidated.
-* Cached data is discarded before the new loader starts.
+* **Only routes that already have cached data are revalidated.**
+* Cached data is cleared before the new loader starts.
 * When used as an event handler, wrap the call in an arrow function:
 
 ```tsx
-<button onClick={() => invalidate()}>
-	Refresh
-</button>
+<button onClick={() => invalidate()}>Refresh</button>
 ```
 
 Passing `invalidate` directly (`onClick={invalidate}`) is not supported because React passes a `MouseEvent` object to event handlers.

package/dist/index.js

@@ -323,7 +323,7 @@ var createNavigate = (routerState, revalidateCache) => {
 //#region runtime/invalidate.ts
 var redirect = () => Promise.resolve();
 var createInvalidate = ({ routeItemDataState, loaderStateRef, timestampMap, currentLoaderState, contextState }, revalidateCache) => {
-	const invalidatePath = async (routeItem, pathname) => {
+	const invalidatePath = async (routeItem, pathname, options) => {
 		const routePathname = routeItemDataState.getState().location.pathname;
 		timestampMap.delete(pathname);
 		const params = getParamsObject({
@@ -331,7 +331,7 @@ var createInvalidate = ({ routeItemDataState, loaderStateRef, timestampMap, curr
 			pathname
 		});
 		try {
-			if (routeItem?.beforeLoad) {
+			if (routeItem?.beforeLoad && options?.withBeforeLoad) {
 				const context = contextState.getState();
 				const setContext = contextState.setState;
 				await routeItem.beforeLoad({
@@ -357,21 +357,21 @@ var createInvalidate = ({ routeItemDataState, loaderStateRef, timestampMap, curr
 		});
 		if (pathname === routePathname) currentLoaderState.setState(loaderStateRef.value);
 	};
-	const invalidateItem = async (pathname, withChildren) => {
+	const invalidateItem = async (pathname, options) => {
 		const routeItem = findRoute(pathname);
 		if (!routeItem) return;
 		const pathnameArray = [];
 		for (const [key] of timestampMap) if (comparePaths(routeItem, key)) pathnameArray.push(key);
-		await Promise.all(pathnameArray.map((pathname) => invalidatePath(routeItem, pathname)));
-		if (withChildren && routeItem.children?.length) {
+		await Promise.all(pathnameArray.map((pathname) => invalidatePath(routeItem, pathname, options)));
+		if (options?.withChildren && routeItem.children?.length) {
 			const childPathList = routeItem.children.map((el) => el.path);
-			await Promise.all(childPathList.map((el) => invalidateItem(`${pathname}${el}`, true)));
+			await Promise.all(childPathList.map((el) => invalidateItem(`${pathname}${el}`, options)));
 		}
 	};
 	return async (pathList, options) => {
 		const routePathname = routeItemDataState.getState().location.pathname;
 		const pathnameList = Array.isArray(pathList) ? pathList : pathList ? [pathList] : [routePathname];
-		await Promise.all(pathnameList.map((pathname) => invalidateItem(pathname, options?.withChildren)));
+		await Promise.all(pathnameList.map((pathname) => invalidateItem(pathname, options)));
 	};
 };
 //#endregion

package/dist/types.d.ts

@@ -138,6 +138,7 @@ export type RouterType = {
 };
 export type InvalidateOptions = {
     withChildren?: boolean;
+    withBeforeLoad?: boolean;
 };
 export type RevalidateCache = ({ routeItem, pathname }: RevalidateCacheArgs) => Promise<unknown> | undefined;
 export type Options = Partial<{

package/package.json

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