react-native-screen-transitions 3.4.0-rc.1 → 3.5.0-beta.0

package/src/shared/components/screen-container/hooks/use-content-layout.ts

@@ -6,8 +6,10 @@ import {
 	useDescriptors,
 } from "../../../providers/screen/descriptors";
 import { AnimationStore } from "../../../stores/animation.store";
-import { SystemStore } from "../../../stores/system.store";
-import { animateToProgress } from "../../../utils/animation/animate-to-progress";
+import {
+	LifecycleTransitionRequestKind,
+	SystemStore,
+} from "../../../stores/system.store";
 
 export function useContentLayout() {
 	const { current } = useDescriptors();
@@ -15,11 +17,14 @@ export function useContentLayout() {
 	const { height: screenHeight } = useWindowDimensions();
 	const routeKey = current.route.key;
 	const animations = AnimationStore.getBag(routeKey);
+	const system = SystemStore.getBag(routeKey);
+
 	const { targetProgress, resolvedAutoSnapPoint, measuredContentLayout } =
-		SystemStore.getBag(routeKey);
+		system;
+	const { requestLifecycleTransition } = system.actions;
+
 	const experimental_animateOnInitialMount =
 		current.options.experimental_animateOnInitialMount;
-	const transitionSpec = current.options.transitionSpec;
 
 	return useCallback(
 		(event: LayoutChangeEvent) => {
@@ -52,12 +57,10 @@ export function useContentLayout() {
 					return;
 				}
 
-				animateToProgress({
-					target: nextFraction,
-					spec: transitionSpec,
-					animations,
-					targetProgress,
-				});
+				requestLifecycleTransition(
+					LifecycleTransitionRequestKind.Open,
+					nextFraction,
+				);
 			})(width, height, fraction);
 		},
 		[
@@ -68,7 +71,7 @@ export function useContentLayout() {
 			isFirstKey,
 			screenHeight,
 			experimental_animateOnInitialMount,
-			transitionSpec,
+			requestLifecycleTransition,
 		],
 	);
 }

package/src/shared/components/screen-container/layers/backdrop.tsx

@@ -24,7 +24,7 @@ export const BackdropLayer = memo(function BackdropLayer({
 	backdropBehavior: BackdropBehavior;
 	isBackdropActive: boolean;
 }) {
-	const { layerStylesMap } = useScreenStyles();
+	const { stylesMap } = useScreenStyles();
 	const { current } = useDescriptors();
 	const { dismissScreen } = useNavigationHelpers();
 
@@ -108,12 +108,12 @@ export const BackdropLayer = memo(function BackdropLayer({
 
 	const animatedBackdropStyle = useAnimatedStyle(() => {
 		"worklet";
-		return layerStylesMap.value.backdrop?.style ?? NO_STYLES;
+		return stylesMap.get().backdrop?.style ?? NO_STYLES;
 	});
 
 	const animatedBackdropProps = useAnimatedProps(() => {
 		"worklet";
-		return layerStylesMap.value.backdrop?.props ?? NO_PROPS;
+		return stylesMap.get().backdrop?.props ?? NO_PROPS;
 	});
 
 	return (

package/src/shared/components/screen-container/layers/content.tsx

@@ -10,7 +10,6 @@ import { NO_PROPS, NO_STYLES } from "../../../constants";
 import { useGestureContext } from "../../../providers/gestures";
 import { useDescriptors } from "../../../providers/screen/descriptors";
 import { useScreenStyles } from "../../../providers/screen/styles";
-import { resolveNavigationMaskEnabled } from "../../../utils/resolve-screen-transition-options";
 import { useContentLayout } from "../hooks/use-content-layout";
 import { MaybeMaskedNavigationContainer } from "./maybe-masked-navigation-container";
 import { SurfaceContainer } from "./surface-container";
@@ -23,13 +22,11 @@ type Props = {
 
 export const ContentLayer = memo(
 	({ children, pointerEvents, isBackdropActive }: Props) => {
-		const { layerStylesMap } = useScreenStyles();
+		const { stylesMap } = useScreenStyles();
 		const { current } = useDescriptors();
 
 		const gestureContext = useGestureContext();
-		const isNavigationMaskEnabled = resolveNavigationMaskEnabled(
-			current.options,
-		);
+		const isNavigationMaskEnabled = !!current.options.navigationMaskEnabled;
 		const contentPointerEvents = isBackdropActive ? "box-none" : pointerEvents;
 
 		const hasAutoSnapPoint =
@@ -39,12 +36,12 @@ export const ContentLayer = memo(
 
 		const animatedContentStyle = useAnimatedStyle(() => {
 			"worklet";
-			return layerStylesMap.value.content?.style || NO_STYLES;
+			return stylesMap.get().content?.style || NO_STYLES;
 		});
 
 		const animatedContentProps = useAnimatedProps(() => {
 			"worklet";
-			return layerStylesMap.value.content?.props ?? NO_PROPS;
+			return stylesMap.get().content?.props ?? NO_PROPS;
 		});
 
 		return (

package/src/shared/components/screen-container/layers/maybe-masked-navigation-container.tsx

@@ -27,21 +27,19 @@ let hasWarnedMissingMaskedView = false;
 
 export const MaybeMaskedNavigationContainer = memo(
 	({ enabled, children, pointerEvents }: Props) => {
-		const { layerStylesMap } = useScreenStyles();
+		const { stylesMap } = useScreenStyles();
 
 		const animatedNavigationMaskStyle = useAnimatedStyle(() => {
 			"worklet";
 			return (
-				layerStylesMap.value[NAVIGATION_MASK_ELEMENT_STYLE_ID]?.style ||
-				NO_STYLES
+				stylesMap.get()[NAVIGATION_MASK_ELEMENT_STYLE_ID]?.style || NO_STYLES
 			);
 		});
 
 		const animatedNavigationMaskContainerStyle = useAnimatedStyle(() => {
 			"worklet";
 			return (
-				layerStylesMap.value[NAVIGATION_MASK_CONTAINER_STYLE_ID]?.style ||
-				NO_STYLES
+				stylesMap.get()[NAVIGATION_MASK_CONTAINER_STYLE_ID]?.style || NO_STYLES
 			);
 		});
 

package/src/shared/components/screen-container/layers/surface-container.tsx

@@ -14,7 +14,7 @@ type Props = {
 };
 
 export const SurfaceContainer = memo(({ children, pointerEvents }: Props) => {
-	const { layerStylesMap } = useScreenStyles();
+	const { stylesMap } = useScreenStyles();
 	const { current } = useDescriptors();
 
 	const SurfaceComponent = current.options.surfaceComponent;
@@ -27,12 +27,12 @@ export const SurfaceContainer = memo(({ children, pointerEvents }: Props) => {
 
 	const animatedSurfaceStyle = useAnimatedStyle(() => {
 		"worklet";
-		return layerStylesMap.value.surface?.style ?? NO_STYLES;
+		return stylesMap.get().surface?.style ?? NO_STYLES;
 	});
 
 	const animatedSurfaceProps = useAnimatedProps(() => {
 		"worklet";
-		return layerStylesMap.value.surface?.props ?? NO_PROPS;
+		return stylesMap.get().surface?.props ?? NO_PROPS;
 	});
 
 	if (!AnimatedSurfaceComponent) return children;

package/src/shared/components/screen-lifecycle/hooks/helpers/reset-stores-for-screen.ts

@@ -0,0 +1,29 @@
+import { runOnUI } from "react-native-reanimated";
+import { AnimationStore } from "../../../../stores/animation.store";
+import { BoundStore } from "../../../../stores/bounds";
+import { GestureStore } from "../../../../stores/gesture.store";
+import { SystemStore } from "../../../../stores/system.store";
+
+export function resetStoresForScreen(
+	routeKey: string,
+	isBranchScreen: boolean,
+	branchNavigatorKey?: string,
+) {
+	AnimationStore.clearBag(routeKey);
+	GestureStore.clearBag(routeKey);
+	SystemStore.clearBag(routeKey);
+
+	runOnUI(() => {
+		"worklet";
+		if (!isBranchScreen) return;
+
+		BoundStore.cleanup.byScreen(routeKey);
+
+		if (branchNavigatorKey) {
+			BoundStore.cleanup.byBranch(branchNavigatorKey);
+			return;
+		}
+
+		BoundStore.cleanup.byAncestor(routeKey);
+	})();
+}

package/src/shared/components/screen-lifecycle/hooks/{use-screen-events.ts → history/use-screen-history.ts}

@@ -1,9 +1,13 @@
 import { useEffect } from "react";
 import { runOnJS, useAnimatedReaction } from "react-native-reanimated";
-import useStableCallback from "../../../hooks/use-stable-callback";
-import type { BaseDescriptor } from "../../../providers/screen/descriptors";
-import type { AnimationStoreMap } from "../../../stores/animation.store";
-import { HistoryStore } from "../../../stores/history.store";
+import useStableCallback from "../../../../hooks/use-stable-callback";
+import type { BaseDescriptor } from "../../../../providers/screen/descriptors";
+import type { AnimationStoreMap } from "../../../../stores/animation.store";
+import { HistoryStore } from "../../../../stores/history.store";
+import {
+	registerMountedRoute,
+	unregisterMountedRoute,
+} from "./navigator-route-registry";
 
 function hasSnapPoints(descriptor: BaseDescriptor): boolean {
 	const snapPoints = descriptor.options?.snapPoints;
@@ -27,24 +31,37 @@ function shouldTrackInHistory(descriptor: BaseDescriptor): boolean {
 }
 
 /**
- * Updates the HistoryStore for navigation history tracking.
+ * Keeps navigator route registration and screen history in sync.
  */
-export function useScreenEvents(
+export function useScreenHistory(
 	current: BaseDescriptor,
 	previous: BaseDescriptor | undefined,
 	animations: AnimationStoreMap,
 ) {
 	const navigatorKey = current.navigation.getState()?.key ?? "";
+	const routeKey = current.route.key;
+
+	useEffect(() => {
+		registerMountedRoute(navigatorKey, routeKey);
+
+		return () => {
+			const shouldClearNavigator = unregisterMountedRoute(
+				navigatorKey,
+				routeKey,
+			);
+			if (shouldClearNavigator) {
+				HistoryStore.clearNavigator(navigatorKey);
+			}
+		};
+	}, [navigatorKey, routeKey]);
 
 	// Track history via focus listener - waits for nested navigators to initialize
 	// biome-ignore lint/correctness/useExhaustiveDependencies: Must only run once on mount
 	useEffect(() => {
-		// Check on mount (after paint, nested navs initialized)
 		if (shouldTrackInHistory(current)) {
 			HistoryStore.focus(current, navigatorKey);
 		}
 
-		// Also listen for focus events
 		const unsubscribe = current.navigation.addListener?.("focus", () => {
 			if (shouldTrackInHistory(current)) {
 				HistoryStore.focus(current, navigatorKey);
@@ -54,7 +71,6 @@ export function useScreenEvents(
 		return () => unsubscribe?.();
 	}, []);
 
-	// When closing starts, focus previous in history
 	const handleBlur = useStableCallback(() => {
 		if (previous && shouldTrackInHistory(previous)) {
 			const prevNavigatorKey = previous.navigation.getState()?.key ?? "";

package/src/shared/components/screen-lifecycle/hooks/use-close-transition-intent.ts

@@ -0,0 +1,160 @@
+/** biome-ignore-all lint/correctness/useHookAtTopLevel: STACK_TYPE is stable per navigator */
+import { useLayoutEffect, useMemo, useRef } from "react";
+import { useAnimatedReaction } from "react-native-reanimated";
+import useStableCallback from "../../../hooks/use-stable-callback";
+import {
+	type BaseDescriptor,
+	useDescriptorDerivations,
+} from "../../../providers/screen/descriptors";
+import { useStackCoreContext } from "../../../providers/stack/core.provider";
+import { useManagedStackContext } from "../../../providers/stack/managed.provider";
+import type { AnimationStoreMap } from "../../../stores/animation.store";
+import { GestureStore } from "../../../stores/gesture.store";
+import {
+	LifecycleTransitionRequestKind,
+	type SystemStoreActions,
+	type SystemStoreMap,
+} from "../../../stores/system.store";
+import { StackType } from "../../../types/stack.types";
+import { resetStoresForScreen } from "./helpers/reset-stores-for-screen";
+
+interface CloseHookParams {
+	current: BaseDescriptor;
+	animations: AnimationStoreMap;
+	requestLifecycleTransition: SystemStoreActions["requestLifecycleTransition"];
+	resetStores: () => void;
+}
+
+/**
+ * Managed close - reacts to closingRouteKeysShared from ManagedStackContext.
+ * Used by blank-stack and component-stack.
+ */
+const useManagedClose = ({
+	current,
+	requestLifecycleTransition,
+	resetStores,
+}: CloseHookParams) => {
+	const { handleCloseRoute, closingRouteKeysShared } = useManagedStackContext();
+	const routeKey = current.route.key;
+
+	const handleManagedCloseEnd = useStableCallback((finished: boolean) => {
+		if (!finished) return;
+		handleCloseRoute({ route: current.route });
+		requestAnimationFrame(() => {
+			resetStores();
+		});
+	});
+
+	useAnimatedReaction(
+		() => {
+			const keys = closingRouteKeysShared.value;
+			return keys?.includes(routeKey) ?? false;
+		},
+		(isClosing, wasClosing) => {
+			if (!isClosing || wasClosing) return;
+
+			requestLifecycleTransition(
+				LifecycleTransitionRequestKind.ManagedClose,
+				0,
+			);
+		},
+	);
+
+	return { handleManagedCloseEnd };
+};
+
+/**
+ * Native stack close - listens to beforeRemove navigation event.
+ */
+const useNativeStackClose = ({
+	current,
+	animations,
+	requestLifecycleTransition,
+	resetStores,
+}: CloseHookParams) => {
+	const { parentScreenKey } = useDescriptorDerivations();
+	const pendingActionRef = useRef<any>(null);
+
+	const nearestAncestorDismissing = useMemo(() => {
+		if (!parentScreenKey) return null;
+
+		return GestureStore.peekBag(parentScreenKey)?.dismissing ?? null;
+	}, [parentScreenKey]);
+
+	const handleNativeCloseEnd = useStableCallback((finished: boolean) => {
+		if (!finished || !pendingActionRef.current) {
+			pendingActionRef.current = null;
+			return;
+		}
+
+		current.navigation.dispatch(pendingActionRef.current);
+		pendingActionRef.current = null;
+		requestAnimationFrame(() => {
+			resetStores();
+		});
+	});
+
+	const handleBeforeRemove = useStableCallback((e: any) => {
+		const options = current.options as { enableTransitions?: boolean };
+		const isEnabled = options.enableTransitions;
+		const navigation = current.navigation;
+		const routeKey = current.route.key;
+		const state = navigation.getState();
+		const routeIndex = state.routes.findIndex(
+			(route) => route.key === routeKey,
+		);
+		const isFirstScreen = routeIndex <= 0;
+
+		if (!isEnabled || nearestAncestorDismissing?.get() || isFirstScreen) {
+			animations.closing.set(1);
+			resetStores();
+			return;
+		}
+
+		e.preventDefault();
+		pendingActionRef.current = e.data.action;
+		requestLifecycleTransition(LifecycleTransitionRequestKind.NativeClose, 0);
+	});
+
+	// biome-ignore lint/correctness/useExhaustiveDependencies: navigation listener should only rebind when the navigator instance changes
+	useLayoutEffect(() => {
+		return current.navigation.addListener?.("beforeRemove", handleBeforeRemove);
+	}, [current.navigation]);
+
+	return { handleNativeCloseEnd };
+};
+
+/**
+ * Handles close transition intent and returns finish callbacks for cleanup.
+ */
+export function useCloseTransitionIntent(
+	current: BaseDescriptor,
+	animations: AnimationStoreMap,
+	system: SystemStoreMap,
+): {
+	handleManagedCloseEnd?: (finished: boolean) => void;
+	handleNativeCloseEnd?: (finished: boolean) => void;
+} {
+	const routeKey = current.route.key;
+	const { flags } = useStackCoreContext();
+	const { isBranchScreen, branchNavigatorKey } = useDescriptorDerivations();
+	const isNativeStack = flags.STACK_TYPE === StackType.NATIVE;
+	const { requestLifecycleTransition } = system.actions;
+
+	const resetStores = useStableCallback(() => {
+		resetStoresForScreen(routeKey, isBranchScreen, branchNavigatorKey);
+	});
+
+	const closeParams: CloseHookParams = {
+		current,
+		animations,
+		requestLifecycleTransition,
+		resetStores,
+	};
+
+	if (isNativeStack) {
+		return useNativeStackClose(closeParams);
+	}
+
+	return useManagedClose(closeParams);
+}

package/src/shared/components/screen-lifecycle/hooks/{use-open-transition.ts → use-open-transition-intent.ts}

@@ -1,10 +1,14 @@
 import { useLayoutEffect } from "react";
-import type { SharedValue } from "react-native-reanimated";
-import type { BaseDescriptor } from "../../../providers/screen/descriptors";
+import {
+	type BaseDescriptor,
+	useDescriptorDerivations,
+} from "../../../providers/screen/descriptors";
 import type { AnimationStoreMap } from "../../../stores/animation.store";
+import {
+	LifecycleTransitionRequestKind,
+	type SystemStoreMap,
+} from "../../../stores/system.store";
 import type { SnapPoint } from "../../../types/screen.types";
-import { animateToProgress } from "../../../utils/animation/animate-to-progress";
-import { useHighRefreshRate } from "./use-high-refresh-rate";
 
 /**
  * Calculates the initial progress value based on snap points configuration.
@@ -30,17 +34,15 @@ function getInitialProgress({
 }
 
 /**
- * Handles opening animation on mount.
- * Returns activate/deactivate functions for high refresh rate.
+ * Handles opening transition intent on mount.
  */
-export function useOpenTransition(
+export function useOpenTransitionIntent(
 	current: BaseDescriptor,
 	animations: AnimationStoreMap,
-	targetProgressValue: SharedValue<number>,
-	isFirstKey: boolean,
+	system: SystemStoreMap,
 ) {
-	const { activateHighRefreshRate, deactivateHighRefreshRate } =
-		useHighRefreshRate(current);
+	const { isFirstKey } = useDescriptorDerivations();
+	const { requestLifecycleTransition } = system.actions;
 
 	// biome-ignore lint/correctness/useExhaustiveDependencies: Must only run once on mount
 	useLayoutEffect(() => {
@@ -57,11 +59,11 @@ export function useOpenTransition(
 
 		if (isFirstKey && !experimental_animateOnInitialMount) {
 			if (initialProgress === "auto") {
-				targetProgressValue.set(0);
+				system.targetProgress.set(0);
 				animations.progress.set(0);
 			} else {
 				const target = initialProgress ?? 1;
-				targetProgressValue.set(target);
+				system.targetProgress.set(target);
 				animations.progress.set(target);
 			}
 			animations.animating.set(0);
@@ -76,15 +78,9 @@ export function useOpenTransition(
 			return;
 		}
 
-		activateHighRefreshRate();
-		animateToProgress({
-			target: initialProgress ?? "open",
-			spec: current.options.transitionSpec,
-			animations,
-			targetProgress: targetProgressValue,
-			onAnimationFinish: deactivateHighRefreshRate,
-		});
+		requestLifecycleTransition(
+			LifecycleTransitionRequestKind.Open,
+			initialProgress ?? 1,
+		);
 	}, []);
-
-	return { activateHighRefreshRate, deactivateHighRefreshRate };
 }

package/src/shared/components/screen-lifecycle/hooks/use-transition-start-controller.ts

@@ -0,0 +1,71 @@
+import { useAnimatedReaction } from "react-native-reanimated";
+import type { BaseDescriptor } from "../../../providers/screen/descriptors";
+import type { AnimationStoreMap } from "../../../stores/animation.store";
+import {
+	LifecycleTransitionRequestKind,
+	type SystemStoreMap,
+} from "../../../stores/system.store";
+import { animateToProgress } from "../../../utils/animation/animate-to-progress";
+
+export const useTransitionStartController = ({
+	current,
+	animations,
+	system,
+	onManagedCloseFinish,
+	onNativeCloseFinish,
+}: {
+	current: BaseDescriptor;
+	animations: AnimationStoreMap;
+	system: SystemStoreMap;
+	onManagedCloseFinish?: (finished: boolean) => void;
+	onNativeCloseFinish?: (finished: boolean) => void;
+}) => {
+	const {
+		targetProgress,
+		pendingLifecycleRequestKind,
+		pendingLifecycleRequestTarget,
+		pendingLifecycleStartBlockCount,
+	} = system;
+	const { clearLifecycleTransitionRequest } = system.actions;
+	const transitionSpec = current.options.transitionSpec;
+
+	useAnimatedReaction(
+		() => {
+			"worklet";
+			return [
+				pendingLifecycleRequestKind.get(),
+				pendingLifecycleRequestTarget.get(),
+				pendingLifecycleStartBlockCount.get(),
+			] as const;
+		},
+		(next) => {
+			"worklet";
+			const [kind, target, blockCount] = next;
+
+			if (kind === LifecycleTransitionRequestKind.None) {
+				return;
+			}
+
+			if (blockCount > 0) {
+				return;
+			}
+
+			const onAnimationFinish =
+				kind === LifecycleTransitionRequestKind.ManagedClose
+					? onManagedCloseFinish
+					: kind === LifecycleTransitionRequestKind.NativeClose
+						? onNativeCloseFinish
+						: undefined;
+
+			animateToProgress({
+				target,
+				spec: transitionSpec,
+				animations,
+				targetProgress,
+				onAnimationFinish,
+			});
+
+			clearLifecycleTransitionRequest();
+		},
+	);
+};

package/src/shared/components/screen-lifecycle/index.tsx

@@ -1,12 +1,10 @@
-import {
-	useDescriptorDerivations,
-	useDescriptors,
-} from "../../providers/screen/descriptors";
+import { useDescriptors } from "../../providers/screen/descriptors";
 import { AnimationStore } from "../../stores/animation.store";
 import { SystemStore } from "../../stores/system.store";
-import { useCloseTransition } from "./hooks/use-close-transition";
-import { useOpenTransition } from "./hooks/use-open-transition";
-import { useScreenEvents } from "./hooks/use-screen-events";
+import { useScreenHistory } from "./hooks/history/use-screen-history";
+import { useCloseTransitionIntent } from "./hooks/use-close-transition-intent";
+import { useOpenTransitionIntent } from "./hooks/use-open-transition-intent";
+import { useTransitionStartController } from "./hooks/use-transition-start-controller";
 
 interface Props {
 	children: React.ReactNode;
@@ -18,22 +16,24 @@ interface Props {
  */
 export const ScreenLifecycle = ({ children }: Props) => {
 	const { current, previous } = useDescriptors();
-	const { isFirstKey } = useDescriptorDerivations();
+
 	const animations = AnimationStore.getBag(current.route.key);
-	const { targetProgress } = SystemStore.getBag(current.route.key);
+	const system = SystemStore.getBag(current.route.key);
+
+	const { handleManagedCloseEnd, handleNativeCloseEnd } =
+		useCloseTransitionIntent(current, animations, system);
 
-	const { activateHighRefreshRate, deactivateHighRefreshRate } =
-		useOpenTransition(current, animations, targetProgress, isFirstKey);
+	useOpenTransitionIntent(current, animations, system);
 
-	useCloseTransition(
+	useTransitionStartController({
 		current,
 		animations,
-		targetProgress,
-		activateHighRefreshRate,
-		deactivateHighRefreshRate,
-	);
+		system,
+		onManagedCloseFinish: handleManagedCloseEnd,
+		onNativeCloseFinish: handleNativeCloseEnd,
+	});
 
-	useScreenEvents(current, previous, animations);
+	useScreenHistory(current, previous, animations);
 
 	return children;
 };

package/src/shared/constants.ts

@@ -25,7 +25,6 @@ export const NAVIGATION_MASK_CONTAINER_STYLE_ID =
  * Styles
  */
 export const NO_STYLES = Object.freeze({});
-export const HIDDEN_STYLE = Object.freeze({ opacity: 0 });
 export const VISIBLE_STYLE = Object.freeze({ opacity: 1 });
 export const NO_PROPS = Object.freeze({});
 
@@ -54,6 +53,7 @@ const DEFAULT_GESTURE_VALUES = {
 export const createScreenTransitionState = (
 	route: BaseStackRoute,
 	meta?: Record<string, unknown>,
+	navigationMaskEnabled = false,
 ): ScreenTransitionState => ({
 	progress: 0,
 	closing: 0,
@@ -70,6 +70,7 @@ export const createScreenTransitionState = (
 			width: 0,
 			height: 0,
 		},
+		navigationMaskEnabled,
 	},
 	snapIndex: -1,
 });
@@ -93,6 +94,7 @@ export const DEFAULT_SCREEN_TRANSITION_STATE: ScreenTransitionState =
 				width: 0,
 				height: 0,
 			},
+			navigationMaskEnabled: false,
 		},
 		snapIndex: -1,
 	});
@@ -100,16 +102,6 @@ export const DEFAULT_SCREEN_TRANSITION_STATE: ScreenTransitionState =
 /**
  * Bounds API Defaults
  */
-export const EMPTY_BOUND_HELPER_RESULT = Object.freeze({});
-export const EMPTY_BOUND_HELPER_RESULT_RAW = Object.freeze({
-	scaleX: 1,
-	scaleY: 1,
-	scale: 1,
-	translateX: 0,
-	translateY: 0,
-	width: 0,
-	height: 0,
-});
 export const TRANSFORM_RESET = Object.freeze({
 	transform: [
 		{ translateX: 0 },