react-router 8.4.0 → 8.5.0

package/dist/production/lib/router/router.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -10,7 +10,7 @@
  */
 import { PROTOCOL_RELATIVE_URL_REGEX, normalizeProtocolRelativeUrl } from "./url.js";
 import { createBrowserURLImpl, createLocation, createPath, invariant, parsePath, warning } from "./history.js";
-import { ErrorResponseImpl, RouterContextProvider, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createDataFunctionUrl, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, prependBasename, removeDoubleSlashes, resolveTo, stripBasename } from "./utils.js";
+import { DiscoveryCancelledError, ErrorResponseImpl, RouterContextProvider, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createDataFunctionUrl, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, prependBasename, removeDoubleSlashes, resolveTo, stripBasename } from "./utils.js";
 import { consumeInstrumentationClientResultMetaReceiver, getRouteInstrumentationUpdates, instrumentClientSideRouter } from "./instrumentation.js";
 import { V6RegExMatcher } from "./matcher.js";
 import { getRoutePatternMatcher } from "./matcher-route-pattern.preload.js";
@@ -114,6 +114,7 @@ var DataRoutes = class {
 		}
 	}
 };
+const clientErrors = /* @__PURE__ */ new WeakMap();
 /**
 * Create a router and listen to history POP navigations
 */
@@ -142,7 +143,6 @@ function createRouter(init) {
 	let dataStrategyImpl = init.dataStrategy || defaultDataStrategyWithMiddleware;
 	let unlistenHistory = null;
 	let subscribers = /* @__PURE__ */ new Set();
-	let bufferedInitialStateUpdate = null;
 	let savedScrollPositions = null;
 	let getScrollRestorationKey = null;
 	let getScrollPosition = null;
@@ -213,6 +213,8 @@ function createRouter(init) {
 		blockers: /* @__PURE__ */ new Map()
 	};
 	let pendingAction = "POP";
+	let pendingPopstateDelta = 0;
+	let pendingDiscoveryCancellation;
 	let pendingPopstateNavigationDfd = null;
 	let pendingPreventScrollReset = false;
 	let pendingNavigationController;
@@ -273,6 +275,7 @@ function createRouter(init) {
 				pendingPopstateNavigationDfd = null;
 				return;
 			}
+			if (future.unstable_customRouteDiscovery) pendingPopstateDelta += delta || 0;
 			return startNavigation(historyAction, location);
 		});
 		if (isBrowser) {
@@ -294,19 +297,16 @@ function createRouter(init) {
 	}
 	function subscribe(fn) {
 		subscribers.add(fn);
-		if (bufferedInitialStateUpdate) {
-			let { newErrors } = bufferedInitialStateUpdate;
-			bufferedInitialStateUpdate = null;
-			fn(state, {
-				deletedFetchers: [],
-				newErrors,
-				viewTransitionOpts: void 0,
-				flushSync: false
-			});
-		}
 		return () => subscribers.delete(fn);
 	}
 	function updateState(newState, opts = {}) {
+		let newErrors = newState.errors ?? null;
+		let cachedErrors = newErrors ? clientErrors.get(newErrors) : void 0;
+		if (cachedErrors !== void 0) newErrors = cachedErrors;
+		if (newState.errors !== void 0 || newState.initialized) {
+			if (state.errors) clientErrors.delete(state.errors);
+			if (newState.errors) clientErrors.set(newState.errors, newErrors);
+		}
 		if (newState.matches) newState.matches = newState.matches.map((m) => {
 			let route = manifest[m.route.id];
 			let matchRoute = m.route;
@@ -329,10 +329,9 @@ function createRouter(init) {
 		fetchersQueuedForDeletion.forEach((key) => {
 			if (!state.fetchers.has(key) && !fetchControllers.has(key)) unmountedFetchers.push(key);
 		});
-		if (subscribers.size === 0) bufferedInitialStateUpdate = { newErrors: newState.errors ?? null };
 		[...subscribers].forEach((subscriber) => subscriber(state, {
 			deletedFetchers: unmountedFetchers,
-			newErrors: newState.errors ?? null,
+			newErrors,
 			viewTransitionOpts: opts.viewTransitionOpts,
 			flushSync: opts.flushSync === true
 		}));
@@ -397,17 +396,22 @@ function createRouter(init) {
 			viewTransitionOpts,
 			flushSync: flushSync === true
 		});
+		resetPendingNavigation();
+		pendingPopstateNavigationDfd?.resolve();
+		pendingPopstateNavigationDfd = null;
+		pendingRevalidationDfd?.resolve();
+		pendingRevalidationDfd = null;
+	}
+	function resetPendingNavigation() {
+		pendingPopstateDelta = 0;
 		pendingAction = "POP";
 		pendingPreventScrollReset = false;
 		pendingViewTransitionEnabled = false;
 		isUninterruptedRevalidation = false;
 		isRevalidationRequired = false;
-		pendingPopstateNavigationDfd?.resolve();
-		pendingPopstateNavigationDfd = null;
-		pendingRevalidationDfd?.resolve();
-		pendingRevalidationDfd = null;
 	}
 	async function navigate(to, opts) {
+		if (pendingDiscoveryCancellation) await pendingDiscoveryCancellation;
 		pendingPopstateNavigationDfd?.resolve();
 		pendingPopstateNavigationDfd = null;
 		if (typeof to === "number") {
@@ -484,22 +488,28 @@ function createRouter(init) {
 		});
 	}
 	function revalidate() {
+		if (pendingDiscoveryCancellation) return pendingDiscoveryCancellation.then(revalidate);
 		if (!pendingRevalidationDfd) pendingRevalidationDfd = createDeferred();
 		interruptActiveLoads();
 		updateState({ revalidation: "loading" });
 		let promise = pendingRevalidationDfd.promise;
 		if (state.navigation.state === "submitting") return promise;
 		if (state.navigation.state === "idle") {
-			startNavigation(state.historyAction, state.location, { startUninterruptedRevalidation: true });
+			startNavigation(state.historyAction, state.location, {
+				startUninterruptedRevalidation: true,
+				dataStrategyInitiator: "revalidation"
+			});
 			return promise;
 		}
 		startNavigation(pendingAction || state.historyAction, state.navigation.location, {
 			overrideNavigation: state.navigation,
+			dataStrategyInitiator: "revalidation",
 			enableViewTransition: pendingViewTransitionEnabled === true
 		});
 		return promise;
 	}
 	async function startNavigation(historyAction, location, opts) {
+		if (pendingDiscoveryCancellation) await pendingDiscoveryCancellation;
 		pendingNavigationController && pendingNavigationController.abort();
 		pendingNavigationController = null;
 		pendingAction = historyAction;
@@ -535,6 +545,7 @@ function createRouter(init) {
 		} : void 0;
 		pendingNavigationController = new AbortController();
 		let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
+		let dataStrategyInitiator = opts?.initialHydration ? "initialization" : opts?.dataStrategyInitiator ?? "navigation";
 		let scopedContext = init.getContext ? await init.getContext() : new RouterContextProvider();
 		let pendingActionResult;
 		if (opts && opts.pendingError) pendingActionResult = [findNearestBoundary(matches).route.id, {
@@ -542,7 +553,7 @@ function createRouter(init) {
 			error: opts.pendingError
 		}];
 		else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
-			let actionResult = await handleAction(request, location, opts.submission, matches, historyAction, scopedContext, fogOfWar.active, opts && opts.initialHydration === true, {
+			let actionResult = await handleAction(request, dataStrategyInitiator, location, opts.submission, matches, historyAction, scopedContext, fogOfWar.active, opts && opts.initialHydration === true, {
 				replace: opts.replace,
 				flushSync
 			});
@@ -566,7 +577,7 @@ function createRouter(init) {
 			fogOfWar.active = false;
 			request = createClientSideRequest(init.history, request.url, request.signal);
 		}
-		let { shortCircuited, matches: updatedMatches, loaderData, errors, workingFetchers } = await handleLoaders(request, location, matches, historyAction, scopedContext, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult, opts && opts.callSiteDefaultShouldRevalidate);
+		let { shortCircuited, matches: updatedMatches, loaderData, errors, workingFetchers } = await handleLoaders(request, dataStrategyInitiator, location, matches, historyAction, scopedContext, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult, opts && opts.callSiteDefaultShouldRevalidate);
 		if (shortCircuited) return;
 		pendingNavigationController = null;
 		completeNavigation(location, {
@@ -577,13 +588,57 @@ function createRouter(init) {
 			...workingFetchers ? { fetchers: workingFetchers } : {}
 		});
 	}
-	async function handleAction(request, location, submission, matches, historyAction, scopedContext, isFogOfWar, initialHydration, opts = {}) {
-		interruptActiveLoads();
+	function cancelDiscoveryNavigation() {
+		let cancellation = createDeferred();
+		pendingDiscoveryCancellation = cancellation.promise;
+		let delta = pendingPopstateDelta;
+		let popstateNavigationDfd = pendingPopstateNavigationDfd;
+		pendingPopstateNavigationDfd = null;
+		pendingNavigationController?.abort();
+		pendingNavigationController = null;
+		resetPendingNavigation();
+		pendingRevalidationDfd?.resolve();
+		pendingRevalidationDfd = null;
+		let blockers = new Map(state.blockers);
+		blockers.forEach((blocker, key) => {
+			if (blocker.state === "proceeding") blockers.set(key, IDLE_BLOCKER);
+		});
+		let fetchers = new Map(state.fetchers);
+		let didUpdateFetchers = markFetchRedirectsDone(fetchers);
+		fetchers.forEach((fetcher, key) => {
+			if (fetcher.state === "loading" && !fetchControllers.has(key)) {
+				fetchers.set(key, getDoneFetcher(fetcher.data));
+				didUpdateFetchers = true;
+			}
+		});
+		cancelledFetcherLoads.clear();
+		updateState({
+			navigation: IDLE_NAVIGATION,
+			revalidation: "idle",
+			blockers,
+			...didUpdateFetchers ? { fetchers } : {}
+		});
+		function finishCancellation() {
+			pendingDiscoveryCancellation = void 0;
+			popstateNavigationDfd?.resolve();
+			cancellation.resolve();
+		}
+		if (delta) {
+			unblockBlockerHistoryUpdate = finishCancellation;
+			init.history.go(-delta);
+		} else finishCancellation();
+		return cancellation.promise;
+	}
+	async function handleAction(request, dataStrategyInitiator, location, submission, matches, historyAction, scopedContext, isFogOfWar, initialHydration, opts = {}) {
+		if (!future.unstable_customRouteDiscovery) interruptActiveLoads();
 		updateState({ navigation: getSubmittingNavigation(location, matches, historyAction, submission) }, { flushSync: opts.flushSync === true });
 		if (isFogOfWar) {
 			let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
-			if (discoverResult.type === "aborted") return { shortCircuited: true };
-			else if (discoverResult.type === "error") {
+			if (future.unstable_customRouteDiscovery && request.signal.aborted || discoverResult.type === "aborted") return { shortCircuited: true };
+			else if (discoverResult.type === "cancelled") {
+				await cancelDiscoveryNavigation();
+				return { shortCircuited: true };
+			} else if (discoverResult.type === "error") {
 				if (discoverResult.partialMatches.length === 0) {
 					let { matches, route } = getShortCircuitMatches(dataRoutes.activeRoutes);
 					return {
@@ -613,6 +668,7 @@ function createRouter(init) {
 				};
 			} else matches = discoverResult.matches;
 		}
+		if (future.unstable_customRouteDiscovery) interruptActiveLoads();
 		let result;
 		let actionMatch = getTargetMatch(matches, location);
 		if (!actionMatch.route.action && !actionMatch.route.lazy) result = {
@@ -624,7 +680,7 @@ function createRouter(init) {
 			})
 		};
 		else {
-			let results = await callDataStrategy(request, location, getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, location, matches, actionMatch, initialHydration ? [] : hydrationRouteProperties, scopedContext), scopedContext, null);
+			let results = await callDataStrategy(request, location, getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, location, matches, actionMatch, initialHydration ? [] : hydrationRouteProperties, scopedContext), scopedContext, null, dataStrategyInitiator, historyAction);
 			result = results[actionMatch.route.id];
 			if (!result) {
 				for (let match of matches) if (results[match.route.id]) {
@@ -638,7 +694,7 @@ function createRouter(init) {
 			let replace;
 			if (opts && opts.replace != null) replace = opts.replace;
 			else replace = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename, init.history) === state.location.pathname + state.location.search;
-			await startRedirectNavigation(request, result, true, {
+			await startRedirectNavigation(request, result, true, dataStrategyInitiator, {
 				submission,
 				replace
 			});
@@ -661,7 +717,7 @@ function createRouter(init) {
 			pendingActionResult: [actionMatch.route.id, result]
 		};
 	}
-	async function handleLoaders(request, location, matches, historyAction, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult, callSiteDefaultShouldRevalidate) {
+	async function handleLoaders(request, dataStrategyInitiator, location, matches, historyAction, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult, callSiteDefaultShouldRevalidate) {
 		let loadingNavigation = overrideNavigation || getLoadingNavigation(location, matches, historyAction, submission);
 		let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
 		let shouldUpdateNavigationState = !isUninterruptedRevalidation && !initialHydration;
@@ -674,8 +730,11 @@ function createRouter(init) {
 				}, { flushSync });
 			}
 			let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
-			if (discoverResult.type === "aborted") return { shortCircuited: true };
-			else if (discoverResult.type === "error") {
+			if (future.unstable_customRouteDiscovery && request.signal.aborted || discoverResult.type === "aborted") return { shortCircuited: true };
+			else if (discoverResult.type === "cancelled") {
+				await cancelDiscoveryNavigation();
+				return { shortCircuited: true };
+			} else if (discoverResult.type === "error") {
 				if (discoverResult.partialMatches.length === 0) {
 					let { matches, route } = getShortCircuitMatches(dataRoutes.activeRoutes);
 					return {
@@ -697,7 +756,10 @@ function createRouter(init) {
 					loaderData: {},
 					errors: { [route.id]: error }
 				};
-			} else matches = discoverResult.matches;
+			} else {
+				matches = discoverResult.matches;
+				if (initialHydration && !request.signal.aborted) updateState({ matches });
+			}
 		}
 		let { dsMatches, revalidatingFetchers } = getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest, init.history, state, matches, activeSubmission, location, initialHydration ? [] : hydrationRouteProperties, initialHydration === true, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, dataRouteMatcher, pendingActionResult, callSiteDefaultShouldRevalidate);
 		pendingNavigationLoadId = ++incrementingLoadId;
@@ -729,27 +791,31 @@ function createRouter(init) {
 		});
 		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((f) => abortFetcher(f.key));
 		if (pendingNavigationController) pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
-		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, request, location, scopedContext);
+		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, request, location, scopedContext, dataStrategyInitiator, historyAction);
 		if (request.signal.aborted) return { shortCircuited: true };
 		if (pendingNavigationController) pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
 		revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));
 		let redirect = findRedirect(loaderResults);
 		if (redirect) {
-			await startRedirectNavigation(request, redirect.result, true, { replace });
+			await startRedirectNavigation(request, redirect.result, true, dataStrategyInitiator, { replace });
 			return { shortCircuited: true };
 		}
 		redirect = findRedirect(fetcherResults);
 		if (redirect) {
 			fetchRedirectIds.add(redirect.key);
-			await startRedirectNavigation(request, redirect.result, true, { replace });
+			await startRedirectNavigation(request, redirect.result, true, dataStrategyInitiator, { replace });
 			return { shortCircuited: true };
 		}
 		let workingFetchers = new Map(state.fetchers);
 		let { loaderData, errors } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, workingFetchers);
-		if (initialHydration && state.errors) errors = {
-			...state.errors,
-			...errors
-		};
+		if (initialHydration && state.errors) {
+			let newClientErrors = errors ?? null;
+			errors = {
+				...state.errors,
+				...errors
+			};
+			clientErrors.set(errors, newClientErrors);
+		}
 		let didUpdateFetcherRedirects = markFetchRedirectsDone(workingFetchers);
 		let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId, workingFetchers);
 		let shouldUpdateFetchers = didUpdateFetcherRedirects || didAbortFetchLoads || revalidatingFetchers.length > 0;
@@ -775,6 +841,7 @@ function createRouter(init) {
 		return workingFetchers;
 	}
 	async function fetch(key, routeId, href, opts) {
+		if (pendingDiscoveryCancellation) await pendingDiscoveryCancellation;
 		abortFetcher(key);
 		let flushSync = (opts && opts.flushSync) === true;
 		let instrumentationResultMetaReceiver = consumeInstrumentationClientResultMetaReceiver(router);
@@ -807,15 +874,22 @@ function createRouter(init) {
 		await handleFetcherLoader(key, loadMatch, matches, scopedContext, flushSync, preventScrollReset, submission);
 	}
 	async function handleFetcherAction(key, routeId, path, requestMatches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission, callSiteDefaultShouldRevalidate) {
-		interruptActiveLoads();
+		if (!future.unstable_customRouteDiscovery) interruptActiveLoads();
 		fetchLoadMatches.delete(key);
-		updateFetcherState(key, getSubmittingFetcher(submission, state.fetchers.get(key)), { flushSync });
+		let existingFetcher = state.fetchers.get(key);
+		updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), { flushSync });
 		let abortController = new AbortController();
+		if (future.unstable_customRouteDiscovery) fetchControllers.set(key, abortController);
 		let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
 		if (isFogOfWar) {
 			let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
-			if (discoverResult.type === "aborted") return;
-			else if (discoverResult.type === "error") {
+			if (future.unstable_customRouteDiscovery && fetchRequest.signal.aborted || discoverResult.type === "aborted") return;
+			else if (discoverResult.type === "cancelled") {
+				fetchControllers.delete(key);
+				fetchLoadMatches.delete(key);
+				updateFetcherState(key, getDoneFetcher(existingFetcher?.data), { flushSync });
+				return;
+			} else if (discoverResult.type === "error") {
 				setFetcherError(key, routeId, discoverResult.error, { flushSync });
 				return;
 			} else if (!discoverResult.matches) {
@@ -832,10 +906,11 @@ function createRouter(init) {
 			}), { flushSync });
 			return;
 		}
+		if (future.unstable_customRouteDiscovery) interruptActiveLoads();
 		fetchControllers.set(key, abortController);
 		let originatingLoadId = incrementingLoadId;
 		let fetchMatches = getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, path, requestMatches, match, hydrationRouteProperties, scopedContext);
-		let actionResults = await callDataStrategy(fetchRequest, path, fetchMatches, scopedContext, key);
+		let actionResults = await callDataStrategy(fetchRequest, path, fetchMatches, scopedContext, key, "fetcher");
 		let actionResult = actionResults[match.route.id];
 		if (!actionResult) {
 			for (let match of fetchMatches) if (actionResults[match.route.id]) {
@@ -861,7 +936,7 @@ function createRouter(init) {
 				} else {
 					fetchRedirectIds.add(key);
 					updateFetcherState(key, getLoadingFetcher(submission));
-					return startRedirectNavigation(fetchRequest, actionResult, false, {
+					return startRedirectNavigation(fetchRequest, actionResult, false, "fetcher", {
 						fetcherSubmission: submission,
 						preventScrollReset
 					});
@@ -893,7 +968,7 @@ function createRouter(init) {
 		updateState({ fetchers: workingFetchers });
 		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));
 		abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
-		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, revalidationRequest, nextLocation, scopedContext);
+		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, revalidationRequest, nextLocation, scopedContext, "fetcher");
 		if (abortController.signal.aborted) {
 			if (fetchReloadIds.get(key) === loadId) fetchReloadIds.delete(key);
 			return;
@@ -915,13 +990,13 @@ function createRouter(init) {
 		let redirect = findRedirect(loaderResults);
 		if (redirect) {
 			state = getRedirectStateWithDoneFetcher(state);
-			return startRedirectNavigation(revalidationRequest, redirect.result, false, { preventScrollReset });
+			return startRedirectNavigation(revalidationRequest, redirect.result, false, "fetcher", { preventScrollReset });
 		}
 		redirect = findRedirect(fetcherResults);
 		if (redirect) {
 			fetchRedirectIds.add(redirect.key);
 			state = getRedirectStateWithDoneFetcher(state);
-			return startRedirectNavigation(revalidationRequest, redirect.result, false, { preventScrollReset });
+			return startRedirectNavigation(revalidationRequest, redirect.result, false, "fetcher", { preventScrollReset });
 		}
 		let finalFetchers = new Map(state.fetchers);
 		if (fetcherIsMounted) finalFetchers.set(key, getDoneFetcher(actionResult.data));
@@ -950,11 +1025,17 @@ function createRouter(init) {
 		let existingFetcher = state.fetchers.get(key);
 		updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : void 0), { flushSync });
 		let abortController = new AbortController();
+		if (future.unstable_customRouteDiscovery) fetchControllers.set(key, abortController);
 		let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
 		if (loadMatch.isDiscovering) {
 			let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
-			if (discoverResult.type === "aborted") return;
-			else if (discoverResult.type === "error") {
+			if (future.unstable_customRouteDiscovery && fetchRequest.signal.aborted || discoverResult.type === "aborted") return;
+			else if (discoverResult.type === "cancelled") {
+				fetchControllers.delete(key);
+				fetchLoadMatches.delete(key);
+				updateFetcherState(key, getDoneFetcher(existingFetcher?.data), { flushSync });
+				return;
+			} else if (discoverResult.type === "error") {
 				setFetcherError(key, routeId, discoverResult.error, { flushSync });
 				return;
 			} else if (!discoverResult.matches) {
@@ -968,7 +1049,7 @@ function createRouter(init) {
 		let match = getTargetMatch(matches, path);
 		fetchControllers.set(key, abortController);
 		let originatingLoadId = incrementingLoadId;
-		let results = await callDataStrategy(fetchRequest, path, getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, path, matches, match, hydrationRouteProperties, scopedContext), scopedContext, key);
+		let results = await callDataStrategy(fetchRequest, path, getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, path, matches, match, hydrationRouteProperties, scopedContext), scopedContext, key, "fetcher");
 		let result = results[match.route.id];
 		if (!result) {
 			for (let match of matches) if (results[match.route.id]) {
@@ -987,7 +1068,7 @@ function createRouter(init) {
 			return;
 		} else {
 			fetchRedirectIds.add(key);
-			await startRedirectNavigation(fetchRequest, result, false, { preventScrollReset });
+			await startRedirectNavigation(fetchRequest, result, false, "fetcher", { preventScrollReset });
 			return;
 		}
 		if (isErrorResult(result)) {
@@ -1015,7 +1096,7 @@ function createRouter(init) {
 	* actually touch history until we've processed redirects, so we just use
 	* the history action from the original navigation (PUSH or REPLACE).
 	*/
-	async function startRedirectNavigation(request, redirect, isNavigation, { submission, fetcherSubmission, preventScrollReset, replace } = {}) {
+	async function startRedirectNavigation(request, redirect, isNavigation, dataStrategyInitiator, { submission, fetcherSubmission, preventScrollReset, replace } = {}) {
 		if (!isNavigation) {
 			pendingPopstateNavigationDfd?.resolve();
 			pendingPopstateNavigationDfd = null;
@@ -1052,20 +1133,22 @@ function createRouter(init) {
 				formAction: location
 			},
 			preventScrollReset: preventScrollReset || pendingPreventScrollReset,
-			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
+			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0,
+			dataStrategyInitiator
 		});
 		else await startNavigation(redirectNavigationType, redirectLocation, {
 			overrideNavigation: getLoadingNavigation(redirectLocation, [], redirectNavigationType, submission),
 			fetcherSubmission,
 			preventScrollReset: preventScrollReset || pendingPreventScrollReset,
-			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
+			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0,
+			dataStrategyInitiator
 		});
 	}
-	async function callDataStrategy(request, path, matches, scopedContext, fetcherKey) {
+	async function callDataStrategy(request, path, matches, scopedContext, fetcherKey, initiator, navigationType = null) {
 		let results;
 		let dataResults = {};
 		try {
-			results = await callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, false);
+			results = await callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, initiator, scopedContext, false, navigationType);
 		} catch (e) {
 			matches.filter((m) => m.shouldLoad).forEach((m) => {
 				dataResults[m.route.id] = {
@@ -1092,11 +1175,11 @@ function createRouter(init) {
 		} else dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
 		return dataResults;
 	}
-	async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, request, location, scopedContext) {
-		let loaderResultsPromise = callDataStrategy(request, location, matches, scopedContext, null);
+	async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, request, location, scopedContext, initiator, navigationType = null) {
+		let loaderResultsPromise = callDataStrategy(request, location, matches, scopedContext, null, initiator, navigationType);
 		let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async (f) => {
 			if (f.matches && f.match && f.request && f.controller) {
-				let result = (await callDataStrategy(f.request, f.path, f.matches, scopedContext, f.key))[f.match.route.id];
+				let result = (await callDataStrategy(f.request, f.path, f.matches, scopedContext, f.key, initiator, navigationType))[f.match.route.id];
 				return { [f.key]: result };
 			} else return Promise.resolve({ [f.key]: {
 				type: "error",
@@ -1110,7 +1193,8 @@ function createRouter(init) {
 	}
 	function interruptActiveLoads() {
 		isRevalidationRequired = true;
-		fetchLoadMatches.forEach((_, key) => {
+		fetchLoadMatches.forEach((loadMatch, key) => {
+			if (future.unstable_customRouteDiscovery && loadMatch.isDiscovering) return;
 			if (fetchControllers.has(key)) cancelledFetcherLoads.add(key);
 			abortFetcher(key);
 		});
@@ -1136,6 +1220,8 @@ function createRouter(init) {
 	}
 	function resetFetcher(key, opts) {
 		abortFetcher(key, opts?.reason);
+		fetchLoadMatches.delete(key);
+		cancelledFetcherLoads.delete(key);
 		updateFetcherState(key, getDoneFetcher(null));
 	}
 	function deleteFetcher(fetchers, key) {
@@ -1308,6 +1394,10 @@ function createRouter(init) {
 					}
 				});
 			} catch (e) {
+				if (future.unstable_customRouteDiscovery) {
+					if (signal.aborted) return { type: "aborted" };
+					if (e instanceof DiscoveryCancelledError) return { type: "cancelled" };
+				}
 				return {
 					type: "error",
 					error: e,
@@ -1768,7 +1858,7 @@ function createStaticHandler(routes, opts) {
 		};
 	}
 	async function callDataStrategy(request, location, matches, isRouteRequest, requestContext, dataStrategy) {
-		let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, request, location, matches, null, requestContext, true);
+		let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, request, location, matches, null, "static", requestContext, true);
 		let dataResults = {};
 		await Promise.all(matches.map(async (match) => {
 			if (!(match.route.id in results)) return;
@@ -2409,7 +2499,7 @@ function getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, p
 		return getDataStrategyMatch(mapRouteProperties, manifest, request, path, getRoutePattern(matches), match, lazyRoutePropertiesToSkip, scopedContext, true, shouldRevalidateArgs);
 	});
 }
-async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, isStaticHandler) {
+async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, initiator, scopedContext, isStaticHandler, navigationType = null) {
 	if (matches.some((m) => m._lazyPromises?.middleware)) await Promise.all(matches.map((m) => m._lazyPromises?.middleware));
 	let dataStrategyArgs = {
 		request,
@@ -2417,7 +2507,9 @@ async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fe
 		pattern: getRoutePattern(matches),
 		params: matches[0].params,
 		context: scopedContext,
-		matches
+		matches,
+		unstable_initiator: initiator,
+		unstable_navigationType: initiator === "navigation" ? navigationType : null
 	};
 	let runClientMiddleware = isStaticHandler ? () => {
 		throw new Error("You cannot call `runClientMiddleware()` from a static handler `dataStrategy`. Middleware is run outside of `dataStrategy` during SSR in order to bubble up the Response.  You can enable middleware via the `respond` API in `query`/`queryRoute`");
@@ -3014,4 +3106,4 @@ function createDeferred() {
 	};
 }
 //#endregion
-export { IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, createDataRouteMatcher, createRouter, createStaticHandler, getStaticContextFromError, hasInvalidProtocol, isDataWithResponseInit, isMutationMethod, isRedirectResponse, isRedirectStatusCode, isResponse };
+export { IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, clientErrors, createDataRouteMatcher, createRouter, createStaticHandler, getStaticContextFromError, hasInvalidProtocol, isDataWithResponseInit, isMutationMethod, isRedirectResponse, isRedirectStatusCode, isResponse };

package/dist/production/lib/router/url.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.0
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/router/utils.d.ts

@@ -1,5 +1,5 @@
 
-import { Location, Path, To } from "./history.js";
+import { Action, Location, Path, To } from "./history.js";
 import * as React$1 from "react";
 
 //#region lib/router/utils.d.ts
@@ -389,6 +389,11 @@ interface DataStrategyMatch extends RouteMatch<string, DataRouteObject> {
    */
   resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
 }
+/**
+ * The operation that initiated a data strategy execution. Static handler
+ * executions use `"static"`.
+ */
+type DataStrategyInitiator = "initialization" | "navigation" | "fetcher" | "revalidation" | "static";
 interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
   /**
    * Matches for this route extended with Data strategy APIs
@@ -396,8 +401,23 @@ interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctio
   matches: DataStrategyMatch[];
   runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
   /**
-   * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
-   * for navigational executions
+   * The operation that initiated this data strategy execution
+   *
+   * This field is experimental and subject to breaking changes.
+   */
+  unstable_initiator: DataStrategyInitiator;
+  /**
+   * The history action (`"PUSH"`, `"REPLACE"`, or `"POP"`) for a navigation-
+   * initiated execution, including fetchers reloaded by that navigation.
+   * `null` for initialization, fetcher, revalidation, and static executions.
+   *
+   * This field is experimental and subject to breaking changes.
+   */
+  unstable_navigationType: Action | null;
+  /**
+   * The key of the fetcher targeted by this data strategy execution, otherwise
+   * `null`. Fetchers reloaded during a navigation or revalidation retain that
+   * `unstable_initiator` while providing their key here.
    */
   fetcherKey: string | null;
 }
@@ -962,4 +982,4 @@ declare class ErrorResponseImpl implements ErrorResponse {
  */
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 //#endregion
-export { ActionFunction, ActionFunctionArgs, BaseRouteObject, DataRouteMatch, DataRouteObject, DataStrategyFunction, DataStrategyFunctionArgs, DataStrategyMatch, DataStrategyResult, DataWithResponseInit, ErrorResponse, ErrorResponseImpl, FormEncType, FormMethod, HTMLFormMethod, IndexRouteObject, LazyRouteFunction, LoaderFunction, LoaderFunctionArgs, MapRoutePropertiesFunction, MaybePromise, MiddlewareFunction, MiddlewareNextFunction, NonIndexRouteObject, ParamParseKey, Params, PatchRoutesOnNavigationFunction, PatchRoutesOnNavigationFunctionArgs, PathMatch, PathParam, PathPattern, RedirectFunction, RouteBranch, RouteData, RouteManifest, RouteMatch, RouteObject, RouterContext, RouterContextProvider, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, Submission, TrackedPromise, UIMatch, createContext, data, defaultMapRouteProperties, generatePath, isRouteErrorResponse, matchPath, matchRoutes, redirect, redirectDocument, replace, resolvePath };
+export { ActionFunction, ActionFunctionArgs, BaseRouteObject, DataRouteMatch, DataRouteObject, DataStrategyFunction, DataStrategyFunctionArgs, DataStrategyInitiator, DataStrategyMatch, DataStrategyResult, DataWithResponseInit, ErrorResponse, ErrorResponseImpl, FormEncType, FormMethod, HTMLFormMethod, IndexRouteObject, LazyRouteFunction, LoaderFunction, LoaderFunctionArgs, MapRoutePropertiesFunction, MaybePromise, MiddlewareFunction, MiddlewareNextFunction, NonIndexRouteObject, ParamParseKey, Params, PatchRoutesOnNavigationFunction, PatchRoutesOnNavigationFunctionArgs, PathMatch, PathParam, PathPattern, RedirectFunction, RouteBranch, RouteData, RouteManifest, RouteMatch, RouteObject, RouterContext, RouterContextProvider, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, Submission, TrackedPromise, UIMatch, createContext, data, defaultMapRouteProperties, generatePath, isRouteErrorResponse, matchPath, matchRoutes, redirect, redirectDocument, replace, resolvePath };

package/dist/production/lib/router/utils.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -129,6 +129,7 @@ var RouterContextProvider = class {
 		this.#map.set(context, value);
 	}
 };
+var DiscoveryCancelledError = class extends Error {};
 const unsupportedLazyRouteObjectKeys = new Set([
 	"lazy",
 	"caseSensitive",
@@ -514,7 +515,7 @@ function compilePath(path, caseSensitive = false, end = true) {
 			return "(?:/([^\\/]*))?";
 		}
 		return "/([^\\/]+)";
-	}).replace(/\/([\w-]+)\?(?=\/|$|\()/g, "(?:/$1)?");
+	}).replace(/\/((?:[^/?()[\]*^\\]|\\.)+)\?(?=\/|$|\()/g, "(?:/$1)?");
 	if (path.endsWith("*")) {
 		params.push({ paramName: "*" });
 		regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
@@ -875,4 +876,4 @@ function parseToInfo(_to, basename) {
 	};
 }
 //#endregion
-export { ErrorResponseImpl, RouterContextProvider, SUPPORTED_ERROR_TYPES, compilePath, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createContext, createDataFunctionUrl, data, decodePath, defaultMapRouteProperties, encodePathParam, explodeOptionalSegments, flattenAndRankRoutes, generatePath, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isBrowser, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, joinPaths, matchPath, matchRoutes, matchRoutesImpl, normalizePathname, parseToInfo, prependBasename, redirect, redirectDocument, removeDoubleSlashes, removeTrailingSlash, replace, resolvePath, resolveTo, stripBasename };
+export { DiscoveryCancelledError, ErrorResponseImpl, RouterContextProvider, SUPPORTED_ERROR_TYPES, compilePath, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createContext, createDataFunctionUrl, data, decodePath, defaultMapRouteProperties, encodePathParam, explodeOptionalSegments, flattenAndRankRoutes, generatePath, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isBrowser, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, joinPaths, matchPath, matchRoutes, matchRoutesImpl, normalizePathname, parseToInfo, prependBasename, redirect, redirectDocument, removeDoubleSlashes, removeTrailingSlash, replace, resolvePath, resolveTo, stripBasename };