react-native-screen-transitions 3.9.0 → 3.11.0

package/src/shared/providers/screen/animation/helpers/hydrate-transition-state/index.ts

@@ -1,4 +1,3 @@
-import { EPSILON } from "../../../../../constants";
 import type {
 	ScreenTransitionOptions,
 	TransitionInterpolatorOptions,
@@ -92,6 +91,7 @@ export const hydrateTransitionState = (
 	out.gesture.dragging = s.gesture.dragging.get();
 	out.gesture.settling = s.gesture.settling.get();
 	out.gesture.active = s.gesture.active.get();
+	out.gesture.initiator = out.gesture.active ?? "none";
 	out.gesture.direction = s.gesture.direction.get();
 	const handoff = out.gesture.handoff;
 	const useHandoffSnapshot = out.gesture.dismissing;
@@ -166,7 +166,7 @@ export const hydrateTransitionState = (
 			x: s.gesture.internal.progressDeltaX.get(),
 			y: s.gesture.internal.progressDeltaY.get(),
 		},
-		effectiveOptions?.gestureDirection ?? s.options.gestureDirection,
+		options.gestureDirection,
 		getResolvedSnapBounds(
 			s.sortedNumericSnapPoints,
 			s.hasAutoSnapPoint ? s.resolvedAutoSnapPoint.get() : null,
@@ -174,35 +174,18 @@ export const hydrateTransitionState = (
 		),
 	);
 
-	// Unsure where else to place this if im being honest.
-	// I think for here is fine
 	if (s.visualProgress.get() !== out.progress) {
 		s.visualProgress.set(out.progress);
 	}
 
-	const hasResidualGestureValues =
-		Math.abs(out.gesture.normX) > EPSILON ||
-		Math.abs(out.gesture.normY) > EPSILON ||
-		Math.abs(out.gesture.normScale) > EPSILON ||
-		Math.abs(out.gesture.rotation) > EPSILON;
-
-	const isGestureActive =
-		out.gesture.dragging ||
-		out.gesture.settling ||
-		(!out.gesture.dismissing && hasResidualGestureValues)
-			? 1
-			: 0;
-
-	const isProgressAnimating = s.progressAnimating.get();
-
-	out.animating = isProgressAnimating || isGestureActive ? 1 : 0;
+	out.animating = s.progressAnimating.get();
 
 	out.gesture.normalizedX = out.gesture.normX;
 	out.gesture.normalizedY = out.gesture.normY;
 	out.gesture.isDismissing = out.gesture.dismissing;
 	out.gesture.isDragging = out.gesture.dragging;
 
-	out.settled = s.progressSettled.get() && !isGestureActive ? 1 : 0;
+	out.settled = s.progressSettled.get();
 	out.logicallySettled = out.settled;
 
 	out.meta = s.meta;

package/src/shared/providers/screen/animation/helpers/pipeline.ts

@@ -18,7 +18,7 @@ import type {
 	ScreenTransitionState,
 } from "../../../../types/animation.types";
 
-import { type BaseDescriptor, useDescriptors } from "../../descriptors";
+import { type BaseDescriptor, useDescriptorsStore } from "../../descriptors";
 import { buildScreenTransitionOptions } from "./build-screen-transition-options";
 import { updateDerivations } from "./derivations";
 import { hasTransitionsEnabled } from "./has-transitions-enabled";
@@ -157,7 +157,7 @@ const createInitialInterpolatorProps = ({
 		progress: currentProgress,
 		entering: currentEntering,
 		animating: currentEntering,
-		willAnimate: currentEntering,
+		willAnimate: 0,
 	});
 	const previous = prevDescriptor
 		? createInitialTransitionState({
@@ -173,7 +173,7 @@ const createInitialInterpolatorProps = ({
 				progress: 0,
 				entering: 1,
 				animating: 1,
-				willAnimate: 1,
+				willAnimate: 0,
 				settled: 0,
 			})
 		: undefined;
@@ -280,11 +280,9 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 	const dimensions = useWindowDimensions();
 	const insets = useSafeAreaInsets();
 
-	const {
-		current: currDescriptor,
-		next: nextDescriptor,
-		previous: prevDescriptor,
-	} = useDescriptors();
+	const currDescriptor = useDescriptorsStore((store) => store.current);
+	const nextDescriptor = useDescriptorsStore((store) => store.next);
+	const prevDescriptor = useDescriptorsStore((store) => store.previous);
 
 	const currentAnimation = useBuildTransitionState(currDescriptor);
 	const nextAnimation = useBuildTransitionState(nextDescriptor);
@@ -314,10 +312,8 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 		});
 
 	const propsRevisionState = useSharedValue({ value: 0 });
-
 	const screenInterpolatorPropsRevision = useDerivedValue<number>(() => {
 		"worklet";
-
 		screenInterpolatorProps.modify((frame) => {
 			"worklet";
 			const interpolatorOptions = selectedInterpolatorOptions.get();

package/src/shared/providers/screen/animation/index.tsx

@@ -1,6 +1,6 @@
 export {
 	ScreenAnimationProvider,
-	useScreenAnimationContext,
+	useScreenAnimationStore,
 } from "./animation.provider";
 export {
 	type ScreenAnimationTarget,

package/src/shared/providers/screen/animation/use-screen-animation.tsx

@@ -3,7 +3,7 @@ import type {
 	ScreenInterpolationProps,
 	ScreenTransitionTarget,
 } from "../../../types/animation.types";
-import { useScreenAnimationContext } from "./animation.provider";
+import { useScreenAnimationStore } from "./animation.provider";
 import { useBuildTransitionAccessor } from "./helpers/accessors/use-build-transition-accessor";
 import { readScreenAnimationRevisions } from "./helpers/read-screen-animation-revisions";
 import type {
@@ -37,7 +37,7 @@ export function useScreenAnimation(
 		screenInterpolatorPropsRevision,
 		ancestorScreenAnimationSources,
 		descendantScreenAnimationSources,
-	} = useScreenAnimationContext();
+	} = useScreenAnimationStore();
 	const transition = useBuildTransitionAccessor();
 	const transitionTarget = normalizeScreenAnimationTarget(
 		target,

package/src/shared/providers/screen/descriptors/descriptors.provider.tsx

@@ -1,5 +1,7 @@
 import type { ReactNode } from "react";
 import { useMemo } from "react";
+import { useScreenTransitionsAdapterOptionalContext } from "../../../adapters/with-screen-transitions/context";
+import { useBlankStackStore } from "../../../providers/stack/blank-stack.provider";
 import type { BaseStackDescriptor } from "../../../types/stack.types";
 import createProvider from "../../../utils/create-provider";
 import type { DescriptorDerivations } from "./helpers/derive-descriptor-derivations";
@@ -25,87 +27,96 @@ export type DescriptorDerivationsContextValue = DescriptorDerivations;
 
 interface DescriptorStoreValue<
 	TDescriptor extends BaseDescriptor = BaseDescriptor,
-> {
+> extends DescriptorsContextValue<TDescriptor> {
 	descriptors: DescriptorsContextValue<TDescriptor>;
 	derivations: DescriptorDerivationsContextValue;
+	options: TDescriptor["options"];
 }
 
-interface DescriptorsProviderProps<TDescriptor extends BaseDescriptor> {
+type DescriptorsProviderProps = {
 	children: ReactNode;
-	previous?: TDescriptor;
-	current: TDescriptor;
-	next?: TDescriptor;
-}
-
-const {
-	DescriptorsProvider: InternalDescriptorsProvider,
-	useDescriptorsStore,
-} = createProvider("Descriptors", { guarded: true })<
-	DescriptorsProviderProps<BaseDescriptor>,
-	DescriptorStoreValue<BaseDescriptor>
->(({ previous, current, next, children }) => {
-	const descriptors = useMemo(
-		() => ({ previous, current, next }),
-		[previous, current, next],
-	);
-
-	const { ancestorKeys, ancestorDestinationPairKey } = useMemo(
-		() => getAncestorKeyState(current),
-		[current],
-	);
-
-	const derivations = useMemo(
-		() =>
-			deriveDescriptorDerivations({
-				previous,
-				current,
-				next,
-				ancestorKeys,
-				ancestorDestinationPairKey,
-			}),
-		[previous, current, next, ancestorKeys, ancestorDestinationPairKey],
-	);
+	previous?: BaseDescriptor;
+	current?: BaseDescriptor;
+	next?: BaseDescriptor;
+	routeKey?: string;
+};
 
-	const value = useMemo(
-		() => ({
-			descriptors,
-			derivations,
-		}),
-		[descriptors, derivations],
-	);
+export const { DescriptorsProvider, useDescriptorsStore } = createProvider(
+	"Descriptors",
+	{ guarded: true },
+)<DescriptorsProviderProps, DescriptorStoreValue<BaseDescriptor>>(
+	({ previous, current, next, routeKey, children }) => {
+		const blankStackCurrent = useBlankStackStore((store) =>
+			routeKey ? store?.scenesByKey[routeKey]?.descriptor : undefined,
+		);
+		const blankStackPrevious = useBlankStackStore((store) =>
+			routeKey ? store?.scenesByKey[routeKey]?.previousDescriptor : undefined,
+		);
+		const blankStackNext = useBlankStackStore((store) =>
+			routeKey ? store?.scenesByKey[routeKey]?.nextDescriptor : undefined,
+		);
+		const adapterContext = useScreenTransitionsAdapterOptionalContext();
+		const adapterScene = routeKey
+			? (adapterContext?.scenesByKey?.[routeKey] ??
+				adapterContext?.scenes[
+					adapterContext.routeIndexByKey.get(routeKey) ?? -1
+				])
+			: undefined;
 
-	return {
-		value,
-		children,
-	};
-});
+		const resolvedCurrent =
+			current ?? blankStackCurrent ?? adapterScene?.descriptor;
+		const resolvedPrevious =
+			previous ?? blankStackPrevious ?? adapterScene?.previousDescriptor;
+		const resolvedNext = next ?? blankStackNext ?? adapterScene?.nextDescriptor;
 
-export function DescriptorsProvider<TDescriptor extends BaseDescriptor>({
-	children,
-	previous,
-	current,
-	next,
-}: DescriptorsProviderProps<TDescriptor>) {
-	const providerProps = {
-		previous,
-		current,
-		next,
-		children,
-	};
+		if (!resolvedCurrent) {
+			throw new Error(
+				`Descriptors scene "${routeKey ?? "unknown"}" was not found.`,
+			);
+		}
 
-	return <InternalDescriptorsProvider {...providerProps} />;
-}
+		const descriptors = useMemo(
+			() => ({
+				previous: resolvedPrevious,
+				current: resolvedCurrent,
+				next: resolvedNext,
+			}),
+			[resolvedPrevious, resolvedCurrent, resolvedNext],
+		);
 
-export function useDescriptors<
-	TDescriptor extends BaseDescriptor = BaseDescriptor,
->() {
-	return useDescriptorsStore(
-		(store) => store.descriptors,
-	) as DescriptorsContextValue<TDescriptor>;
-}
+		const { ancestorKeys, ancestorDestinationPairKey } = useMemo(
+			() => getAncestorKeyState(resolvedCurrent),
+			[resolvedCurrent],
+		);
 
-export function useDescriptorDerivations(): DescriptorDerivationsContextValue {
-	return useDescriptorsStore((store) => store.derivations);
-}
+		const derivations = useMemo(
+			() =>
+				deriveDescriptorDerivations({
+					previous: resolvedPrevious,
+					current: resolvedCurrent,
+					next: resolvedNext,
+					ancestorKeys,
+					ancestorDestinationPairKey,
+				}),
+			[
+				resolvedPrevious,
+				resolvedCurrent,
+				resolvedNext,
+				ancestorKeys,
+				ancestorDestinationPairKey,
+			],
+		);
 
-export { useDescriptorsStore };
+		return {
+			value: {
+				previous: resolvedPrevious,
+				current: resolvedCurrent,
+				next: resolvedNext,
+				descriptors,
+				derivations,
+				options: resolvedCurrent.options,
+			},
+			children,
+		};
+	},
+);

package/src/shared/providers/screen/descriptors/index.tsx

@@ -1,7 +1,5 @@
 export {
 	type BaseDescriptor,
 	DescriptorsProvider,
-	useDescriptorDerivations,
-	useDescriptors,
 	useDescriptorsStore,
 } from "./descriptors.provider";

package/src/shared/providers/screen/gestures/gestures.provider.tsx

@@ -3,12 +3,11 @@ import { Gesture } from "react-native-gesture-handler";
 import { useSharedValue } from "react-native-reanimated";
 import { ScrollStore } from "../../../stores/scroll.store";
 import createProvider from "../../../utils/create-provider";
-import { useDescriptorDerivations } from "../descriptors";
+import { useDescriptorsStore } from "../descriptors";
 import { useScreenGestureConfig } from "./hooks/use-screen-gesture-config";
 import { useWalkUpAndRegisterShadowingClaims } from "./ownership/use-walk-up-and-register-shadowing-claims";
 import { useBuildPanGesture } from "./pan/use-build-pan-gesture";
 import { useBuildPinchGesture } from "./pinch/use-build-pinch-gesture";
-import { useBuildRotationGesture } from "./rotation/use-build-rotation-gesture";
 import {
 	type DirectionClaimMap,
 	type GestureCompositionOwner,
@@ -20,81 +19,83 @@ interface ScreenGestureProviderProps {
 	children: React.ReactNode;
 }
 
-export const {
-	ScreenGestureProvider,
-	useScreenGestureContext: useGestureContext,
-} = createProvider("ScreenGesture", { guarded: false })<
-	ScreenGestureProviderProps,
-	GestureContextType
->(({ children }): { value: GestureContextType; children: React.ReactNode } => {
-	const gestureContext = useGestureContext();
-	const gestureConfig = useScreenGestureConfig();
-	const { currentScreenKey } = useDescriptorDerivations();
+export const { ScreenGestureProvider, useScreenGestureStore: useGestureStore } =
+	createProvider("ScreenGesture", { guarded: false })<
+		ScreenGestureProviderProps,
+		GestureContextType
+	>(
+		(
+			{ children },
+			{ useParentStore },
+		): { value: GestureContextType; children: React.ReactNode } => {
+			const gestureContext = useParentStore();
+			const gestureConfig = useScreenGestureConfig();
+			const currentScreenKey = useDescriptorsStore(
+				(store) => store.derivations.currentScreenKey,
+			);
 
-	const scrollState = ScrollStore.getValue(currentScreenKey, "coordination");
+			const scrollState = ScrollStore.getValue(
+				currentScreenKey,
+				"coordination",
+			);
 
-	// Ancestors read this before activating. If a nested screen claims the same
-	// direction, it writes here so the ancestor can fail and let it take priority.
-	const childDirectionClaims =
-		useSharedValue<DirectionClaimMap>(NO_DIRECTION_CLAIMS);
+			// Ancestors read this before activating. If a nested screen claims the same
+			// direction, it writes here so the ancestor can fail and let it take priority.
+			const childDirectionClaims =
+				useSharedValue<DirectionClaimMap>(NO_DIRECTION_CLAIMS);
 
-	// The first gesture to activate owns navigation release. Other gestures may
-	// still join as companion trackers during the same simultaneous composition.
-	const gestureCompositionOwner = useSharedValue<GestureCompositionOwner>(null);
+			// The first gesture to activate owns navigation release. Other gestures may
+			// still join as companion trackers during the same simultaneous composition.
+			const gestureCompositionOwner =
+				useSharedValue<GestureCompositionOwner>(null);
 
-	const panGesture = useBuildPanGesture({
-		scrollState,
-		gestureConfig,
-		childDirectionClaims,
-		gestureCompositionOwner,
-	});
+			const panGesture = useBuildPanGesture({
+				scrollState,
+				gestureConfig,
+				childDirectionClaims,
+				gestureCompositionOwner,
+			});
 
-	const pinchGesture = useBuildPinchGesture({
-		gestureConfig,
-		gestureCompositionOwner,
-	});
+			const pinchGesture = useBuildPinchGesture({
+				gestureConfig,
+				gestureCompositionOwner,
+			});
 
-	const rotationGesture = useBuildRotationGesture({
-		gestureConfig,
-		gestureCompositionOwner,
-	});
+			const detectorGesture = useMemo(
+				() => Gesture.Simultaneous(panGesture, pinchGesture),
+				[panGesture, pinchGesture],
+			);
 
-	const detectorGesture = useMemo(
-		() => Gesture.Simultaneous(panGesture, pinchGesture, rotationGesture),
-		[panGesture, pinchGesture, rotationGesture],
-	);
+			const value = useMemo<GestureContextType>(
+				() => ({
+					routeKey: currentScreenKey,
+					detectorGesture,
+					panGesture,
+					pinchGesture,
+					scrollState,
+					gestureContext,
+					claimedDirections: gestureConfig.participation.claimedDirections,
+					childDirectionClaims,
+				}),
+				[
+					currentScreenKey,
+					detectorGesture,
+					panGesture,
+					pinchGesture,
+					scrollState,
+					gestureContext,
+					gestureConfig.participation.claimedDirections,
+					childDirectionClaims,
+				],
+			);
 
-	const value = useMemo<GestureContextType>(
-		() => ({
-			routeKey: currentScreenKey,
-			detectorGesture,
-			panGesture,
-			pinchGesture,
-			rotationGesture,
-			scrollState,
-			gestureContext,
-			claimedDirections: gestureConfig.participation.claimedDirections,
-			childDirectionClaims,
-		}),
-		[
-			currentScreenKey,
-			detectorGesture,
-			panGesture,
-			pinchGesture,
-			rotationGesture,
-			scrollState,
-			gestureContext,
-			gestureConfig.participation.claimedDirections,
-			childDirectionClaims,
-		],
-	);
+			useWalkUpAndRegisterShadowingClaims(
+				gestureConfig.participation.claimedDirections,
+			);
 
-	useWalkUpAndRegisterShadowingClaims(
-		gestureConfig.participation.claimedDirections,
+			return {
+				value,
+				children,
+			};
+		},
 	);
-
-	return {
-		value,
-		children,
-	};
-});

package/src/shared/providers/screen/gestures/hooks/use-screen-gesture-config.ts

@@ -1,16 +1,15 @@
 import { useMemo } from "react";
-import { useDescriptorDerivations, useDescriptors } from "../../descriptors";
-import { useGestureContext } from "../gestures.provider";
+import { useDescriptorsStore } from "../../descriptors";
+import { useGestureStore } from "../gestures.provider";
 import { resolveScreenGestureConfig } from "../shared/policy";
 import type { ScreenGestureConfig } from "../types";
 
 export function useScreenGestureConfig(): ScreenGestureConfig {
-	const gestureContext = useGestureContext();
-	const {
-		current: { options },
-	} = useDescriptors();
-
-	const { isFirstKey } = useDescriptorDerivations();
+	const gestureContext = useGestureStore();
+	const options = useDescriptorsStore((store) => store.options);
+	const isFirstKey = useDescriptorsStore(
+		(store) => store.derivations.isFirstKey,
+	);
 
 	return useMemo(
 		() =>

package/src/shared/providers/screen/gestures/hooks/use-screen-gesture.ts

@@ -2,7 +2,7 @@ import {
 	type ChainTarget,
 	resolveChainTarget,
 } from "../../../../utils/resolve-chain-target";
-import { useGestureContext } from "../gestures.provider";
+import { useGestureStore } from "../gestures.provider";
 import { walkGestureAncestors } from "../shared/ancestors";
 
 export type ScreenGestureTarget = ChainTarget;
@@ -21,7 +21,7 @@ export type ScreenGestureTarget = ChainTarget;
  * ```
  */
 export const useScreenGesture = (target?: ScreenGestureTarget) => {
-	const ctx = useGestureContext();
+	const ctx = useGestureStore();
 
 	return (
 		resolveChainTarget({

package/src/shared/providers/screen/gestures/hooks/use-stable-runtime-config.ts

@@ -3,7 +3,7 @@ import { type SharedValue, useSharedValue } from "react-native-reanimated";
 import { AnimationStore } from "../../../../stores/animation.store";
 import { GestureStore } from "../../../../stores/gesture.store";
 import { SystemStore } from "../../../../stores/system.store";
-import { useDescriptorDerivations } from "../../descriptors";
+import { useDescriptorsStore } from "../../descriptors";
 import type { GesturePolicy, GestureRuntime } from "../types";
 
 type RuntimeConfigInput<TPolicy extends GesturePolicy> = Omit<
@@ -14,7 +14,9 @@ type RuntimeConfigInput<TPolicy extends GesturePolicy> = Omit<
 export function useStableRuntimeConfig<TPolicy extends GesturePolicy>(
 	runtimeConfigInput: RuntimeConfigInput<TPolicy>,
 ): SharedValue<GestureRuntime<TPolicy>> {
-	const { currentScreenKey } = useDescriptorDerivations();
+	const currentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
 	const { participation, policy } = runtimeConfigInput;
 
 	const stores = useMemo(() => {

package/src/shared/providers/screen/gestures/index.tsx

@@ -1,6 +1,6 @@
 export {
 	ScreenGestureProvider,
-	useGestureContext,
+	useGestureStore,
 } from "./gestures.provider";
 export type {
 	DirectionClaim,

package/src/shared/providers/screen/gestures/ownership/shadowing-claims.ts

@@ -1,16 +1,15 @@
 import type { ClaimedDirections } from "../../../../types/ownership.types";
-import type { StackSceneActivity } from "../../../../types/stack.types";
 
 export const resolveShadowingClaimDirections = ({
-	currentActivity,
+	isCurrentScreenClosing,
 	currentClaimedDirections,
 	previousClaimedDirections,
 }: {
-	currentActivity: StackSceneActivity | undefined;
+	isCurrentScreenClosing: boolean;
 	currentClaimedDirections: ClaimedDirections;
 	previousClaimedDirections: ClaimedDirections;
 }): ClaimedDirections => {
-	if (currentActivity === "closing") {
+	if (isCurrentScreenClosing) {
 		return previousClaimedDirections;
 	}
 

package/src/shared/providers/screen/gestures/ownership/use-walk-up-and-register-shadowing-claims.ts

@@ -8,10 +8,10 @@ import {
 } from "../../../../types/ownership.types";
 import {
 	type BaseDescriptor,
-	useDescriptorDerivations,
-	useDescriptors,
+	useDescriptorsStore,
 } from "../../../screen/descriptors";
-import { useGestureContext } from "../gestures.provider";
+import { useBlankStackStore } from "../../../stack/blank-stack.provider";
+import { useGestureStore } from "../gestures.provider";
 import { walkGestureAncestors } from "../shared/ancestors";
 import { resolveScreenGestureConfig } from "../shared/policy";
 import type { GestureContextType } from "../types";
@@ -135,9 +135,17 @@ const getDescriptorClaimedDirections = (
 export function useWalkUpAndRegisterShadowingClaims(
 	claimedDirections: ClaimedDirections,
 ): void {
-	const parentContext = useGestureContext();
-	const { current, previous } = useDescriptors();
-	const { isTopMostScreen, currentScreenKey } = useDescriptorDerivations();
+	const parentContext = useGestureStore();
+	const previous = useDescriptorsStore((store) => store.previous);
+	const isTopMostScreen = useDescriptorsStore(
+		(store) => store.derivations.isTopMostScreen,
+	);
+	const currentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
+	const isCurrentScreenClosing = useBlankStackStore(
+		(store) => store?.scenesByKey[currentScreenKey]?.activity === "closing",
+	);
 
 	/*
 	 * We want to calculate effective claimed directions as claimedDirections is not enough for us.
@@ -161,14 +169,14 @@ export function useWalkUpAndRegisterShadowingClaims(
 	const effectiveClaimedDirections = useMemo(
 		() =>
 			resolveShadowingClaimDirections({
-				currentActivity: current.activity,
+				isCurrentScreenClosing,
 				currentClaimedDirections: claimedDirections,
 				previousClaimedDirections: getDescriptorClaimedDirections(
 					previous,
 					parentContext,
 				),
 			}),
-		[current.activity, claimedDirections, previous, parentContext],
+		[isCurrentScreenClosing, claimedDirections, previous, parentContext],
 	);
 
 	const shadowedAncestors = useMemo(

package/src/shared/providers/screen/gestures/pan/activation/use-pan-activation.ts

@@ -7,7 +7,7 @@ import { type SharedValue, useSharedValue } from "react-native-reanimated";
 import { GestureStore } from "../../../../../stores/gesture.store";
 import { GestureActivationState } from "../../../../../types/gesture.types";
 import type { Direction } from "../../../../../types/ownership.types";
-import { useDescriptorDerivations } from "../../../descriptors";
+import { useDescriptorsStore } from "../../../descriptors";
 import type { ScreenOptionsContextValue } from "../../../options";
 import { resolvePanRuntime } from "../../shared/runtime";
 import type {
@@ -36,7 +36,12 @@ export const usePanActivation = ({
 	dimensions,
 	gestureCompositionOwner,
 }: UsePanActivationProps) => {
-	const { currentScreenKey, parentScreenKey } = useDescriptorDerivations();
+	const currentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
+	const parentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.parentScreenKey,
+	);
 
 	const ancestorDismissing = useMemo(() => {
 		if (!parentScreenKey) return null;