react-native-screen-transitions 3.10.0 → 3.11.1

package/src/shared/providers/screen/animation/helpers/accessors/use-build-transition-accessor.ts

@@ -4,7 +4,7 @@ import type {
 	ScreenTransitionTarget,
 } from "../../../../../types/animation.types";
 import { createBoundsAccessor } from "../../../../../utils/bounds";
-import { useScreenAnimationContext } from "../../animation.provider";
+import { useScreenAnimationStore } from "../../animation.provider";
 import type {
 	ScreenAnimationDescendantSources,
 	ScreenAnimationSource,
@@ -124,7 +124,7 @@ export const useBuildTransitionAccessor = () => {
 		screenInterpolatorPropsRevision,
 		ancestorScreenAnimationSources,
 		descendantScreenAnimationSources,
-	} = useScreenAnimationContext();
+	} = useScreenAnimationStore();
 
 	return useMemo(() => {
 		const selfSource = {

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,10 +1,12 @@
 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";
 import { deriveDescriptorDerivations } from "./helpers/derive-descriptor-derivations";
-import { getAncestorKeyState } from "./helpers/get-ancestor-keys";
+import { getAncestorKeys } from "./helpers/get-ancestor-keys";
 
 /**
  * Base descriptor interface - minimal contract for all stack types.
@@ -25,87 +27,89 @@ 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],
-	);
+	previous?: BaseDescriptor;
+	current?: BaseDescriptor;
+	next?: BaseDescriptor;
+	routeKey?: string;
+};
 
-	const derivations = useMemo(
-		() =>
-			deriveDescriptorDerivations({
-				previous,
-				current,
-				next,
-				ancestorKeys,
-				ancestorDestinationPairKey,
-			}),
-		[previous, current, next, ancestorKeys, ancestorDestinationPairKey],
-	);
+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;
 
-	const value = useMemo(
-		() => ({
-			descriptors,
-			derivations,
-		}),
-		[descriptors, derivations],
-	);
+		const resolvedCurrent =
+			current ?? blankStackCurrent ?? adapterScene?.descriptor;
+		const resolvedPrevious =
+			previous ?? blankStackPrevious ?? adapterScene?.previousDescriptor;
+		const resolvedNext = next ?? blankStackNext ?? adapterScene?.nextDescriptor;
 
-	return {
-		value,
-		children,
-	};
-});
+		if (!resolvedCurrent) {
+			throw new Error(
+				`Descriptors scene "${routeKey ?? "unknown"}" was not found.`,
+			);
+		}
 
-export function DescriptorsProvider<TDescriptor extends BaseDescriptor>({
-	children,
-	previous,
-	current,
-	next,
-}: DescriptorsProviderProps<TDescriptor>) {
-	const providerProps = {
-		previous,
-		current,
-		next,
-		children,
-	};
+		const descriptors = useMemo(
+			() => ({
+				previous: resolvedPrevious,
+				current: resolvedCurrent,
+				next: resolvedNext,
+			}),
+			[resolvedPrevious, resolvedCurrent, resolvedNext],
+		);
 
-	return <InternalDescriptorsProvider {...providerProps} />;
-}
+		const ancestorKeys = useMemo(
+			() => getAncestorKeys(resolvedCurrent),
+			[resolvedCurrent],
+		);
 
-export function useDescriptors<
-	TDescriptor extends BaseDescriptor = BaseDescriptor,
->() {
-	return useDescriptorsStore(
-		(store) => store.descriptors,
-	) as DescriptorsContextValue<TDescriptor>;
-}
-
-export function useDescriptorDerivations(): DescriptorDerivationsContextValue {
-	return useDescriptorsStore((store) => store.derivations);
-}
+		const derivations = useMemo(
+			() =>
+				deriveDescriptorDerivations({
+					previous: resolvedPrevious,
+					current: resolvedCurrent,
+					next: resolvedNext,
+					ancestorKeys,
+				}),
+			[resolvedPrevious, resolvedCurrent, resolvedNext, ancestorKeys],
+		);
 
-export { useDescriptorsStore };
+		return {
+			value: {
+				previous: resolvedPrevious,
+				current: resolvedCurrent,
+				next: resolvedNext,
+				descriptors,
+				derivations,
+				options: resolvedCurrent.options,
+			},
+			children,
+		};
+	},
+);

package/src/shared/providers/screen/descriptors/helpers/derive-descriptor-derivations.ts

@@ -8,7 +8,6 @@ export interface DescriptorDerivations {
 	nextScreenKey?: string;
 	sourcePairKey?: ScreenPairKey;
 	destinationPairKey?: ScreenPairKey;
-	ancestorDestinationPairKey?: ScreenPairKey;
 	parentScreenKey?: string;
 	isFirstKey: boolean;
 	isTopMostScreen: boolean;
@@ -21,7 +20,6 @@ interface Params {
 	current: BaseStackDescriptor;
 	next?: BaseStackDescriptor;
 	ancestorKeys: string[];
-	ancestorDestinationPairKey?: ScreenPairKey;
 }
 
 export function deriveDescriptorDerivations({
@@ -29,7 +27,6 @@ export function deriveDescriptorDerivations({
 	current,
 	next,
 	ancestorKeys,
-	ancestorDestinationPairKey,
 }: Params): DescriptorDerivations {
 	const previousScreenKey = previous?.route.key;
 	const currentScreenKey = current.route.key;
@@ -56,7 +53,6 @@ export function deriveDescriptorDerivations({
 		nextScreenKey,
 		sourcePairKey,
 		destinationPairKey,
-		ancestorDestinationPairKey,
 		parentScreenKey: ancestorKeys[0],
 		isFirstKey,
 		isTopMostScreen,

package/src/shared/providers/screen/descriptors/helpers/get-ancestor-keys.ts

@@ -1,26 +1,14 @@
-import { createScreenPairKey } from "../../../../stores/bounds/helpers/link-pairs.helpers";
-import type { ScreenPairKey } from "../../../../stores/bounds/types";
 import type { BaseStackDescriptor } from "../../../../types/stack.types";
 
-export interface AncestorKeyState {
-	ancestorKeys: string[];
-	ancestorDestinationPairKey?: ScreenPairKey;
-}
-
 /**
  * Builds nested navigator ancestor keys from immediate parent to root.
- * The nearest ancestor destination pair lets child routes attach measurements
- * to the transition owned by the parent stack.
  */
-export function getAncestorKeyState(
-	current: BaseStackDescriptor,
-): AncestorKeyState {
+export function getAncestorKeys(current: BaseStackDescriptor): string[] {
 	const ancestors: string[] = [];
-	let ancestorDestinationPairKey: ScreenPairKey | undefined;
 	const nav = current.navigation as any;
 
 	if (typeof nav?.getParent !== "function") {
-		return { ancestorKeys: ancestors };
+		return ancestors;
 	}
 
 	let parent = nav.getParent();
@@ -31,25 +19,10 @@ export function getAncestorKeyState(
 			const focusedRoute = state.routes[state.index];
 			if (focusedRoute?.key) {
 				ancestors.push(focusedRoute.key);
-
-				const previousRoute = state.routes[state.index - 1];
-				if (!ancestorDestinationPairKey && previousRoute?.key) {
-					ancestorDestinationPairKey = createScreenPairKey(
-						previousRoute.key,
-						focusedRoute.key,
-					);
-				}
 			}
 		}
 		parent = parent.getParent();
 	}
 
-	return {
-		ancestorKeys: ancestors,
-		ancestorDestinationPairKey,
-	};
-}
-
-export function getAncestorKeys(current: BaseStackDescriptor): string[] {
-	return getAncestorKeyState(current).ancestorKeys;
+	return ancestors;
 }

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,7 +3,7 @@ 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";
@@ -19,74 +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 detectorGesture = useMemo(
-		() => Gesture.Simultaneous(panGesture, pinchGesture),
-		[panGesture, pinchGesture],
-	);
+			const detectorGesture = useMemo(
+				() => Gesture.Simultaneous(panGesture, pinchGesture),
+				[panGesture, pinchGesture],
+			);
 
-	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,
+					scrollState,
+					gestureContext,
+					claimedDirections: gestureConfig.participation.claimedDirections,
+					childDirectionClaims,
+				}),
+				[
+					currentScreenKey,
+					detectorGesture,
+					panGesture,
+					pinchGesture,
+					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,