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

package/src/providers/screen/animation/animation.provider.tsx

@@ -1,11 +1,10 @@
 import { type ReactNode, useMemo } from "react";
+import type { BoundsAccessor } from "../../../types/bounds.types";
 import { createBoundsAccessor } from "../../../utils/bounds";
 import createProvider from "../../../utils/create-provider";
 import { useBlankStackStore } from "../../stack/blank-stack.provider";
 import { useDescriptorsStore } from "../descriptors";
-import { useCurrentScreenRelationships } from "../use-current-screen-relationships";
 import { useScreenAnimationPipeline } from "./helpers/pipeline";
-import type { ScreenAnimationTransitionSource } from "./types";
 
 type Props = {
 	children: ReactNode;
@@ -14,70 +13,34 @@ type Props = {
 export type ScreenAnimationContextValue = ReturnType<
 	typeof useScreenAnimationPipeline
 > & {
-	transitionSources: readonly ScreenAnimationTransitionSource[];
-	transitionOriginIndex: number;
-	transitionSourcesThroughSelf: readonly ScreenAnimationTransitionSource[];
-	transitionSourcesFromSelf: readonly ScreenAnimationTransitionSource[];
+	boundsAccessor: BoundsAccessor;
 };
 
-const EMPTY_TRANSITION_SOURCES: readonly ScreenAnimationTransitionSource[] = [];
-
-const createScreenAnimationProvider = createProvider("ScreenAnimation", {
-	global: true,
-})<Props, ScreenAnimationContextValue>;
-
 export const {
 	StoreProvider: ScreenAnimationStoreProvider,
 	ScreenAnimationProvider,
 	useOptionalScreenAnimationStore,
 	useScreenAnimationStore,
-}: ReturnType<
-	typeof createScreenAnimationProvider
-> = createScreenAnimationProvider((_props) => {
+} = createProvider("ScreenAnimation", {
+	global: true,
+})<Props, ScreenAnimationContextValue>(() => {
 	const currentScreenKey = useDescriptorsStore(
 		(store) => store.derivations.currentScreenKey,
 	);
 	const isClosing = useBlankStackStore(
 		(store) => store.scenesByKey[currentScreenKey]?.activity === "closing",
 	);
-	const relationships = useCurrentScreenRelationships();
 	const pipeline = useScreenAnimationPipeline();
 
-	const screenAnimationSource = useMemo<ScreenAnimationTransitionSource>(
-		() => ({
-			screenInterpolatorProps: pipeline.screenInterpolatorProps,
-			screenInterpolatorPropsRevision: pipeline.screenInterpolatorPropsRevision,
-			boundsAccessor: createBoundsAccessor(() => {
+	const { screenInterpolatorProps } = pipeline;
+
+	const boundsAccessor = useMemo(
+		() =>
+			createBoundsAccessor(() => {
 				"worklet";
-				return pipeline.screenInterpolatorProps.get();
+				return screenInterpolatorProps.get();
 			}),
-		}),
-		[
-			pipeline.screenInterpolatorProps,
-			pipeline.screenInterpolatorPropsRevision,
-		],
-	);
-	const ancestorSources =
-		useOptionalScreenAnimationStore(
-			relationships.parentScreenKey,
-			(store) => store.transitionSourcesThroughSelf,
-		) ?? EMPTY_TRANSITION_SOURCES;
-	const descendantSources =
-		useOptionalScreenAnimationStore(
-			relationships.activeChildScreenKey,
-			(store) => store.transitionSourcesFromSelf,
-		) ?? EMPTY_TRANSITION_SOURCES;
-	const transitionSourcesThroughSelf = useMemo(
-		() => [...ancestorSources, screenAnimationSource],
-		[ancestorSources, screenAnimationSource],
-	);
-	const transitionSourcesFromSelf = useMemo(
-		() => [screenAnimationSource, ...descendantSources],
-		[screenAnimationSource, descendantSources],
-	);
-	const transitionSources = useMemo(
-		() => [...transitionSourcesThroughSelf, ...descendantSources],
-		[transitionSourcesThroughSelf, descendantSources],
+		[screenInterpolatorProps],
 	);
 
 	return {
@@ -85,10 +48,7 @@ export const {
 		unregisterOnCleanup: isClosing,
 		value: {
 			...pipeline,
-			transitionSources,
-			transitionOriginIndex: ancestorSources.length,
-			transitionSourcesThroughSelf,
-			transitionSourcesFromSelf,
+			boundsAccessor,
 		},
 	};
 });

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

@@ -34,9 +34,8 @@ export type ScreenInterpolatorFrame = Omit<
 	"bounds" | "transition"
 >;
 
-interface ScreenAnimationPipeline {
-	screenInterpolatorProps: SharedValue<ScreenInterpolatorFrame>;
-	screenInterpolatorPropsRevision: DerivedValue<number>;
+export interface ScreenAnimationPipeline {
+	screenInterpolatorProps: DerivedValue<ScreenInterpolatorFrame>;
 	selectedInterpolatorOptions: SharedValue<SelectedInterpolatorOptions>;
 	nextInterpolator: ScreenStyleInterpolator | undefined;
 	currentInterpolator: ScreenStyleInterpolator | undefined;
@@ -281,9 +280,13 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 		[routeKeys],
 	);
 
-	const currDescriptor = useDescriptorsStore((store) => store.current);
-	const nextDescriptor = useDescriptorsStore((store) => store.next);
-	const prevDescriptor = useDescriptorsStore((store) => store.previous);
+	const currDescriptor = useDescriptorsStore(
+		(store) => store.descriptors.current,
+	);
+	const nextDescriptor = useDescriptorsStore((store) => store.descriptors.next);
+	const prevDescriptor = useDescriptorsStore(
+		(store) => store.descriptors.previous,
+	);
 	const currentAnimation = useBuildTransitionState(currDescriptor);
 	const nextAnimation = useBuildTransitionState(nextDescriptor);
 	const prevAnimation = useBuildTransitionState(prevDescriptor);
@@ -306,20 +309,16 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 		[dimensions, insets, currDescriptor, nextDescriptor, prevDescriptor],
 	);
 
-	const screenInterpolatorProps = useSharedValue(initialInterpolatorProps);
 	const selectedInterpolatorOptions =
 		useSharedValue<SelectedInterpolatorOptions>({
 			owner: "current",
 		});
-
-	const propsRevisionState = useSharedValue({ value: 0 });
-	const screenInterpolatorPropsRevision = useDerivedValue<number>(() => {
-		"worklet";
-		screenInterpolatorProps.modify((frame) => {
+	const screenInterpolatorProps = useDerivedValue<ScreenInterpolatorFrame>(
+		() => {
 			"worklet";
 			const interpolatorOptions = selectedInterpolatorOptions.get();
 			return hydrateInterpolatorFrame({
-				frame,
+				frame: { ...initialInterpolatorProps },
 				dimensions,
 				insets,
 				currentAnimation,
@@ -330,25 +329,14 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 				stackProgressEntries,
 				currentRouteKey,
 			});
-		}, false);
-
-		// `screenInterpolatorProps` is mutated in place. Consumers read this
-		// revision first so Reanimated subscribes to the hydrated frame.
-		propsRevisionState.modify((revision) => {
-			"worklet";
-			revision.value += 1;
-			return revision;
-		}, false);
-
-		return propsRevisionState.get().value;
-	});
+		},
+	);
 
 	const nextInterpolator = nextDescriptor?.options.screenStyleInterpolator;
 	const currentInterpolator = currDescriptor.options.screenStyleInterpolator;
 
 	return {
 		screenInterpolatorProps,
-		screenInterpolatorPropsRevision,
 		selectedInterpolatorOptions,
 		nextInterpolator,
 		currentInterpolator,

package/src/providers/screen/animation/types.ts

@@ -1,14 +1,3 @@
-import type { SharedValue } from "react-native-reanimated";
 import type { ScreenTransitionTarget } from "../../../types/animation.types";
-import type { BoundsAccessor } from "../../../types/bounds.types";
-import type { ScreenInterpolatorFrame } from "./helpers/pipeline";
-
-export type ScreenInterpolatorPropsRevision = Pick<SharedValue<number>, "get">;
 
 export type ScreenAnimationTarget = ScreenTransitionTarget;
-
-export type ScreenAnimationTransitionSource = {
-	screenInterpolatorProps: SharedValue<ScreenInterpolatorFrame>;
-	screenInterpolatorPropsRevision: ScreenInterpolatorPropsRevision;
-	boundsAccessor: BoundsAccessor;
-};

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

@@ -3,9 +3,12 @@ import type {
 	ScreenInterpolationProps,
 	ScreenTransitionTarget,
 } from "../../../types/animation.types";
-import { useScreenAnimationStore } from "./animation.provider";
-import { useBuildTransitionAccessor } from "./helpers/accessors/use-build-transition-accessor";
-import { readScreenAnimationRevisions } from "./helpers/read-screen-animation-revisions";
+import { useOptionalDescriptorsStore } from "../descriptors";
+import { useResolvedTransitionKey } from "../topology";
+import {
+	useOptionalScreenAnimationStore,
+	useScreenAnimationStore,
+} from "./animation.provider";
 import type { ScreenAnimationTarget } from "./types";
 
 export type { ScreenAnimationTarget } from "./types";
@@ -22,16 +25,45 @@ export function useScreenAnimation(
 ):
 	| DerivedValue<ScreenInterpolationProps>
 	| DerivedValue<ScreenInterpolationProps | null> {
-	const screenAnimationStore = useScreenAnimationStore();
+	const currentKey = useOptionalDescriptorsStore(
+		(store) => store?.derivations.currentScreenKey ?? null,
+	);
 
-	const { transitionSources } = screenAnimationStore;
-	const transition = useBuildTransitionAccessor(screenAnimationStore);
-	const transitionTarget = target;
+	const localInterpolatorProps = useScreenAnimationStore(
+		(store) => store.screenInterpolatorProps,
+	);
+	const localBoundsAccessor = useScreenAnimationStore(
+		(store) => store.boundsAccessor,
+	);
+
+	const usesLocalStore =
+		target === undefined || (typeof target === "object" && target.depth === 0);
+
+	const screenKey = useResolvedTransitionKey(currentKey, target);
+
+	const keyedInterpolatorProps = useOptionalScreenAnimationStore(
+		usesLocalStore ? null : screenKey,
+		(store) => store.screenInterpolatorProps,
+	);
+	const keyedBoundsAccessor = useOptionalScreenAnimationStore(
+		usesLocalStore ? null : screenKey,
+		(store) => store.boundsAccessor,
+	);
+
+	const screenInterpolatorProps = usesLocalStore
+		? localInterpolatorProps
+		: keyedInterpolatorProps;
+	const boundsAccessor = usesLocalStore
+		? localBoundsAccessor
+		: keyedBoundsAccessor;
 
 	const animation = useDerivedValue<ScreenInterpolationProps | null>(() => {
-		"worklet";
-		readScreenAnimationRevisions(transitionSources);
-		return transition(transitionTarget);
+		if (!screenInterpolatorProps || !boundsAccessor) return null;
+
+		return {
+			...screenInterpolatorProps.get(),
+			bounds: boundsAccessor,
+		};
 	});
 
 	return animation;

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

@@ -1,17 +1,11 @@
 import type { ReactNode } from "react";
-import { useLayoutEffect, useMemo } from "react";
-import { screenTopology } from "../../../factories/screen-topology";
-import { useBlankStackStore } from "../../../providers/stack/blank-stack.provider";
+import { useMemo } from "react";
 import type { BaseStackDescriptor } from "../../../types/stack.types";
 import createProvider from "../../../utils/create-provider";
+import { useBlankStackStore } from "../../stack/blank-stack.provider";
 import type { DescriptorDerivations } from "./helpers/derive-descriptor-derivations";
 import { deriveDescriptorDerivations } from "./helpers/derive-descriptor-derivations";
 
-/**
- * Base descriptor interface - minimal contract for all stack types.
- * This allows stack implementations to work with the shared providers without
- * tight coupling to React Navigation.
- */
 export type BaseDescriptor = BaseStackDescriptor;
 
 export interface DescriptorsContextValue {
@@ -22,7 +16,7 @@ export interface DescriptorsContextValue {
 
 export type DescriptorDerivationsContextValue = DescriptorDerivations;
 
-interface DescriptorStoreValue extends DescriptorsContextValue {
+interface DescriptorStoreValue {
 	descriptors: DescriptorsContextValue;
 	derivations: DescriptorDerivationsContextValue;
 	options: BaseDescriptor["options"];
@@ -30,106 +24,56 @@ interface DescriptorStoreValue extends DescriptorsContextValue {
 
 type DescriptorsProviderProps = {
 	children: ReactNode;
-	previous?: BaseDescriptor;
-	current?: BaseDescriptor;
-	next?: BaseDescriptor;
-	routeKey?: string;
+	routeKey: string;
 };
 
-const createDescriptorsProvider = createProvider("Descriptors", {
-	global: true,
-})<DescriptorsProviderProps, DescriptorStoreValue>;
-
 const {
 	DescriptorsProvider,
 	useDescriptorsStore,
 	useOptionalDescriptorsStore,
-}: ReturnType<typeof createDescriptorsProvider> = createDescriptorsProvider(
-	({ previous, current, next, routeKey, children }) => {
-		const parentScreenKey = useOptionalDescriptorsStore(
-			(store) => store?.derivations.currentScreenKey,
-		);
-		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 blankStackFocusedScene = useBlankStackStore(
-			(store) => store.scenes[store.focusedIndex],
-		);
-		const resolvedCurrent = current ?? blankStackCurrent;
-		const resolvedPrevious = previous ?? blankStackPrevious;
-		const resolvedNext = next ?? blankStackNext;
-		const currentScreenKey = current?.route.key ?? routeKey;
-		const focusedScene = blankStackFocusedScene;
-		const isActiveScreen =
-			focusedScene?.route.key === currentScreenKey &&
-			focusedScene?.activity === "active";
-
-		if (!resolvedCurrent) {
-			throw new Error(
-				`Descriptors scene "${routeKey ?? "unknown"}" was not found.`,
-			);
-		}
-
-		const descriptors = useMemo(
-			() => ({
-				previous: resolvedPrevious,
-				current: resolvedCurrent,
-				next: resolvedNext,
-			}),
-			[resolvedPrevious, resolvedCurrent, resolvedNext],
-		);
-
-		const derivations = useMemo(
-			() =>
-				deriveDescriptorDerivations({
-					previous: resolvedPrevious,
-					current: resolvedCurrent,
-					next: resolvedNext,
-				}),
-			[resolvedPrevious, resolvedCurrent, resolvedNext],
-		);
-
-		useLayoutEffect(() => {
-			screenTopology.register({
-				screenKey: derivations.currentScreenKey,
-				parentScreenKey,
-			});
+} = createProvider("Descriptors", {
+	global: true,
+})<DescriptorsProviderProps, DescriptorStoreValue>(({ routeKey, children }) => {
+	const scene = useBlankStackStore((s) => s.scenesByKey[routeKey]);
 
-			return () => {
-				screenTopology.unregister(derivations.currentScreenKey);
-			};
-		}, [derivations.currentScreenKey, parentScreenKey]);
+	const currentDescriptor = scene.descriptor;
+	const previousDescriptor = scene.previousDescriptor;
+	const nextDescriptor = scene.nextDescriptor;
+	const options = scene.descriptor.options;
 
-		useLayoutEffect(() => {
-			if (!isActiveScreen || !parentScreenKey) {
-				return;
-			}
+	const descriptors = useMemo(() => {
+		return {
+			previous: previousDescriptor,
+			current: currentDescriptor,
+			next: nextDescriptor,
+		};
+	}, [previousDescriptor, currentDescriptor, nextDescriptor]);
 
-			return screenTopology.activate({
-				screenKey: derivations.currentScreenKey,
-				parentScreenKey,
-			});
-		}, [isActiveScreen, derivations.currentScreenKey, parentScreenKey]);
+	const derivations = useMemo(() => {
+		return deriveDescriptorDerivations({
+			previous: previousDescriptor,
+			current: currentDescriptor,
+			next: nextDescriptor,
+		});
+	}, [previousDescriptor, currentDescriptor, nextDescriptor]);
 
+	const value = useMemo(() => {
 		return {
-			key: derivations.currentScreenKey,
-			value: {
-				previous: resolvedPrevious,
-				current: resolvedCurrent,
-				next: resolvedNext,
-				descriptors,
-				derivations,
-				options: resolvedCurrent.options,
-			},
-			children,
+			descriptors,
+			derivations,
+			options,
 		};
-	},
-);
+	}, [descriptors, derivations, options]);
+
+	return {
+		key: routeKey,
+		value,
+		children,
+	};
+});
 
-export { DescriptorsProvider, useDescriptorsStore };
+export {
+	DescriptorsProvider,
+	useDescriptorsStore,
+	useOptionalDescriptorsStore,
+};

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

@@ -2,4 +2,5 @@ export {
 	type BaseDescriptor,
 	DescriptorsProvider,
 	useDescriptorsStore,
+	useOptionalDescriptorsStore,
 } from "./descriptors.provider";

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

@@ -1,19 +1,17 @@
-import { Fragment, useMemo } from "react";
+import { useMemo } from "react";
 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 { useDescriptorsStore } from "../descriptors";
-import { useCurrentScreenRelationships } from "../use-current-screen-relationships";
 import { useScreenGestureConfig } from "./hooks/use-screen-gesture-config";
-import { GestureOwnershipBridge } from "./ownership/gesture-ownership-bridge";
+import { useRegisterGestureOwnership } from "./ownership/use-register-gesture-ownership";
 import { useBuildPanGesture } from "./pan/use-build-pan-gesture";
 import { useBuildPinchGesture } from "./pinch/use-build-pinch-gesture";
 import {
-	type DirectionClaimMap,
 	type GestureCompositionOwner,
 	type GestureContextType,
-	NO_DIRECTION_CLAIMS,
+	NO_GESTURE_OWNERS,
 	type ScreenGestureSource,
 } from "./types";
 
@@ -21,15 +19,9 @@ interface ScreenGestureProviderProps {
 	children: React.ReactNode;
 }
 
-type ScreenGestureStoreValue = GestureContextType & {
-	relationshipGestureSources: readonly ScreenGestureSource[];
-};
-
-const EMPTY_GESTURE_SOURCES: readonly ScreenGestureSource[] = [];
-
 const createScreenGestureProvider = createProvider("ScreenGesture", {
 	global: true,
-})<ScreenGestureProviderProps, ScreenGestureStoreValue>;
+})<ScreenGestureProviderProps, GestureContextType>;
 
 export const {
 	ScreenGestureProvider,
@@ -40,28 +32,15 @@ export const {
 		const currentScreenKey = useDescriptorsStore(
 			(store) => store.derivations.currentScreenKey,
 		);
-		const isTopMostScreen = useDescriptorsStore(
-			(store) => store.derivations.isTopMostScreen,
-		);
-		const relationships = useCurrentScreenRelationships();
-		const relationshipAncestorGestures =
-			useOptionalScreenGestureStore(
-				relationships.parentScreenKey,
-				(store) => store.relationshipGestureSources,
-			) ?? EMPTY_GESTURE_SOURCES;
-		const ancestorGestures = isTopMostScreen
-			? relationshipAncestorGestures
-			: EMPTY_GESTURE_SOURCES;
-		const gestureConfig = useScreenGestureConfig(ancestorGestures);
+		const gestureConfig = useScreenGestureConfig();
 		const scrollState = ScrollStore.getValue(currentScreenKey, "coordination");
-		const childDirectionClaims =
-			useSharedValue<DirectionClaimMap>(NO_DIRECTION_CLAIMS);
+		const gestureOwners = useSharedValue({ ...NO_GESTURE_OWNERS });
 		const gestureCompositionOwner =
 			useSharedValue<GestureCompositionOwner>(null);
 		const panGesture = useBuildPanGesture({
 			scrollState,
 			gestureConfig,
-			childDirectionClaims,
+			gestureOwners,
 			gestureCompositionOwner,
 		});
 		const pinchGesture = useBuildPinchGesture({
@@ -79,8 +58,6 @@ export const {
 				panGesture,
 				pinchGesture,
 				scrollState,
-				claimedDirections: gestureConfig.participation.claimedDirections,
-				childDirectionClaims,
 			}),
 			[
 				currentScreenKey,
@@ -88,36 +65,18 @@ export const {
 				panGesture,
 				pinchGesture,
 				scrollState,
-				gestureConfig.participation.claimedDirections,
-				childDirectionClaims,
 			],
 		);
-		const relationshipGestureSources = useMemo(
-			() => [source, ...ancestorGestures],
-			[source, ancestorGestures],
-		);
-		const value = useMemo<ScreenGestureStoreValue>(
-			() => ({
-				...source,
-				ancestorGestures,
-				relationshipGestureSources,
-			}),
-			[source, ancestorGestures, relationshipGestureSources],
-		);
-		const content = useMemo(
-			() => (
-				<Fragment>
-					<GestureOwnershipBridge />
-					{children}
-				</Fragment>
-			),
-			[children],
-		);
+		useRegisterGestureOwnership({
+			claimedDirections: gestureConfig.participation.claimedDirections,
+			owners: gestureOwners,
+			source,
+		});
 
 		return {
 			key: currentScreenKey,
-			value,
-			children: content,
+			value: source,
+			children,
 		};
 	},
 );

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

@@ -1,11 +1,9 @@
 import { useMemo } from "react";
 import { useDescriptorsStore } from "../../descriptors";
 import { resolveScreenGestureConfig } from "../shared/policy";
-import type { ScreenGestureConfig, ScreenGestureSource } from "../types";
+import type { ScreenGestureConfig } from "../types";
 
-export function useScreenGestureConfig(
-	ancestorGestures: readonly ScreenGestureSource[],
-): ScreenGestureConfig {
+export function useScreenGestureConfig(): ScreenGestureConfig {
 	const options = useDescriptorsStore((store) => store.options);
 	const isFirstKey = useDescriptorsStore(
 		(store) => store.derivations.isFirstKey,
@@ -15,8 +13,7 @@ export function useScreenGestureConfig(
 			resolveScreenGestureConfig({
 				options,
 				isFirstKey,
-				ancestorGestures,
 			}),
-		[isFirstKey, options, ancestorGestures],
+		[isFirstKey, options],
 	);
 }

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

@@ -1,10 +1,7 @@
-import {
-	type ChainTarget,
-	resolveChainTarget,
-} from "../../../../utils/resolve-chain-target";
+import { useResolvedTransitionKey } from "../../topology";
 import { useOptionalScreenGestureStore } from "../gestures.provider";
 
-export type ScreenGestureTarget = ChainTarget;
+export type ScreenGestureTarget = { depth: number };
 
 /**
  * Returns a screen navigation pan gesture.
@@ -20,13 +17,16 @@ export type ScreenGestureTarget = ChainTarget;
  * ```
  */
 export const useScreenGesture = (target?: ScreenGestureTarget) => {
-	const ctx = useOptionalScreenGestureStore();
-
-	return (
-		resolveChainTarget({
-			target,
-			self: ctx,
-			ancestors: ctx?.ancestorGestures ?? [],
-		})?.panGesture ?? null
+	const localGesture = useOptionalScreenGestureStore();
+	const usesLocalStore = target === undefined || target.depth === 0;
+	const screenKey = useResolvedTransitionKey(
+		localGesture?.routeKey ?? null,
+		target,
+	);
+	const keyedGesture = useOptionalScreenGestureStore(
+		usesLocalStore ? null : screenKey,
+		(store) => store.panGesture,
 	);
+
+	return usesLocalStore ? (localGesture?.panGesture ?? null) : keyedGesture;
 };

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

@@ -4,8 +4,6 @@ export {
 	useScreenGestureStore,
 } from "./gestures.provider";
 export type {
-	DirectionClaim,
-	DirectionClaimMap,
 	GestureContextType,
 	ScrollGestureAxis,
 	ScrollGestureAxisState,