react-native-screen-transitions 4.0.0-alpha.0 → 4.0.0-alpha.10

package/src/providers/screen/styles/slot.provider.tsx

@@ -1,4 +1,4 @@
-import { type ReactNode, useContext, useLayoutEffect, useMemo } from "react";
+import { type ReactNode, useMemo } from "react";
 import { StyleSheet } from "react-native";
 import Animated, { type SharedValue } from "react-native-reanimated";
 import type {
@@ -8,88 +8,79 @@ import type {
 import type { NormalizedTransitionInterpolatedStyle } from "../../../types/animation.types";
 import createProvider from "../../../utils/create-provider";
 import { useDescriptorsStore } from "../descriptors";
-import { FloatingOverlayLayer } from "./components/floating-overlay-layer";
-import type { LocalStyleLayers } from "./helpers/resolve-slot-styles";
+import { useCurrentScreenRelationships } from "../use-current-screen-relationships";
 import { useInterpolatedStylesMap } from "./hooks/use-interpolated-style-maps";
 import { useMaybeBlockVisibility } from "./hooks/use-maybe-block-visibility";
 import { useResolvedStylesMap } from "./hooks/use-resolved-slot-style-map";
-import {
-	registerScreenSlots,
-	unregisterScreenSlots,
-} from "./stores/slot-references.store";
 
-type Props = {
-	children: ReactNode;
-	isFloatingOverlay?: boolean;
-};
+type Props = { children: ReactNode };
 
 export type ScreenSlotName =
+	| "overlay"
 	| "content"
-	| "backdrop"
 	| "surface"
+	| "backdrop"
 	| typeof NAVIGATION_MASK_CONTAINER_STYLE_ID
 	| typeof NAVIGATION_MASK_ELEMENT_STYLE_ID;
 
 export type ScreenSlotContextValue = {
-	localStylesMaps: SharedValue<LocalStyleLayers>;
-	nextInterpolatorReady: SharedValue<number>;
+	interpolatorReady: SharedValue<number>;
 	slotsMap: SharedValue<NormalizedTransitionInterpolatedStyle>;
 	visibilityBlocked: SharedValue<boolean>;
 };
 
+const createScreenSlotProvider = createProvider("ScreenSlot", {
+	global: true,
+})<Props, ScreenSlotContextValue>;
+
 export const {
 	ScreenSlotProvider,
-	ScreenSlotContext,
-	useScreenSlotContext: useScreenSlots,
-} = createProvider("ScreenSlot", {
-	guarded: true,
-})<Props, ScreenSlotContextValue>(({ children, isFloatingOverlay }) => {
-	const parentContext = useContext(ScreenSlotContext);
-	const currentScreenKey = useDescriptorsStore(
-		(s) => s.derivations.currentScreenKey,
-	);
-
-	const { localStylesMaps, nextInterpolatorReady } = useInterpolatedStylesMap();
-
-	const slotsMap = useResolvedStylesMap({
-		localStylesMaps,
-		ancestorStylesMap: parentContext?.slotsMap,
-	});
-	const { animatedStyle, animatedProps, shouldBlockVisibility } =
-		useMaybeBlockVisibility(isFloatingOverlay);
-	const value = useMemo(
-		() => ({
+	useOptionalScreenSlotStore,
+	useScreenSlotStore,
+}: ReturnType<typeof createScreenSlotProvider> = createScreenSlotProvider(
+	({ children }) => {
+		const currentScreenKey = useDescriptorsStore(
+			(store) => store.derivations.currentScreenKey,
+		);
+		const { parentScreenKey } = useCurrentScreenRelationships();
+		const ancestorStylesMap = useOptionalScreenSlotStore(
+			parentScreenKey,
+			(store) => store.slotsMap,
+		);
+		const ancestorVisibilityBlocked = useOptionalScreenSlotStore(
+			parentScreenKey,
+			(store) => store.visibilityBlocked,
+		);
+		const { animatedStyle, animatedProps, visibilityBlocked } =
+			useMaybeBlockVisibility({
+				ancestorVisibilityBlocked: ancestorVisibilityBlocked ?? null,
+			});
+		const { interpolatorReady, localStylesMaps } = useInterpolatedStylesMap({
+			enabled: true,
+			visibilityBlocked,
+		});
+		const slotsMap = useResolvedStylesMap({
 			localStylesMaps,
-			nextInterpolatorReady,
-			slotsMap,
-			visibilityBlocked: shouldBlockVisibility,
-		}),
-		[localStylesMaps, nextInterpolatorReady, shouldBlockVisibility, slotsMap],
-	);
-
-	useLayoutEffect(() => {
-		registerScreenSlots(currentScreenKey, value);
-
-		return () => {
-			unregisterScreenSlots(currentScreenKey, value);
-		};
-	}, [currentScreenKey, value]);
-
-	return {
-		value,
-		children: (
-			<FloatingOverlayLayer enabled={isFloatingOverlay}>
+			ancestorStylesMap: ancestorStylesMap ?? undefined,
+		});
+		const value = useMemo(
+			() => ({ interpolatorReady, slotsMap, visibilityBlocked }),
+			[interpolatorReady, slotsMap, visibilityBlocked],
+		);
+		const content = useMemo(
+			() => (
 				<Animated.View
 					style={[styles.container, animatedStyle]}
 					animatedProps={animatedProps}
 				>
 					{children}
 				</Animated.View>
-			</FloatingOverlayLayer>
-		),
-	};
-});
+			),
+			[children, animatedStyle, animatedProps],
+		);
+
+		return { key: currentScreenKey, value, children: content };
+	},
+);
 
-const styles = StyleSheet.create({
-	container: { flex: 1 },
-});
+const styles = StyleSheet.create({ container: { flex: 1 } });

package/src/providers/screen/use-current-screen-relationships.ts

@@ -0,0 +1,10 @@
+import { useScreenRelationships } from "../../factories/screen-topology";
+import { useDescriptorsStore } from "./descriptors";
+
+export const useCurrentScreenRelationships = () => {
+	const screenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
+
+	return useScreenRelationships(screenKey);
+};

package/src/providers/stack/blank-stack-state/blank-stack-controller.ts

@@ -1,24 +1,15 @@
 import type { BlankStackProviderProps } from "../../../types/providers/blank-stack-provider.types";
-import type {
-	BaseStackDescriptor,
-	BaseStackNavigation,
-	BaseStackRoute,
-} from "../../../types/stack.types";
+import type { BaseStackRoute } from "../../../types/stack.types";
+import { dispatchCloseAction } from "../../../utils/navigation/close-action-replay";
 import { buildBlankStackState } from "./helpers/build-blank-stack-state";
 import { deriveBlankStackState } from "./helpers/derive-blank-stack-state";
 import type {
 	BlankStackControllerSnapshot,
 	BlankStackController as BlankStackControllerType,
-	BlankStackDescriptorSources,
 } from "./helpers/types";
 
 export type { BlankStackController } from "./helpers/types";
 
-const createPopAction = () => ({
-	type: "POP",
-	payload: { count: 1 },
-});
-
 /**
  * Maintains the stack-local route snapshot used while blank stack transitions run.
  *
@@ -26,21 +17,17 @@ const createPopAction = () => ({
  * remove descriptors before our close animation has finished. This controller
  * keeps those closing routes locally until their lifecycle reports completion.
  */
-export const createBlankStackController = <
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
->(
-	initialProps: BlankStackProviderProps<TDescriptor, TNavigation>,
-): BlankStackControllerType<TDescriptor, TNavigation> => {
+export const createBlankStackController = (
+	initialProps: BlankStackProviderProps,
+): BlankStackControllerType => {
 	const closingRouteKeys = new Set<string>();
 	let props = initialProps;
 	let previousRoutesSnapshot = initialProps.state.routes;
-	let snapshot: BlankStackControllerSnapshot<TDescriptor> = {
+	let snapshot: BlankStackControllerSnapshot = {
 		state: buildBlankStackState({
 			props,
 			routes: initialProps.state.routes,
-			descriptors:
-				initialProps.descriptors as BlankStackDescriptorSources<TDescriptor>,
+			descriptors: initialProps.descriptors,
 			closingRouteKeys,
 		}),
 	};
@@ -59,13 +46,11 @@ export const createBlankStackController = <
 		};
 	};
 
-	const getSnapshot = (): BlankStackControllerSnapshot<TDescriptor> => {
+	const getSnapshot = (): BlankStackControllerSnapshot => {
 		return snapshot;
 	};
 
-	const update = (
-		nextProps: BlankStackProviderProps<TDescriptor, TNavigation>,
-	) => {
+	const update = (nextProps: BlankStackProviderProps) => {
 		const lastRoutesSnapshot = previousRoutesSnapshot;
 		props = nextProps;
 
@@ -90,10 +75,14 @@ export const createBlankStackController = <
 		const { state, navigation } = props;
 
 		if (state.routes.some((candidate) => candidate.key === route.key)) {
-			navigation.dispatch({
-				...createPopAction(),
+			const action = {
+				type: "POP",
+				payload: { count: 1 },
 				source: route.key,
 				target: state.key,
+			};
+			dispatchCloseAction(action, (closeAction) => {
+				navigation.dispatch(closeAction);
 			});
 			return;
 		}

package/src/providers/stack/blank-stack-state/helpers/build-blank-stack-state.ts

@@ -1,9 +1,7 @@
+import type { BlankStackDescriptor } from "../../../../types/blank-stack.types";
 import type { BlankStackProviderProps } from "../../../../types/providers/blank-stack-provider.types";
 import type {
-	BaseStackDescriptor,
-	BaseStackNavigation,
 	BaseStackScene,
-	StackDescriptorSource,
 	StackSceneActivity,
 } from "../../../../types/stack.types";
 import { isOverlayVisible } from "../../../../utils/overlay/visibility";
@@ -17,35 +15,29 @@ import {
 	setsAreEqual,
 } from "./state-equality";
 import type {
-	BlankStackDescriptorSources,
 	BlankStackDescriptors,
 	BlankStackRoutes,
 	LocalRoutesState,
 	SceneActivityWindow,
 } from "./types";
 
-type BuildBlankStackStateParams<
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
-> = {
-	props: BlankStackProviderProps<TDescriptor, TNavigation>;
-	routes: BlankStackRoutes<TDescriptor>;
-	descriptors: BlankStackDescriptorSources<TDescriptor>;
+type BuildBlankStackStateParams = {
+	props: BlankStackProviderProps;
+	routes: BlankStackRoutes;
+	descriptors: BlankStackDescriptors;
 	closingRouteKeys: ReadonlySet<string>;
-	previousState?: LocalRoutesState<TDescriptor>;
+	previousState?: LocalRoutesState;
 };
 
-const resolveStableDescriptorSource = <
-	TDescriptor extends BaseStackDescriptor,
->({
+const resolveStableDescriptorSource = ({
 	routeKey,
 	sourceDescriptor,
 	previousState,
 }: {
 	routeKey: string;
-	sourceDescriptor: StackDescriptorSource<TDescriptor>;
-	previousState?: LocalRoutesState<TDescriptor>;
-}): StackDescriptorSource<TDescriptor> => {
+	sourceDescriptor: BlankStackDescriptor;
+	previousState?: LocalRoutesState;
+}): BlankStackDescriptor => {
 	const previousSourceDescriptor = previousState?.sourceDescriptors[routeKey];
 
 	if (
@@ -82,8 +74,8 @@ const getSceneActivity = ({
 	return "inactive";
 };
 
-const getNonClosingSceneIndices = <TDescriptor extends BaseStackDescriptor>(
-	routes: BlankStackRoutes<TDescriptor>,
+const getNonClosingSceneIndices = (
+	routes: BlankStackRoutes,
 	closingRouteKeys: ReadonlySet<string>,
 ) => {
 	const indices: number[] = [];
@@ -98,17 +90,11 @@ const getNonClosingSceneIndices = <TDescriptor extends BaseStackDescriptor>(
 	return indices;
 };
 
-const getSceneActivityWindow = <
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
->({
+const getSceneActivityWindow = ({
 	props,
 	routes,
 	closingRouteKeys,
-}: BuildBlankStackStateParams<
-	TDescriptor,
-	TNavigation
->): SceneActivityWindow => {
+}: BuildBlankStackStateParams): SceneActivityWindow => {
 	const nonClosingIndices = getNonClosingSceneIndices(routes, closingRouteKeys);
 
 	const topNonClosingIndex =
@@ -138,45 +124,26 @@ const getSceneActivityWindow = <
 	};
 };
 
-const withDescriptorActivityState = <TDescriptor extends BaseStackDescriptor>(
-	descriptor: StackDescriptorSource<TDescriptor>,
-	activity: StackSceneActivity,
-): TDescriptor => {
-	if (descriptor.activity === activity) {
-		return descriptor as TDescriptor;
-	}
-
-	return {
-		...descriptor,
-		activity,
-	} as TDescriptor;
-};
-
-const buildBaseScenes = <
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
->({
+const buildBaseScenes = ({
 	routes,
 	descriptors,
 	closingRouteKeys,
 	previousState,
 	activityWindow,
-}: BuildBlankStackStateParams<TDescriptor, TNavigation> & {
+}: BuildBlankStackStateParams & {
 	activityWindow: SceneActivityWindow;
 }) => {
 	const routeKeys: string[] = [];
-	const scenes: BaseStackScene<TDescriptor>[] = [];
+	const scenes: BaseStackScene<BlankStackDescriptor>[] = [];
 	const routeChildStates: Record<string, unknown> = {};
-	const sourceDescriptors = {} as BlankStackDescriptorSources<TDescriptor>;
-	const blankStackDescriptors = {} as BlankStackDescriptors<TDescriptor>;
+	const sourceDescriptors: BlankStackDescriptors = {};
+	const blankStackDescriptors: BlankStackDescriptors = {};
 	let shouldShowFloatOverlay = false;
 
 	for (let sceneIndex = 0; sceneIndex < routes.length; sceneIndex++) {
-		const route = routes[sceneIndex] as TDescriptor["route"];
+		const route = routes[sceneIndex] as BlankStackDescriptor["route"];
 
-		const rawSourceDescriptor = descriptors[route.key] as
-			| StackDescriptorSource<TDescriptor>
-			| undefined;
+		const rawSourceDescriptor = descriptors[route.key];
 
 		if (!rawSourceDescriptor) {
 			throw new Error(`Missing descriptor for route "${route.key}"`);
@@ -207,10 +174,9 @@ const buildBaseScenes = <
 			childStateUnchanged &&
 			previousDescriptor.route === sourceDescriptor.route &&
 			previousDescriptor.navigation === sourceDescriptor.navigation &&
-			previousDescriptor.options === sourceDescriptor.options &&
-			previousDescriptor.activity === activity
+			previousDescriptor.options === sourceDescriptor.options
 				? previousDescriptor
-				: withDescriptorActivityState(sourceDescriptor, activity);
+				: sourceDescriptor;
 
 		routeKeys.push(route.key);
 		routeChildStates[route.key] = routeChildState;
@@ -222,6 +188,7 @@ const buildBaseScenes = <
 		}
 
 		scenes.push({
+			activity,
 			route: descriptor.route,
 			descriptor,
 		});
@@ -237,17 +204,17 @@ const buildBaseScenes = <
 	};
 };
 
-const withSceneRelationships = <TDescriptor extends BaseStackDescriptor>({
+const withSceneRelationships = ({
 	scenes,
 	sourceDescriptors,
 	closingRouteKeys,
 	previousState,
 }: {
-	scenes: BaseStackScene<TDescriptor>[];
-	sourceDescriptors: BlankStackDescriptorSources<TDescriptor>;
+	scenes: BaseStackScene<BlankStackDescriptor>[];
+	sourceDescriptors: BlankStackDescriptors;
 	closingRouteKeys: ReadonlySet<string>;
-	previousState?: LocalRoutesState<TDescriptor>;
-}): BaseStackScene<TDescriptor>[] => {
+	previousState?: LocalRoutesState;
+}): BaseStackScene<BlankStackDescriptor>[] => {
 	const isRouteClosing = (routeKey: string) => closingRouteKeys.has(routeKey);
 
 	const closingRouteOrder = new Map(
@@ -264,8 +231,7 @@ const withSceneRelationships = <TDescriptor extends BaseStackDescriptor>({
 
 	const relationshipScenes = scenes.map((scene) => ({
 		route: scene.route,
-		descriptor: (sourceDescriptors[scene.route.key] ??
-			scene.descriptor) as TDescriptor,
+		descriptor: sourceDescriptors[scene.route.key] ?? scene.descriptor,
 	}));
 
 	const nextScenes = scenes.map((scene, sceneIndex) => {
@@ -289,6 +255,7 @@ const withSceneRelationships = <TDescriptor extends BaseStackDescriptor>({
 
 		if (
 			previousScene &&
+			previousScene.activity === nextScene.activity &&
 			previousScene.route === nextScene.route &&
 			previousScene.descriptor === nextScene.descriptor &&
 			previousScene.previousDescriptor === nextScene.previousDescriptor &&
@@ -308,12 +275,9 @@ const withSceneRelationships = <TDescriptor extends BaseStackDescriptor>({
 	return nextScenes;
 };
 
-export const buildBlankStackState = <
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
->(
-	params: BuildBlankStackStateParams<TDescriptor, TNavigation>,
-): LocalRoutesState<TDescriptor> => {
+export const buildBlankStackState = (
+	params: BuildBlankStackStateParams,
+): LocalRoutesState => {
 	const activityWindow = getSceneActivityWindow(params);
 	const focusedRouteKey =
 		params.props.state.routes[params.props.state.index]?.key;

package/src/providers/stack/blank-stack-state/helpers/derive-blank-stack-state.ts

@@ -1,9 +1,5 @@
 import type { BlankStackProviderProps } from "../../../../types/providers/blank-stack-provider.types";
-import type {
-	BaseStackDescriptor,
-	BaseStackNavigation,
-	RouteWithKey,
-} from "../../../../types/stack.types";
+import type { RouteWithKey } from "../../../../types/stack.types";
 import { buildBlankStackState } from "./build-blank-stack-state";
 import { reconcileBlankStackRoutes } from "./reconcile-blank-stack-routes";
 import {
@@ -16,13 +12,10 @@ import {
 } from "./state-equality";
 import type { BlankStackRoutes, LocalRoutesState } from "./types";
 
-type DeriveBlankStackStateParams<
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
-> = {
-	props: BlankStackProviderProps<TDescriptor, TNavigation>;
-	current: LocalRoutesState<TDescriptor>;
-	previousRoutesSnapshot: BlankStackRoutes<TDescriptor>;
+type DeriveBlankStackStateParams = {
+	props: BlankStackProviderProps;
+	current: LocalRoutesState;
+	previousRoutesSnapshot: BlankStackRoutes;
 	closingRouteKeys: Set<string>;
 };
 
@@ -36,18 +29,12 @@ const routesAreIdentical = <Route extends RouteWithKey>(
 	return a.every((route, index) => route === b[index]);
 };
 
-export const deriveBlankStackState = <
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
->({
+export const deriveBlankStackState = ({
 	props,
 	current,
 	previousRoutesSnapshot,
 	closingRouteKeys,
-}: DeriveBlankStackStateParams<
-	TDescriptor,
-	TNavigation
->): LocalRoutesState<TDescriptor> => {
+}: DeriveBlankStackStateParams): LocalRoutesState => {
 	const nextRoutesSnapshot = props.state.routes;
 	const nextDescriptors = props.descriptors;
 	const nextRouteChildStates = getRouteChildStateMap(nextRoutesSnapshot);

package/src/providers/stack/blank-stack-state/helpers/reconcile-blank-stack-routes.ts

@@ -1,25 +1,21 @@
-import type {
-	BaseStackDescriptor,
-	RouteWithKey,
-} from "../../../../types/stack.types";
+import type { RouteWithKey } from "../../../../types/stack.types";
 import { composeDescriptors } from "./navigation/compose-descriptors";
 import { syncRoutesWithRemoved } from "./navigation/sync-routes-with-removed";
 import { routesHaveSameKeys } from "./state-equality";
 import type {
-	BlankStackDescriptorSources,
+	BlankStackDescriptors,
 	BlankStackRoutes,
 	LocalRoutesState,
 	ReconciledRoutes,
 } from "./types";
 
-type ReconcileBlankStackRoutesParams<TDescriptor extends BaseStackDescriptor> =
-	{
-		current: LocalRoutesState<TDescriptor>;
-		previousRoutesSnapshot: BlankStackRoutes<TDescriptor>;
-		nextRoutesSnapshot: BlankStackRoutes<TDescriptor>;
-		nextDescriptors: BlankStackDescriptorSources<TDescriptor>;
-		closingRouteKeys: Set<string>;
-	};
+type ReconcileBlankStackRoutesParams = {
+	current: LocalRoutesState;
+	previousRoutesSnapshot: BlankStackRoutes;
+	nextRoutesSnapshot: BlankStackRoutes;
+	nextDescriptors: BlankStackDescriptors;
+	closingRouteKeys: Set<string>;
+};
 
 const alignRoutesWithLatest = <
 	Route extends RouteWithKey,
@@ -73,15 +69,13 @@ const alignRoutesWithLatest = <
 	};
 };
 
-const acceptAlreadyClosingRouteRemovals = <
-	TDescriptor extends BaseStackDescriptor,
->({
+const acceptAlreadyClosingRouteRemovals = ({
 	current,
 	previousRoutesSnapshot,
 	nextRoutesSnapshot,
 	nextDescriptors,
 	closingRouteKeys,
-}: ReconcileBlankStackRoutesParams<TDescriptor>): ReconciledRoutes<TDescriptor> | null => {
+}: ReconcileBlankStackRoutesParams): ReconciledRoutes | null => {
 	const nextRouteKeys = new Set(nextRoutesSnapshot.map((route) => route.key));
 	const acceptedRemovedKeys = new Set<string>();
 
@@ -114,13 +108,10 @@ const acceptAlreadyClosingRouteRemovals = <
 		return closingRouteKeys.has(route.key);
 	});
 
-	const routes = [
-		...nextRoutesSnapshot,
-		...remainingClosingRoutes,
-	] as BlankStackRoutes<TDescriptor>;
+	const routes = [...nextRoutesSnapshot, ...remainingClosingRoutes];
 	const descriptors = {
 		...nextDescriptors,
-	} as BlankStackDescriptorSources<TDescriptor>;
+	};
 
 	for (const route of remainingClosingRoutes) {
 		const descriptor = current.sourceDescriptors[route.key];
@@ -135,11 +126,9 @@ const acceptAlreadyClosingRouteRemovals = <
 	};
 };
 
-export const reconcileBlankStackRoutes = <
-	TDescriptor extends BaseStackDescriptor,
->(
-	params: ReconcileBlankStackRoutesParams<TDescriptor>,
-): ReconciledRoutes<TDescriptor> => {
+export const reconcileBlankStackRoutes = (
+	params: ReconcileBlankStackRoutesParams,
+): ReconciledRoutes => {
 	const {
 		current,
 		previousRoutesSnapshot,
@@ -162,9 +151,8 @@ export const reconcileBlankStackRoutes = <
 		);
 
 		return {
-			routes: result.routes as BlankStackRoutes<TDescriptor>,
-			descriptors:
-				result.descriptors as BlankStackDescriptorSources<TDescriptor>,
+			routes: result.routes,
+			descriptors: result.descriptors,
 		};
 	}
 
@@ -186,7 +174,7 @@ export const reconcileBlankStackRoutes = <
 	});
 
 	return {
-		routes: result.routes as BlankStackRoutes<TDescriptor>,
-		descriptors: result.descriptors as BlankStackDescriptorSources<TDescriptor>,
+		routes: result.routes,
+		descriptors: result.descriptors,
 	};
 };

package/src/providers/stack/blank-stack-state/helpers/resolve-presented-index.ts

@@ -0,0 +1,22 @@
+import type { BaseStackRoute } from "../../../../types/stack.types";
+
+export function resolvePresentedIndex(
+	routes: BaseStackRoute[],
+	focusedRouteKey: string | undefined,
+	closingRouteKeys: ReadonlySet<string>,
+): number {
+	const focusedIndex = focusedRouteKey
+		? routes.findIndex((route) => route.key === focusedRouteKey)
+		: routes.length - 1;
+	const resolvedFocusedIndex =
+		focusedIndex >= 0 ? focusedIndex : routes.length - 1;
+
+	for (let index = resolvedFocusedIndex; index >= 0; index -= 1) {
+		const route = routes[index];
+		if (route && !closingRouteKeys.has(route.key)) {
+			return index;
+		}
+	}
+
+	return resolvedFocusedIndex;
+}

package/src/providers/stack/blank-stack-state/helpers/state-equality.ts

@@ -1,9 +1,6 @@
-import type {
-	BaseStackDescriptor,
-	RouteWithKey,
-	StackDescriptorSource,
-} from "../../../../types/stack.types";
-import type { BlankStackDescriptorSources } from "./types";
+import type { BlankStackDescriptor } from "../../../../types/blank-stack.types";
+import type { RouteWithKey } from "../../../../types/stack.types";
+import type { BlankStackDescriptors } from "./types";
 
 export const areDescriptorsEqual = <
 	DescriptorMap extends Record<string, unknown>,
@@ -113,11 +110,9 @@ export const areRecordsShallowEqual = (
 	return aKeys.every((key) => Object.is(a[key], b[key]));
 };
 
-export const areDescriptorSourcesEquivalent = <
-	TDescriptor extends BaseStackDescriptor,
->(
-	previous: StackDescriptorSource<TDescriptor>,
-	next: StackDescriptorSource<TDescriptor>,
+export const areDescriptorSourcesEquivalent = (
+	previous: BlankStackDescriptor,
+	next: BlankStackDescriptor,
 ): boolean => {
 	return (
 		previous.navigation === next.navigation &&
@@ -132,11 +127,9 @@ export const areDescriptorSourcesEquivalent = <
 	);
 };
 
-export const areDescriptorSourceMapsEquivalent = <
-	TDescriptor extends BaseStackDescriptor,
->(
-	previous: BlankStackDescriptorSources<TDescriptor>,
-	next: BlankStackDescriptorSources<TDescriptor>,
+export const areDescriptorSourceMapsEquivalent = (
+	previous: BlankStackDescriptors,
+	next: BlankStackDescriptors,
 ): boolean => {
 	if (previous === next) return true;