clear-react-router 1.7.9 → 1.8.1

package/dist/index.js

@@ -2,7 +2,7 @@ import { Suspense, createContext, lazy, useCallback, useContext, useEffect, useM
 //#region \0rolldown/runtime.js
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 //#endregion
-//#region state/createState.ts
+//#region create.ts
 var create = (initialState) => {
 	let state = initialState;
 	const subscribers = /* @__PURE__ */ new Set();
@@ -28,35 +28,25 @@ var create = (initialState) => {
 var useGlobalState = ({ subscribe, getState, setState }) => {
 	return [useSyncExternalStore(subscribe, getState), setState];
 };
-var createState = (initialState) => {
-	const store = create(initialState);
-	return () => useGlobalState(store);
+//#endregion
+//#region utils/commitState.ts
+var createCommitState = ({ isLoadingState, routeItemDataState, loaderFallbackState, currentLoaderState, prevPathnameRef, loaderStateRef }) => (nextLocation, routeItem) => {
+	routeItemDataState.setState({
+		routeItem,
+		location: nextLocation
+	});
+	currentLoaderState.setState(loaderStateRef.value);
+	isLoadingState.setState(false);
+	loaderFallbackState.setState(void 0);
+	prevPathnameRef.set(nextLocation.pathname);
+	const fullPath = nextLocation.search ? `${nextLocation.pathname}${nextLocation.search}` : nextLocation.pathname;
+	if (fullPath === window.location.pathname + window.location.search) return;
+	history.pushState(null, "", fullPath);
 };
 //#endregion
 //#region constants.ts
 var emptyLoaderState = {};
 //#endregion
-//#region state/state.ts
-var isLoadingState = create(false);
-var useIsLoading = () => useGlobalState(isLoadingState);
-var useBlockedRoute = createState({
-	from: "",
-	to: ""
-});
-var loaderFallbackState = create(void 0);
-var useLoaderFallback = () => useGlobalState(loaderFallbackState);
-var routeItemDataState = create({
-	routeItem: void 0,
-	location: {}
-});
-var useRouteItemData = () => useGlobalState(routeItemDataState);
-var currentLoaderState = create(emptyLoaderState);
-var useCurrentLoaderState = () => useGlobalState(currentLoaderState);
-var scrollMapState = create({});
-var useScrollMap = () => useGlobalState(scrollMapState);
-var contextState = create({});
-var useContextState = () => useGlobalState(contextState);
-//#endregion
 //#region \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
@@ -95,25 +85,40 @@ function _defineProperty(e, r, t) {
 	}) : e[r] = t, e;
 }
 //#endregion
-//#region cell.ts
-var Cell = class {
-	constructor(_value) {
-		_defineProperty(this, "_value", void 0);
-		this._value = _value;
+//#region config/routerConfig.ts
+var RouterConfig = class {
+	constructor() {
+		_defineProperty(this, "routes", []);
+		_defineProperty(this, "prefetch", "hover");
+		_defineProperty(this, "isAnimated", false);
+		_defineProperty(this, "showFallbackOnAnimation", false);
+		_defineProperty(this, "hoverPrefetchDelay", 150);
+		_defineProperty(this, "beforeLoad", void 0);
+		_defineProperty(this, "afterLoad", void 0);
+		_defineProperty(this, "defaultRetry", void 0);
 	}
-	get value() {
-		return this._value;
+	configure(config) {
+		Object.assign(this, config);
 	}
-	set(action) {
-		this._value = typeof action === "function" ? action(this._value) : action;
+};
+var routerConfig = new RouterConfig();
+//#endregion
+//#region utils/commitNavigation.ts
+var createCommitNavigation = (navigationExecutor, prevPathnameRef) => (nextLocation, routeItem) => {
+	const { isAnimated } = routerConfig;
+	if (!isAnimated || !prevPathnameRef.value) {
+		navigationExecutor(nextLocation, routeItem);
+		return;
+	}
+	try {
+		document.startViewTransition(() => navigationExecutor(nextLocation, routeItem));
+	} catch {
+		navigationExecutor(nextLocation, routeItem);
 	}
 };
-var loaderStateRef = new Cell(emptyLoaderState);
-var prevPathnameRef = new Cell("");
-var timestampMap = /* @__PURE__ */ new Map();
 //#endregion
 //#region utils/isCacheItemFresh.ts
-var isCacheItemFresh = ({ routeItem, pathname }) => {
+var createIsCacheItemFresh = (timestampMap) => ({ routeItem, pathname }) => {
 	if (!routeItem) return true;
 	const currentCacheTimestamp = timestampMap.get(pathname);
 	if (!currentCacheTimestamp) return false;
@@ -216,204 +221,397 @@ var comparePaths = (el, pathname) => {
 	const splitPathname = pathname.split("/").filter(Boolean);
 	return splitElementPath.every((item, index) => item === splitPathname[2 * index]) && splitPathname.length === splitElementPath.length + paramsLength;
 };
+var findRoute = (pathname, includeAll) => {
+	if (includeAll) return routerConfig.routes.find((el) => el.path === "/*" || comparePaths(el, pathname));
+	return routerConfig.routes.find((el) => comparePaths(el, pathname));
+};
 //#endregion
-//#region utils/getContext.ts
-var getContext = () => {
-	return {
+//#region runtime/navigate.ts
+var navigationSeq = 0;
+var createNavigate = (routerState, revalidateCache) => {
+	const { loaderStateRef, scrollMapState, prevPathnameRef, loaderFallbackState, isLoadingState, contextState, timestampMap } = routerState;
+	const commitNavigation = createCommitNavigation(createCommitState(routerState), prevPathnameRef);
+	const isCacheItemFresh = createIsCacheItemFresh(timestampMap);
+	const getContext = () => ({
 		context: contextState.getState(),
 		setContext: contextState.setState
+	});
+	const routeResolve = (location) => {
+		loaderStateRef.set(emptyLoaderState);
+		const nextItem = findRoute(location.pathname, true);
+		return {
+			nextItem,
+			params: getParamsObject({
+				params: nextItem?.params,
+				pathname: location.pathname
+			})
+		};
 	};
+	const beforeLoad = async (routeItem, params) => {
+		const { beforeLoad } = routerConfig;
+		const runBeforeLoad = async (loaderFn) => {
+			const redirect = async (redirected) => await navigate(typeof redirected === "string" ? { pathname: redirected } : redirected);
+			try {
+				await loaderFn({
+					...getContext(),
+					redirect,
+					params
+				});
+				loaderStateRef.set((prev) => ({
+					...prev,
+					beforeLoadError: null
+				}));
+			} catch (error) {
+				loaderStateRef.set((prev) => ({
+					...prev,
+					beforeLoadError: error
+				}));
+			}
+		};
+		if (beforeLoad) await runBeforeLoad(beforeLoad);
+		if (routeItem?.beforeLoad) await runBeforeLoad(routeItem?.beforeLoad);
+	};
+	const prepareNavigation = (routeItem, location) => {
+		const { isAnimated, showFallbackOnAnimation: showFallback } = routerConfig;
+		scrollMapState.setState((prevState) => {
+			const scrollPosition = document.scrollingElement?.scrollTop ?? 0;
+			if (!scrollPosition || prevState[prevPathnameRef.value] === scrollPosition) return prevState;
+			return {
+				...prevState,
+				[prevPathnameRef.value]: scrollPosition
+			};
+		});
+		loaderFallbackState.setState(isCacheItemFresh({
+			routeItem,
+			pathname: location.pathname
+		}) || isAnimated && !showFallback ? void 0 : routeItem?.loaderFallback);
+	};
+	const loader = async (routeItem, location) => {
+		if (!routeItem?.loader) return;
+		isLoadingState.setState(true);
+		await revalidateCache({
+			routeItem,
+			pathname: location.pathname
+		});
+	};
+	const afterLoad = async (routeItem, params) => {
+		const { afterLoad } = routerConfig;
+		if (routeItem?.afterLoad) await routeItem.afterLoad({
+			...getContext(),
+			params
+		});
+		if (afterLoad) await afterLoad({
+			...getContext(),
+			params
+		});
+	};
+	const navigate = async (nextLocation) => {
+		navigationSeq = navigationSeq + 1;
+		const seq = navigationSeq;
+		const { nextItem, params } = routeResolve(nextLocation);
+		await beforeLoad(nextItem, params);
+		if (seq !== navigationSeq) return;
+		prepareNavigation(nextItem, nextLocation);
+		await loader(nextItem, nextLocation);
+		if (seq !== navigationSeq) return;
+		commitNavigation(nextLocation, nextItem);
+		await afterLoad(nextItem, params);
+	};
+	return navigate;
 };
 //#endregion
-//#region utils/revalidateCache.ts
-var loaderMapRef = {};
-var loadingPromises = /* @__PURE__ */ new Map();
-var revalidateCache = ({ routeItem, pathname }) => {
-	if (!routeItem?.loader) return;
-	if (loadingPromises.has(pathname)) return loadingPromises.get(pathname);
-	if (isCacheItemFresh({
-		routeItem,
-		pathname
-	})) {
-		loaderStateRef.set(loaderMapRef[pathname]);
-		return;
-	}
-	const promise = (async () => {
-		if (!routeItem?.loader) return;
+//#region runtime/invalidate.ts
+var redirect = () => Promise.resolve();
+var createInvalidate = ({ routeItemDataState, loaderStateRef, timestampMap, currentLoaderState, contextState }, revalidateCache) => {
+	const invalidatePath = async (routeItem, pathname) => {
+		const routePathname = routeItemDataState.getState().location.pathname;
+		timestampMap.delete(pathname);
+		const params = getParamsObject({
+			params: routeItem?.params,
+			pathname
+		});
 		try {
-			const { context, setContext } = getContext();
-			const params = getParamsObject({
-				params: routeItem.params,
-				pathname
-			});
-			const result = await routeItem?.loader({
-				params,
-				context,
-				setContext
-			});
-			timestampMap.set(pathname, Date.now());
+			if (routeItem?.beforeLoad) {
+				const context = contextState.getState();
+				const setContext = contextState.setState;
+				await routeItem.beforeLoad({
+					context,
+					redirect,
+					params,
+					setContext
+				});
+			}
 			loaderStateRef.set((prev) => ({
 				...prev,
-				data: result,
-				loaderError: null
+				beforeLoadError: null
 			}));
-			loaderMapRef[pathname] = loaderStateRef.value;
 		} catch (error) {
 			loaderStateRef.set((prev) => ({
 				...prev,
-				data: null,
-				loaderError: error
+				beforeLoadError: error
 			}));
-		} finally {
-			loadingPromises.delete(pathname);
 		}
-	})();
-	loadingPromises.set(pathname, promise);
-	return promise;
+		await revalidateCache({
+			routeItem,
+			pathname
+		});
+		if (pathname === routePathname) currentLoaderState.setState(loaderStateRef.value);
+	};
+	const invalidateItem = async (pathname, withChildren) => {
+		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) {
+			const childPathList = routeItem.children.map((el) => el.path);
+			await Promise.all(childPathList.map((el) => invalidateItem(`${pathname}${el}`, true)));
+		}
+	};
+	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)));
+	};
 };
 //#endregion
-//#region utils/commitState.ts
-var commitState = (nextLocation, routeItem) => {
-	routeItemDataState.setState({
-		routeItem,
-		location: nextLocation
+//#region runtime/prefetch.ts
+var createPrefetch = (revalidateCache) => async (pathname) => {
+	const item = findRoute(pathname);
+	if (item) await revalidateCache({
+		routeItem: item,
+		pathname
 	});
-	currentLoaderState.setState(loaderStateRef.value);
-	isLoadingState.setState(false);
-	loaderFallbackState.setState(void 0);
-	prevPathnameRef.set(nextLocation.pathname);
-	const fullPath = nextLocation.search ? `${nextLocation.pathname}${nextLocation.search}` : nextLocation.pathname;
-	if (fullPath === window.location.pathname + window.location.search) return;
-	history.pushState(null, "", fullPath);
 };
 //#endregion
-//#region config/routerConfig.ts
-var RouterConfig = class {
-	constructor() {
-		_defineProperty(this, "routes", []);
-		_defineProperty(this, "prefetch", "hover");
-		_defineProperty(this, "isAnimated", false);
-		_defineProperty(this, "showFallbackOnAnimation", false);
-		_defineProperty(this, "hoverPrefetchDelay", 150);
-		_defineProperty(this, "beforeLoad", void 0);
-		_defineProperty(this, "afterLoad", void 0);
-	}
-	configure(config) {
-		Object.assign(this, config);
-	}
+//#region utils/revalidateCache.ts
+var loaderMapRef = {};
+var loadingPromises = /* @__PURE__ */ new Map();
+var isObjectRetry = (arg) => typeof arg === "object";
+var createRetry = (arg) => {
+	if (arg === void 0) return null;
+	return {
+		count: isObjectRetry(arg) ? arg.count : arg,
+		delay: isObjectRetry(arg) ? arg.delay : 0
+	};
+};
+var getRetry = (routeItem) => {
+	const routeRetry = createRetry(routeItem?.retry);
+	const globalRetry = createRetry(routerConfig.defaultRetry);
+	if (!routeRetry && !globalRetry) return null;
+	return {
+		count: routeRetry ? routeRetry.count : globalRetry?.count || 0,
+		delay: routeRetry ? routeRetry.delay : globalRetry?.delay || 0
+	};
+};
+var sleep = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var createRevalidateCache = (routerState) => {
+	const revalidateCache = async ({ routeItem, pathname }, retried = 0) => {
+		if (!routeItem?.loader) return;
+		const isCacheItemFresh = createIsCacheItemFresh(routerState.timestampMap);
+		const { loaderStateRef, timestampMap, contextState } = routerState;
+		if (loadingPromises.has(pathname)) return loadingPromises.get(pathname);
+		if (isCacheItemFresh({
+			routeItem,
+			pathname
+		})) {
+			loaderStateRef.set(loaderMapRef[pathname]);
+			return;
+		}
+		const promise = (async () => {
+			if (!routeItem?.loader) return;
+			try {
+				const context = contextState.getState();
+				const setContext = contextState.setState;
+				const params = getParamsObject({
+					params: routeItem.params,
+					pathname
+				});
+				const result = await routeItem?.loader({
+					params,
+					context,
+					setContext
+				});
+				timestampMap.set(pathname, Date.now());
+				loaderStateRef.set((prev) => ({
+					...prev,
+					data: result,
+					loaderError: null
+				}));
+				loaderMapRef[pathname] = loaderStateRef.value;
+			} catch (error) {
+				const retry = getRetry(routeItem);
+				if (retry && retry.count > retried) {
+					loadingPromises.delete(pathname);
+					if (retry.delay) await sleep(retry.delay);
+					await revalidateCache({
+						routeItem,
+						pathname
+					}, retried + 1);
+				} else loaderStateRef.set((prev) => ({
+					...prev,
+					data: null,
+					loaderError: error
+				}));
+			} finally {
+				loadingPromises.delete(pathname);
+			}
+		})();
+		loadingPromises.set(pathname, promise);
+		return promise;
+	};
+	return revalidateCache;
 };
-var routerConfig = new RouterConfig();
 //#endregion
-//#region utils/commitNavigation.ts
-var commitNavigation = (nextLocation, routeItem) => {
-	const { isAnimated } = routerConfig;
-	if (!isAnimated || !prevPathnameRef.value) {
-		commitState(nextLocation, routeItem);
-		return;
+//#region cell.ts
+var Cell = class {
+	constructor(_value) {
+		_defineProperty(this, "_value", void 0);
+		this._value = _value;
 	}
-	try {
-		document.startViewTransition(() => commitState(nextLocation, routeItem));
-	} catch {
-		commitState(nextLocation, routeItem);
+	get value() {
+		return this._value;
+	}
+	set(action) {
+		this._value = typeof action === "function" ? action(this._value) : action;
 	}
 };
-var findRoute = (pathname, includeAll) => {
-	if (includeAll) return routerConfig.routes.find((el) => el.path === "*" || comparePaths(el, pathname));
-	return routerConfig.routes.find((el) => el.path === "*" || comparePaths(el, pathname));
-};
+new Cell(emptyLoaderState);
+new Cell("");
 //#endregion
-//#region runtime/navigate.ts
-var navigationSeq = 0;
-var routeResolve = (location) => {
-	loaderStateRef.set(emptyLoaderState);
-	const nextItem = findRoute(location.pathname, true);
-	return {
-		nextItem,
-		params: getParamsObject({
-			params: nextItem?.params,
+//#region utils/createRouterInstance.ts
+var createRouterInstance = () => {
+	const routerState = {
+		isLoadingState: create(false),
+		loaderFallbackState: create(void 0),
+		routeItemDataState: create({
+			routeItem: void 0,
+			location: {}
+		}),
+		currentLoaderState: create(emptyLoaderState),
+		scrollMapState: create({}),
+		contextState: create({}),
+		blockedRouteState: create({
+			from: "",
+			to: ""
+		}),
+		loaderStateRef: new Cell(emptyLoaderState),
+		prevPathnameRef: new Cell(""),
+		timestampMap: /* @__PURE__ */ new Map()
+	};
+	const revalidateCache = createRevalidateCache(routerState);
+	const navigate = createNavigate(routerState, revalidateCache);
+	const invalidate = createInvalidate(routerState, revalidateCache);
+	const prefetch = createPrefetch(revalidateCache);
+	const useGetAction = (actionKey) => {
+		const { routeItem, location } = routerState.routeItemDataState.getState();
+		const context = routerState.contextState.getState();
+		const setContext = routerState.contextState.setState;
+		const params = getParamsObject({
+			params: routeItem?.params,
 			pathname: location.pathname
-		})
+		});
+		if (!routeItem) throw new Error("Route not found");
+		if (!routeItem.actions) throw new Error("Route action creator not found");
+		const action = routeItem.actions({
+			context,
+			setContext,
+			params,
+			invalidate
+		})[actionKey];
+		if (!action) throw new Error(`Action "${actionKey}" not found`);
+		return {
+			currentAction: action,
+			invalidate
+		};
 	};
-};
-var beforeLoad = async (routeItem, params) => {
-	const { beforeLoad } = routerConfig;
-	const runBeforeLoad = async (loaderFn) => {
-		const redirect = async (redirected) => await navigate(typeof redirected === "string" ? { pathname: redirected } : redirected);
-		try {
-			await loaderFn({
-				...getContext(),
-				redirect,
-				params
-			});
-			loaderStateRef.set((prev) => ({
-				...prev,
-				beforeLoadError: null
-			}));
-		} catch (error) {
-			loaderStateRef.set((prev) => ({
-				...prev,
-				beforeLoadError: error
-			}));
+	return {
+		state: {
+			isLoadingState: routerState.isLoadingState,
+			loaderFallbackState: routerState.loaderFallbackState,
+			routeItemDataState: routerState.routeItemDataState,
+			currentLoaderState: routerState.currentLoaderState,
+			scrollMapState: routerState.scrollMapState,
+			contextState: routerState.contextState,
+			blockedRouteState: routerState.blockedRouteState,
+			prevPathnameRef: routerState.prevPathnameRef
+		},
+		runtime: {
+			navigate,
+			invalidate,
+			prefetch
+		},
+		hooks: {
+			useIsLoading: () => useGlobalState(routerState.isLoadingState),
+			useBlockedRoute: () => useGlobalState(routerState.blockedRouteState),
+			useLoaderFallback: () => useGlobalState(routerState.loaderFallbackState),
+			useRouteItemData: () => useGlobalState(routerState.routeItemDataState),
+			useCurrentLoaderState: () => useGlobalState(routerState.currentLoaderState),
+			useScrollMap: () => useGlobalState(routerState.scrollMapState),
+			useContextState: () => useGlobalState(routerState.contextState),
+			useParams: () => {
+				const routeItemData = routerState.routeItemDataState.getState();
+				return getParamsObject({
+					params: routeItemData.routeItem?.params,
+					pathname: routeItemData.location.pathname
+				});
+			},
+			useNavigate: () => {
+				const { blockedRouteState } = routerState;
+				const { location } = routerState.routeItemDataState.getState();
+				return async (arg) => {
+					if (arg !== -1 && blockedRouteState.getState().from) {
+						const to = typeof arg === "object" ? arg.pathname : arg;
+						blockedRouteState.setState((prevState) => ({
+							...prevState,
+							to
+						}));
+						return;
+					}
+					if (arg === -1) return history.go(arg);
+					if (typeof arg === "string") {
+						if (arg !== location.pathname) await navigate({ pathname: arg });
+					} else if (JSON.stringify(arg) !== JSON.stringify(location)) await navigate(arg);
+				};
+			},
+			useRestoreScroll: () => {
+				const { pathname } = routerState.routeItemDataState.getState().location;
+				const scrollMap = routerState.scrollMapState.getState();
+				return () => {
+					if (scrollMap[pathname]) requestAnimationFrame(() => window.scrollTo({
+						top: scrollMap[pathname],
+						behavior: "smooth"
+					}));
+				};
+			},
+			useGetAction,
+			useAction: (action, options = {}) => {
+				const { currentAction, invalidate } = useGetAction(action);
+				return async (formData) => {
+					try {
+						const result = await currentAction(formData);
+						await invalidate();
+						options.onSuccess?.(result);
+					} catch (error) {
+						options.onError?.(error);
+					}
+				};
+			}
 		}
 	};
-	if (beforeLoad) await runBeforeLoad(beforeLoad);
-	if (routeItem?.beforeLoad) await runBeforeLoad(routeItem?.beforeLoad);
-};
-var prepareNavigation = (routeItem, location) => {
-	const { isAnimated, showFallbackOnAnimation: showFallback } = routerConfig;
-	scrollMapState.setState((prevState) => {
-		const scrollPosition = document.scrollingElement?.scrollTop ?? 0;
-		if (!scrollPosition || prevState[prevPathnameRef.value] === scrollPosition) return prevState;
-		return {
-			...prevState,
-			[prevPathnameRef.value]: scrollPosition
-		};
-	});
-	loaderFallbackState.setState(isCacheItemFresh({
-		routeItem,
-		pathname: location.pathname
-	}) || isAnimated && !showFallback ? void 0 : routeItem?.loaderFallback);
-};
-var loader = async (routeItem, location) => {
-	if (!routeItem?.loader) return;
-	isLoadingState.setState(true);
-	await revalidateCache({
-		routeItem,
-		pathname: location.pathname
-	});
-};
-var afterLoad = async (routeItem, params) => {
-	const { afterLoad } = routerConfig;
-	if (routeItem?.afterLoad) await routeItem.afterLoad({
-		...getContext(),
-		params
-	});
-	if (afterLoad) await afterLoad({
-		...getContext(),
-		params
-	});
-};
-var navigate = async (nextLocation) => {
-	navigationSeq = navigationSeq + 1;
-	const seq = navigationSeq;
-	const { nextItem, params } = routeResolve(nextLocation);
-	await beforeLoad(nextItem, params);
-	if (seq !== navigationSeq) return;
-	prepareNavigation(nextItem, nextLocation);
-	await loader(nextItem, nextLocation);
-	if (seq !== navigationSeq) return;
-	commitNavigation(nextLocation, nextItem);
-	await afterLoad(nextItem, params);
 };
 //#endregion
+//#region instance.ts
+var router = createRouterInstance();
+//#endregion
 //#region hooks/useNavigation.ts
 var useNavigation = () => {
-	const [blockedRoute, setBlockedRoute] = useBlockedRoute();
+	const { state: { prevPathnameRef, blockedRouteState }, runtime: { navigate } } = router;
 	useEffect(() => {
 		const handler = async (event) => {
 			const newLocation = parseWindowLocation(event.target.location);
-			if (prevPathnameRef.value === blockedRoute.from) {
-				setBlockedRoute({
+			if (prevPathnameRef.value === blockedRouteState.getState().from) {
+				blockedRouteState.setState({
 					from: prevPathnameRef.value,
 					to: newLocation.pathname
 				});
@@ -422,12 +620,16 @@ var useNavigation = () => {
 		};
 		window.addEventListener("popstate", handler);
 		return () => window.removeEventListener("popstate", handler);
-	}, [blockedRoute.from, setBlockedRoute]);
+	}, [
+		blockedRouteState,
+		navigate,
+		prevPathnameRef.value
+	]);
 	useEffect(() => {
 		const currentLocation = parseWindowLocation(window.location);
 		navigate(currentLocation);
 		prevPathnameRef.set(currentLocation.pathname);
-	}, []);
+	}, [navigate, prevPathnameRef]);
 };
 //#endregion
 //#region hooks/useApplyCustomAnimation.ts
@@ -467,20 +669,16 @@ var useApplyCustomAnimation = (animationDuration) => {
 	}, [animationDuration]);
 };
 //#endregion
+//#region hooks/useLocation.ts
+var useLocation = () => {
+	const [routeItemData] = router.hooks.useRouteItemData();
+	return routeItemData.location;
+};
+//#endregion
 //#region hooks/usePreserveScroll.ts
 var usePreserveScroll = (preserveScroll) => {
-	const [routeItemData] = useRouteItemData();
-	const [scrollMap] = useScrollMap();
-	const { pathname } = routeItemData.location;
-	const restoreScroll = useCallback(() => {
-		if (!pathname || !scrollMap[pathname]) return;
-		requestAnimationFrame(() => {
-			window.scrollTo({
-				top: scrollMap[pathname],
-				behavior: "smooth"
-			});
-		});
-	}, [pathname, scrollMap]);
+	const restoreScroll = router.hooks.useRestoreScroll();
+	const { pathname } = useLocation();
 	useEffect(() => {
 		if (preserveScroll) restoreScroll();
 	}, [
@@ -497,7 +695,7 @@ var useSetRouterConfig = (routerProps) => {
 //#endregion
 //#region hooks/useSetInitialContext.ts
 var useSetInitialContext = (initialContext) => {
-	const [, setContext] = useContextState();
+	const [, setContext] = router.hooks.useContextState();
 	useEffect(() => {
 		if (initialContext) setContext(initialContext);
 	}, [initialContext, setContext]);
@@ -514,7 +712,8 @@ var renderElement = (Component) => {
 //#endregion
 //#region components/Router.tsx
 var EmptyBoundary = ({ children }) => children;
-var Router = ({ routes, beforeLoad, afterLoad, animationDuration, isAnimated = false, spinner = true, preserveScroll = true, showFallbackOnAnimation = false, prefetch = "hover", hoverPrefetchDelay = 150, errorBoundary: ErrorBoundary = EmptyBoundary, context: initialContext, defaultLoaderFallback, defaultErrorElement }) => {
+var Router = ({ routes, beforeLoad, afterLoad, animationDuration, isAnimated = false, spinner = true, preserveScroll = true, showFallbackOnAnimation = false, prefetch = "hover", hoverPrefetchDelay = 150, errorBoundary: ErrorBoundary = EmptyBoundary, context: initialContext, defaultLoaderFallback, defaultErrorElement, defaultRetry }) => {
+	const { useIsLoading, useLoaderFallback, useRouteItemData, useCurrentLoaderState } = router.hooks;
 	const [isLoading] = useIsLoading();
 	const [currentLoaderFallback] = useLoaderFallback();
 	const [routeItemData] = useRouteItemData();
@@ -527,7 +726,8 @@ var Router = ({ routes, beforeLoad, afterLoad, animationDuration, isAnimated = f
 		hoverPrefetchDelay,
 		showFallbackOnAnimation,
 		beforeLoad,
-		afterLoad
+		afterLoad,
+		defaultRetry
 	});
 	useApplyCustomAnimation(animationDuration);
 	useSetInitialContext(initialContext);
@@ -546,98 +746,51 @@ var Router = ({ routes, beforeLoad, afterLoad, animationDuration, isAnimated = f
 	});
 };
 //#endregion
-//#region runtime/prefetch.ts
-var prefetch = async (pathname) => {
-	const item = findRoute(pathname);
-	if (item) await revalidateCache({
-		routeItem: item,
-		pathname
-	});
-};
-//#endregion
-//#region hooks/useLocation.ts
-var useLocation = () => {
-	const [routeItemData] = useRouteItemData();
-	return routeItemData.location;
-};
-//#endregion
-//#region hooks/useLatest.ts
-var useLatest = (value) => {
-	const ref = useRef(value);
-	useEffect(() => {
-		ref.current = value;
-	}, [value]);
-	return ref;
-};
-//#endregion
 //#region hooks/useNavigate.ts
-var useNavigate = () => {
-	const [blockedRoute, setBlockedRoute] = useBlockedRoute();
-	const locationRef = useLatest(useLocation());
-	const blockedRouteRef = useLatest(blockedRoute);
-	return useCallback(async (arg) => {
-		if (!navigate) throw new Error("Router has not been initialized. Did you forget to render <Router />?");
-		if (arg !== -1 && blockedRouteRef.current.from) {
-			const to = typeof arg === "object" ? arg.pathname : arg;
-			setBlockedRoute((prevState) => ({
-				...prevState,
-				to
-			}));
-			return;
-		}
-		if (arg === -1) return history.go(arg);
-		if (typeof arg === "string") {
-			if (arg !== locationRef.current.pathname) await navigate({ pathname: arg });
-		} else if (JSON.stringify(arg) !== JSON.stringify(locationRef.current)) await navigate(arg);
-	}, [
-		blockedRouteRef,
-		locationRef,
-		setBlockedRoute
-	]);
-};
+var useNavigate = router.hooks.useNavigate;
 //#endregion
 //#region components/Link.tsx
 var Link = ({ children, to, prefetch: prefetchLink, hoverPrefetchDelay }) => {
 	const { prefetch: configPrefetch, hoverPrefetchDelay: configPrefetchDelay } = routerConfig;
-	const prefetch$1 = prefetchLink || configPrefetch;
+	const prefetch = prefetchLink || configPrefetch;
 	const prefetchDelay = hoverPrefetchDelay ?? configPrefetchDelay;
 	const navigate = useNavigate();
 	const timeout = useRef(0);
 	const ref = useRef(null);
 	const onMouseEnter = useCallback(() => {
-		if (prefetch$1 !== "hover" || !prefetchDelay) return;
+		if (prefetch !== "hover" || !prefetchDelay) return;
 		if (timeout.current) clearTimeout(timeout.current);
-		timeout.current = window.setTimeout(() => prefetch(to), prefetchDelay);
+		timeout.current = window.setTimeout(() => router.runtime.prefetch(to), prefetchDelay);
 	}, [
-		prefetch$1,
+		prefetch,
 		prefetchDelay,
 		to
 	]);
 	const onMouseLeave = useCallback(() => {
-		if (prefetch$1 !== "hover" || !prefetchDelay) return;
+		if (prefetch !== "hover" || !prefetchDelay) return;
 		if (timeout.current) {
 			clearTimeout(timeout.current);
 			timeout.current = 0;
 		}
-	}, [prefetch$1, prefetchDelay]);
+	}, [prefetch, prefetchDelay]);
 	useEffect(() => {
-		if (prefetch$1 !== "render") return;
+		if (prefetch !== "render") return;
 		(async () => {
-			await prefetch(to);
+			await router.runtime.prefetch(to);
 		})();
-	}, [prefetch$1, to]);
+	}, [prefetch, to]);
 	useEffect(() => {
-		if (prefetch$1 !== "viewport") return;
+		if (prefetch !== "viewport") return;
 		const element = ref.current;
 		const observer = new IntersectionObserver(async () => {
-			await prefetch(to);
+			await router.runtime.prefetch(to);
 			observer.disconnect();
 		});
 		if (element) observer.observe(element);
 		return () => {
 			if (element) observer.disconnect();
 		};
-	}, [prefetch$1, to]);
+	}, [prefetch, to]);
 	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("a", {
 		ref,
 		style: { cursor: "pointer" },
@@ -657,97 +810,9 @@ var FormProvider = ({ children, isSubmitting }) => /* @__PURE__ */ (0, import_js
 	children
 });
 //#endregion
-//#region runtime/invalidate.ts
-var redirect = () => Promise.resolve();
-var invalidatePath = async (routeItem, pathname) => {
-	const routePathname = routeItemDataState.getState().location.pathname;
-	timestampMap.delete(pathname);
-	const params = getParamsObject({
-		params: routeItem?.params,
-		pathname
-	});
-	try {
-		if (routeItem?.beforeLoad) {
-			const { context, setContext } = getContext();
-			await routeItem.beforeLoad({
-				context,
-				redirect,
-				params,
-				setContext
-			});
-		}
-		loaderStateRef.set((prev) => ({
-			...prev,
-			beforeLoadError: null
-		}));
-	} catch (error) {
-		loaderStateRef.set((prev) => ({
-			...prev,
-			beforeLoadError: error
-		}));
-	}
-	await revalidateCache({
-		routeItem,
-		pathname
-	});
-	if (pathname === routePathname) currentLoaderState.setState(loaderStateRef.value);
-};
-var invalidateItem = async (pathname, withChildren) => {
-	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) {
-		const childPathList = routeItem.children.map((el) => el.path);
-		await Promise.all(childPathList.map((el) => invalidateItem(`${pathname}${el}`, withChildren)));
-	}
-};
-async function invalidate(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)));
-}
-//#endregion
-//#region hooks/useInvalidate.ts
-var useInvalidate = () => invalidate;
-//#endregion
-//#region hooks/useParams.ts
-var useParams = () => {
-	const [routeItemData] = useRouteItemData();
-	const { routeItem, location: { pathname } } = routeItemData;
-	return useMemo(() => routeItem ? getParamsObject({
-		params: routeItem?.params,
-		pathname
-	}) : void 0, [pathname, routeItem]);
-};
-//#endregion
-//#region hooks/useGetAction.ts
-var useGetAction = (actionKey) => {
-	const invalidate = useInvalidate();
-	const [routeItemData] = useRouteItemData();
-	const [context, setContext] = useContextState();
-	const params = useParams();
-	const { routeItem } = routeItemData;
-	const latestContext = useLatest(context);
-	if (!routeItem) throw new Error("Route not found");
-	if (!routeItem.actions) throw new Error("Route action creator not found");
-	const action = routeItem.actions({
-		context: latestContext.current,
-		setContext,
-		params,
-		invalidate
-	})[actionKey];
-	if (!action) throw new Error(`Action "${actionKey}" not found`);
-	return {
-		currentAction: action,
-		invalidate
-	};
-};
-//#endregion
 //#region components/Form.tsx
 var Form = ({ children, action, onSuccess, onError, autoReset = true }) => {
-	const { currentAction, invalidate } = useGetAction(action);
+	const { currentAction, invalidate } = router.hooks.useGetAction(action);
 	const [isSubmitting, setIsSubmitting] = useState(false);
 	const onSubmit = async (evt) => {
 		evt.preventDefault();
@@ -772,14 +837,21 @@ var Form = ({ children, action, onSuccess, onError, autoReset = true }) => {
 	});
 };
 //#endregion
+//#region hooks/useParams.ts
+var useParams = router.hooks.useParams;
+//#endregion
 //#region hooks/useLoaderState.ts
 var useLoaderState = () => {
-	const [loaderState] = useCurrentLoaderState();
+	const [loaderState] = router.hooks.useCurrentLoaderState();
 	return loaderState;
 };
 //#endregion
+//#region hooks/useInvalidate.ts
+var useInvalidate = () => router.runtime.invalidate;
+//#endregion
 //#region hooks/useBlocker.ts
 var useBlocker = (blockerFn) => {
+	const { hooks: { useBlockedRoute, useRouteItemData }, runtime: { navigate } } = router;
 	const [blockedRoute, setBlockedRoute] = useBlockedRoute();
 	const [routeItemData] = useRouteItemData();
 	const { location: { pathname } } = routeItemData;
@@ -799,7 +871,7 @@ var useBlocker = (blockerFn) => {
 			from: "",
 			to: ""
 		};
-	}), [setBlockedRoute]);
+	}), [navigate, setBlockedRoute]);
 	const blockerState = useMemo(() => {
 		if (blockedRoute.from && blockedRoute.to) return "blocked";
 		if (blockedRoute.from) return "charged";
@@ -822,29 +894,11 @@ var useBlocker = (blockerFn) => {
 };
 //#endregion
 //#region hooks/useAction.ts
-var useAction = (action, options = {}) => {
-	const { currentAction, invalidate } = useGetAction(action);
-	const latestOnSuccess = useLatest(options?.onSuccess);
-	const latestOnError = useLatest(options?.onError);
-	return useCallback(async (formData) => {
-		try {
-			const result = await currentAction(formData);
-			await invalidate();
-			latestOnSuccess.current?.(result);
-		} catch (error) {
-			latestOnError.current?.(error);
-		}
-	}, [
-		currentAction,
-		invalidate,
-		latestOnError,
-		latestOnSuccess
-	]);
-};
+var useAction = router.hooks.useAction;
 //#endregion
 //#region hooks/useRouterContext.ts
 var useRouterContext = () => {
-	const [context, setContext] = useContextState();
+	const [context, setContext] = router.hooks.useContextState();
 	return {
 		context,
 		setContext
@@ -880,6 +934,15 @@ var useSearch = () => {
 	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 };
 //#endregion
+//#region hooks/useLatest.ts
+var useLatest = (value) => {
+	const ref = useRef(value);
+	useEffect(() => {
+		ref.current = value;
+	}, [value]);
+	return ref;
+};
+//#endregion
 //#region hooks/useSearchParams.ts
 var useSearchParams = () => {
 	const search = useSearch();