react-native-screen-transitions 4.0.0-alpha.7 → 4.0.0-alpha.8

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;
 

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

@@ -1,54 +1,41 @@
+import type { BlankStackDescriptor } from "../../../../types/blank-stack.types";
 import type { BlankStackProviderProps } from "../../../../types/providers/blank-stack-provider.types";
 import type {
-	BaseStackDescriptor,
-	BaseStackNavigation,
 	BaseStackRoute,
 	BaseStackScene,
-	StackDescriptorSource,
 } from "../../../../types/stack.types";
 
-export type BlankStackRoutes<TDescriptor extends BaseStackDescriptor> =
-	TDescriptor["route"][];
+export type BlankStackRoutes = BlankStackDescriptor["route"][];
 
-export type BlankStackDescriptors<TDescriptor extends BaseStackDescriptor> =
-	Record<string, TDescriptor>;
+export type BlankStackDescriptors = Record<string, BlankStackDescriptor>;
 
-export type BlankStackDescriptorSources<
-	TDescriptor extends BaseStackDescriptor,
-> = Record<string, StackDescriptorSource<TDescriptor>>;
-
-export type LocalRoutesState<TDescriptor extends BaseStackDescriptor> = {
-	routes: BlankStackRoutes<TDescriptor>;
-	descriptors: BlankStackDescriptors<TDescriptor>;
-	sourceDescriptors: BlankStackDescriptorSources<TDescriptor>;
+export type LocalRoutesState = {
+	routes: BlankStackRoutes;
+	descriptors: BlankStackDescriptors;
+	sourceDescriptors: BlankStackDescriptors;
 	focusedRouteKey?: string;
 	routeChildStates: Record<string, unknown>;
-	scenes: BaseStackScene<TDescriptor>[];
+	scenes: BaseStackScene<BlankStackDescriptor>[];
 	routeKeys: string[];
 	shouldShowFloatOverlay: boolean;
 	closingRouteKeys: ReadonlySet<string>;
 };
 
-export type BlankStackControllerSnapshot<
-	TDescriptor extends BaseStackDescriptor,
-> = {
-	state: LocalRoutesState<TDescriptor>;
+export type BlankStackControllerSnapshot = {
+	state: LocalRoutesState;
 };
 
-export type BlankStackController<
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
-> = {
+export type BlankStackController = {
 	subscribe: (listener: () => void) => () => void;
-	getSnapshot: () => BlankStackControllerSnapshot<TDescriptor>;
-	update: (props: BlankStackProviderProps<TDescriptor, TNavigation>) => void;
+	getSnapshot: () => BlankStackControllerSnapshot;
+	update: (props: BlankStackProviderProps) => void;
 	handleCloseRoute: (payload: { route: BaseStackRoute }) => void;
 	requestDismiss: (payload: { route: BaseStackRoute }) => boolean;
 };
 
-export type ReconciledRoutes<TDescriptor extends BaseStackDescriptor> = {
-	routes: BlankStackRoutes<TDescriptor>;
-	descriptors: BlankStackDescriptorSources<TDescriptor>;
+export type ReconciledRoutes = {
+	routes: BlankStackRoutes;
+	descriptors: BlankStackDescriptors;
 };
 
 export type SceneActivityWindow = {

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

@@ -1,23 +1,12 @@
 import { useRef, useSyncExternalStore } from "react";
 import type { BlankStackProviderProps } from "../../../types/providers/blank-stack-provider.types";
-import type {
-	BaseStackDescriptor,
-	BaseStackNavigation,
-} from "../../../types/stack.types";
 import {
 	type BlankStackController,
 	createBlankStackController,
 } from "./blank-stack-controller";
 
-export const useBlankStackState = <
-	TDescriptor extends BaseStackDescriptor,
-	TNavigation extends BaseStackNavigation,
->(
-	props: BlankStackProviderProps<TDescriptor, TNavigation>,
-) => {
-	const controllerRef = useRef<
-		BlankStackController<TDescriptor, TNavigation> | undefined
-	>(undefined);
+export const useBlankStackState = (props: BlankStackProviderProps) => {
+	const controllerRef = useRef<BlankStackController | undefined>(undefined);
 
 	if (!controllerRef.current) {
 		controllerRef.current = createBlankStackController(props);

package/src/providers/stack/blank-stack.provider.tsx

@@ -1,33 +1,20 @@
-import type { Route } from "@react-navigation/native";
 import { type ReactNode, useMemo } from "react";
-import {
-	type StackContextValue,
-	StackProvider,
-} from "../../hooks/navigation/use-stack";
+import type { BlankStackDescriptor } from "../../types/blank-stack.types";
 import type {
 	BlankStackProviderProps,
 	BlankStackStoreValue,
 } from "../../types/providers/blank-stack-provider.types";
-import type {
-	BaseStackDescriptor,
-	BaseStackNavigation,
-	BaseStackScene,
-} from "../../types/stack.types";
+import type { BaseStackScene } from "../../types/stack.types";
 import createProvider from "../../utils/create-provider";
 import { useBlankStackState } from "./blank-stack-state";
-import { useStackCoreStore } from "./core.provider";
+import { resolvePresentedIndex } from "./blank-stack-state/helpers/resolve-presented-index";
 
-type InternalBlankStackProviderProps = BlankStackProviderProps<
-	BaseStackDescriptor,
-	BaseStackNavigation
-> & {
+type InternalBlankStackProviderProps = BlankStackProviderProps & {
 	children: ReactNode;
 };
 
-const createScenesByKey = <TDescriptor extends BaseStackDescriptor>(
-	scenes: BaseStackScene<TDescriptor>[],
-) => {
-	const scenesByKey: Record<string, BaseStackScene<TDescriptor>> = {};
+const createScenesByKey = (scenes: BaseStackScene<BlankStackDescriptor>[]) => {
+	const scenesByKey: Record<string, BaseStackScene<BlankStackDescriptor>> = {};
 
 	for (const scene of scenes) {
 		scenesByKey[scene.route.key] = scene;
@@ -36,74 +23,54 @@ const createScenesByKey = <TDescriptor extends BaseStackDescriptor>(
 	return scenesByKey;
 };
 
-type BlankStackStoreProviderProps = {
-	children: ReactNode;
-	value: BlankStackStoreValue<BaseStackDescriptor>;
-};
-
-const { BlankStackProvider: BlankStackStoreProvider, useBlankStackStore } =
-	createProvider("BlankStack", { guarded: false })<
-		BlankStackStoreProviderProps,
-		BlankStackStoreValue<BaseStackDescriptor>
-	>(({ children, value }) => ({ children, value }));
-
-function BlankStackProvider({
-	state: stackState,
-	children,
-	...props
-}: InternalBlankStackProviderProps) {
-	const flags = useStackCoreStore((store) => store.flags);
+const {
+	StoreProvider: BlankStackStoreProvider,
+	BlankStackProvider,
+	useBlankStackStore,
+} = createProvider("BlankStack")<
+	InternalBlankStackProviderProps,
+	BlankStackStoreValue
+>(({ state: stackState, children, ...props }) => {
 	const { state, handleCloseRoute, requestDismiss } = useBlankStackState({
 		...props,
 		state: stackState,
 	});
 	const navigatorKey = stackState.key;
-	const focusedIndex = stackState.index;
+	const focusedIndex = resolvePresentedIndex(
+		state.routes,
+		state.focusedRouteKey,
+		state.closingRouteKeys,
+	);
 	const scenesByKey = useMemo(
 		() => createScenesByKey(state.scenes),
 		[state.scenes],
 	);
+	const paintDriverRouteKeyByRouteKey = useMemo(() => {
+		const paintDrivers = new Map<string, string>();
+
+		for (let index = 0; index + 2 < state.routeKeys.length; index++) {
+			paintDrivers.set(state.routeKeys[index], state.routeKeys[index + 2]);
+		}
 
-	const stackValue = useMemo<StackContextValue>(
-		() => ({
-			flags,
+		return paintDrivers;
+	}, [state.routeKeys]);
+
+	return {
+		value: {
 			navigatorKey,
 			routeKeys: state.routeKeys,
-			routes: state.routes as Route<string>[],
-			scenes: state.scenes as BaseStackScene[],
-			focusedIndex,
-			requestDismiss,
-		}),
-		[
-			flags,
-			navigatorKey,
-			state.routeKeys,
-			state.routes,
-			state.scenes,
+			routes: state.routes,
+			scenes: state.scenes,
+			scenesByKey,
+			paintDriverRouteKeyByRouteKey,
 			focusedIndex,
 			requestDismiss,
-		],
-	);
-	const blankStackValue = {
-		navigatorKey,
-		routeKeys: state.routeKeys,
-		routes: state.routes,
-		scenes: state.scenes,
-		scenesByKey,
-		focusedIndex,
-		requestDismiss,
-		shouldShowFloatOverlay: state.shouldShowFloatOverlay,
-		handleCloseRoute,
+			shouldShowFloatOverlay: state.shouldShowFloatOverlay,
+			handleCloseRoute,
+		},
+		children,
 	};
-
-	return (
-		<StackProvider value={stackValue}>
-			<BlankStackStoreProvider value={blankStackValue}>
-				{children}
-			</BlankStackStoreProvider>
-		</StackProvider>
-	);
-}
+});
 
 export type { BlankStackProviderProps, BlankStackStoreValue };
-export { BlankStackProvider, useBlankStackStore };
+export { BlankStackProvider, BlankStackStoreProvider, useBlankStackStore };

package/src/providers/stack/core.provider.tsx

@@ -6,14 +6,10 @@ import {
 	SafeAreaInsetsContext,
 	SafeAreaProvider,
 } from "react-native-safe-area-context";
-import { StackType } from "../../types/stack.types";
 import createProvider from "../../utils/create-provider";
 
 export interface StackCoreConfig {
 	TRANSITIONS_ALWAYS_ON?: boolean;
-	STACK_TYPE?: StackType;
-	DISABLE_NATIVE_SCREENS?: boolean;
-	DISABLE_NATIVE_SCREEN_CONTAINER?: boolean;
 }
 
 interface StackCoreProviderProps {
@@ -24,9 +20,6 @@ interface StackCoreProviderProps {
 export interface StackCoreContextValue {
 	flags: {
 		TRANSITIONS_ALWAYS_ON: boolean;
-		STACK_TYPE?: StackType;
-		DISABLE_NATIVE_SCREENS: boolean;
-		DISABLE_NATIVE_SCREEN_CONTAINER: boolean;
 	};
 }
 
@@ -63,16 +56,11 @@ const StackSafeAreaProvider = memo(function StackSafeAreaProvider({
 
 const StackCoreRoot = memo(function StackCoreRoot({
 	children,
-	stackType,
 }: {
 	children: ReactNode;
-	stackType: StackType;
 }) {
 	return (
-		<GestureHandlerRootView
-			style={styles.container}
-			pointerEvents={stackType === StackType.COMPONENT ? "box-none" : undefined}
-		>
+		<GestureHandlerRootView style={styles.container}>
 			<StackSafeAreaProvider>{children}</StackSafeAreaProvider>
 		</GestureHandlerRootView>
 	);
@@ -80,33 +68,19 @@ const StackCoreRoot = memo(function StackCoreRoot({
 
 export const { StackCoreProvider, useStackCoreStore } = createProvider(
 	"StackCore",
-	{ guarded: true },
 )<StackCoreProviderProps, StackCoreContextValue>(({ config, children }) => {
-	const {
-		TRANSITIONS_ALWAYS_ON = false,
-		DISABLE_NATIVE_SCREENS = false,
-		DISABLE_NATIVE_SCREEN_CONTAINER = false,
-		STACK_TYPE = StackType.BLANK,
-	} = config;
+	const { TRANSITIONS_ALWAYS_ON = false } = config;
 
 	const flags = useMemo(
 		() => ({
 			TRANSITIONS_ALWAYS_ON,
-			STACK_TYPE,
-			DISABLE_NATIVE_SCREENS,
-			DISABLE_NATIVE_SCREEN_CONTAINER,
 		}),
-		[
-			TRANSITIONS_ALWAYS_ON,
-			STACK_TYPE,
-			DISABLE_NATIVE_SCREENS,
-			DISABLE_NATIVE_SCREEN_CONTAINER,
-		],
+		[TRANSITIONS_ALWAYS_ON],
 	);
 
 	return {
 		value: { flags },
-		children: <StackCoreRoot stackType={STACK_TYPE}>{children}</StackCoreRoot>,
+		children: <StackCoreRoot>{children}</StackCoreRoot>,
 	};
 });
 

package/src/stores/animation.store.ts

@@ -10,7 +10,6 @@ import { createStore } from "../utils/create-store";
 export type AnimationStoreMap = {
 	transitionProgress: SharedValue<number>;
 	visualProgress: SharedValue<number>;
-	stackProgress: SharedValue<number>;
 	willAnimate: SharedValue<number>;
 	progressAnimating: SharedValue<number>;
 	progressSettled: SharedValue<number>;
@@ -39,7 +38,6 @@ function createAnimationBag(): AnimationStoreMap {
 	return {
 		transitionProgress: makeMutable(0),
 		visualProgress: makeMutable(0),
-		stackProgress: makeMutable(0),
 		willAnimate: makeMutable(0),
 		closing: makeMutable(0),
 		progressAnimating: makeMutable(0),
@@ -58,7 +56,6 @@ export const AnimationStore = createStore<AnimationStoreMap>({
 	disposeBag: (bag) => {
 		cancelAnimation(bag.transitionProgress);
 		cancelAnimation(bag.visualProgress);
-		cancelAnimation(bag.stackProgress);
 		cancelAnimation(bag.willAnimate);
 		cancelAnimation(bag.progressAnimating);
 		cancelAnimation(bag.progressSettled);

package/src/stores/bounds/internals/links.ts

@@ -411,16 +411,24 @@ function getPairKeyForSource(
 	"worklet";
 	const state = pairs.get();
 	const linkKey = getLinkKeyFromTag(tag);
+	let latestPairKey: ScreenPairKey | null = null;
+	let latestPairAwaitingSource: ScreenPairKey | null = null;
+
 	for (const pairKey in state) {
 		if (getSourceScreenKeyFromPairKey(pairKey) !== screenKey) continue;
-		if (
-			getResolvedLink(pairKey, tag).link?.destination ||
-			state[pairKey]?.sourceRequests?.[linkKey]
-		) {
-			return pairKey;
+
+		const link = getResolvedLink(pairKey, tag).link;
+		const hasSourceRequest = state[pairKey]?.sourceRequests?.[linkKey];
+
+		if (!link?.destination && !hasSourceRequest) continue;
+
+		latestPairKey = pairKey;
+		if (!link?.source) {
+			latestPairAwaitingSource = pairKey;
 		}
 	}
-	return null;
+
+	return latestPairAwaitingSource ?? latestPairKey;
 }
 
 function getPairKeyForDestination(