react-native-screen-transitions 3.2.0 → 3.3.0-beta.0

package/src/shared/hooks/navigation/use-screen-state.tsx

@@ -1,12 +1,19 @@
 import type { Route } from "@react-navigation/native";
-import { useMemo } from "react";
-import { useDerivedValue } from "react-native-reanimated";
+import { useCallback, useMemo } from "react";
+import {
+	runOnUI,
+	type SharedValue,
+	useDerivedValue,
+} from "react-native-reanimated";
+import { DefaultSnapSpec } from "../../configs/specs";
 import {
 	type BaseDescriptor,
 	useKeys,
 } from "../../providers/screen/keys.provider";
+import { AnimationStore } from "../../stores/animation.store";
 import type { ScreenTransitionConfig } from "../../types/screen.types";
 import type { BaseStackNavigation } from "../../types/stack.types";
+import { animateToProgress } from "../../utils/animation/animate-to-progress";
 import { useSharedValueState } from "../reanimated/use-shared-value-state";
 import { type StackContextValue, useStack } from "./use-stack";
 
@@ -47,6 +54,21 @@ export interface ScreenState<
 	 * Navigation object for this screen.
 	 */
 	navigation: TNavigation;
+
+	/**
+	 * Programmatically snap to a specific snap point by index.
+	 * Only works if the screen has snapPoints defined.
+	 *
+	 * @param index - The index of the snap point to snap to (0-based)
+	 */
+	snapTo: (index: number) => void;
+
+	/**
+	 * Animated value representing the current snap point index.
+	 * Interpolates between indices during gestures (e.g., 0.5 means halfway between snap 0 and 1).
+	 * Returns -1 if no snap points are defined.
+	 */
+	animatedSnapIndex: SharedValue<number>;
 }
 
 /**
@@ -77,6 +99,84 @@ export function useScreenState<
 		return scenes[focusedIndex] ?? scenes[scenes.length - 1];
 	}, [scenes, focusedIndex]);
 
+	const currentOptions = current.options;
+	const snapPoints = currentOptions?.snapPoints;
+	const animations = useMemo(
+		() => AnimationStore.getAll(current.route.key),
+		[current.route.key],
+	);
+
+	// Pre-sort snap points for the derived value (avoids sorting in worklet)
+	const sortedSnapPoints = useMemo(
+		() => (snapPoints ? [...snapPoints].sort((a, b) => a - b) : []),
+		[snapPoints],
+	);
+
+	const animatedSnapIndex = useDerivedValue(() => {
+		if (sortedSnapPoints.length === 0) {
+			return -1;
+		}
+
+		const progress = animations.progress.value;
+
+		// Below first snap point
+		if (progress <= sortedSnapPoints[0]) {
+			return 0;
+		}
+
+		// Above last snap point
+		if (progress >= sortedSnapPoints[sortedSnapPoints.length - 1]) {
+			return sortedSnapPoints.length - 1;
+		}
+
+		// Find segment and interpolate
+		for (let i = 0; i < sortedSnapPoints.length - 1; i++) {
+			if (progress <= sortedSnapPoints[i + 1]) {
+				const t =
+					(progress - sortedSnapPoints[i]) /
+					(sortedSnapPoints[i + 1] - sortedSnapPoints[i]);
+				return i + t;
+			}
+		}
+
+		return sortedSnapPoints.length - 1;
+	});
+
+	const snapTo = useCallback(
+		(targetIndex: number) => {
+			if (!sortedSnapPoints || sortedSnapPoints.length === 0) {
+				console.warn("snapTo called but no snapPoints defined");
+				return;
+			}
+
+			if (targetIndex < 0 || targetIndex >= sortedSnapPoints.length) {
+				console.warn(
+					`snapTo index ${targetIndex} out of bounds (0-${sortedSnapPoints.length - 1})`,
+				);
+				return;
+			}
+
+			const targetProgress = sortedSnapPoints[targetIndex];
+
+			runOnUI(() => {
+				"worklet";
+				animateToProgress({
+					target: targetProgress,
+					animations,
+					spec: {
+						open:
+							focusedScene.descriptor.options.transitionSpec?.expand ??
+							DefaultSnapSpec,
+						close:
+							focusedScene.descriptor.options.transitionSpec?.collapse ??
+							DefaultSnapSpec,
+					},
+				});
+			})();
+		},
+		[sortedSnapPoints, animations, focusedScene],
+	);
+
 	return useMemo(
 		() => ({
 			index,
@@ -86,6 +186,8 @@ export function useScreenState<
 			focusedIndex,
 			meta: focusedScene?.descriptor?.options?.meta,
 			navigation: current.navigation as TNavigation,
+			snapTo,
+			animatedSnapIndex,
 		}),
 		[
 			index,
@@ -94,6 +196,8 @@ export function useScreenState<
 			focusedIndex,
 			current.navigation,
 			current.route,
+			snapTo,
+			animatedSnapIndex,
 		],
 	);
 }

package/src/shared/hooks/use-backdrop-pointer-events.ts

@@ -0,0 +1,32 @@
+import { useKeys } from "../providers/screen/keys.provider";
+import { useStackCoreContext } from "../providers/stack/core.provider";
+import { StackType } from "../types/stack.types";
+
+type BackdropBehavior = "block" | "passthrough" | "dismiss";
+
+interface BackdropPointerEventsResult {
+	pointerEvents: "box-none" | undefined;
+	backdropBehavior: BackdropBehavior;
+}
+
+/**
+ * Returns pointer events and backdrop behavior based on screen options.
+ *
+ * - Explicit `backdropBehavior` option takes precedence
+ * - Component stacks default to 'passthrough' (box-none)
+ * - Other stacks default to 'block' (undefined = normal touch handling)
+ */
+export function useBackdropPointerEvents(): BackdropPointerEventsResult {
+	const { current } = useKeys();
+	const { flags } = useStackCoreContext();
+
+	const isComponentStack = flags.STACK_TYPE === StackType.COMPONENT;
+	const backdropBehavior: BackdropBehavior =
+		current.options.backdropBehavior ??
+		(isComponentStack ? "passthrough" : "block");
+
+	const pointerEvents =
+		backdropBehavior === "passthrough" ? "box-none" : undefined;
+
+	return { pointerEvents, backdropBehavior };
+}

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

@@ -6,7 +6,7 @@ import {
 import type { SharedValue } from "react-native-reanimated";
 import { useSharedValue } from "react-native-reanimated";
 import { useBuildGestures } from "../hooks/gestures/use-build-gestures";
-import { useStackPointerEvents } from "../hooks/use-stack-pointer-events";
+import { useBackdropPointerEvents } from "../hooks/use-backdrop-pointer-events";
 import type { GestureStoreMap } from "../stores/gesture.store";
 import createProvider from "../utils/create-provider";
 import { useKeys } from "./screen/keys.provider";
@@ -18,6 +18,7 @@ export type ScrollConfig = {
 	contentWidth: number;
 	layoutHeight: number;
 	layoutWidth: number;
+	isTouched: boolean;
 };
 
 export interface GestureContextType {
@@ -42,9 +43,9 @@ export const {
 	GestureContextType
 >(({ children }) => {
 	const { current } = useKeys();
-	const pointerEvents = useStackPointerEvents();
 	const ancestorContext = useGestureContext();
 	const scrollConfig = useSharedValue<ScrollConfig | null>(null);
+	const { pointerEvents } = useBackdropPointerEvents();
 
 	const hasGestures = current.options.gestureEnabled === true;
 

package/src/shared/providers/screen/screen-composer.tsx

@@ -1,5 +1,5 @@
 import type React from "react";
-import { RootTransitionAware } from "../../components/root-transition-aware";
+import { ScreenContainer } from "../../components/screen-container";
 import { ScreenLifecycle } from "../../components/screen-lifecycle";
 import { ScreenGestureProvider } from "../gestures.provider";
 import { type BaseDescriptor, KeysProvider } from "./keys.provider";
@@ -23,7 +23,7 @@ export function ScreenComposer<TDescriptor extends BaseDescriptor>({
 			<KeysProvider previous={previous} current={current} next={next}>
 				<ScreenGestureProvider>
 					<ScreenStylesProvider>
-						<RootTransitionAware>{children}</RootTransitionAware>
+						<ScreenContainer>{children}</ScreenContainer>
 					</ScreenStylesProvider>
 				</ScreenGestureProvider>
 			</KeysProvider>

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

@@ -28,56 +28,62 @@ export function ScreenStylesProvider({ children }: Props) {
 	const { screenInterpolatorProps, nextInterpolator, currentInterpolator } =
 		_useScreenAnimation();
 
-	// Track when a gesture is triggered while another screen is closing
-	const hasTriggeredGestureWhileInFlight = useSharedValue(false);
+	/**
+	 * Tracks when user starts a gesture while another screen is still closing.
+	 * This persists until both the gesture ends AND the closing animation completes.
+	 */
+	const isGesturingDuringCloseAnimation = useSharedValue(false);
 
 	const stylesMap = useDerivedValue<TransitionInterpolatedStyle>(() => {
 		"worklet";
 		const props = screenInterpolatorProps.value;
-		const bounds = createBounds(props);
+		const { current, next, progress, stackProgress } = props;
+		const isDragging = current.gesture.isDragging;
+		const isNextClosing = !!next?.closing;
 
-		// Detect when user starts gesture on current screen while next screen is closing
-		if (props.current.gesture.isDragging && props.next?.closing) {
-			hasTriggeredGestureWhileInFlight.value = true;
+		if (isDragging && isNextClosing) {
+			isGesturingDuringCloseAnimation.value = true;
 		}
 
-		// Reset the flag when no longer dragging and next screen is done closing
-		if (
-			!props.current.gesture.isDragging &&
-			!props.next?.closing &&
-			hasTriggeredGestureWhileInFlight.value
-		) {
-			hasTriggeredGestureWhileInFlight.value = false;
+		if (!isDragging && !isNextClosing) {
+			isGesturingDuringCloseAnimation.value = false;
 		}
 
-		// Use current interpolator when gesture triggered while in-flight,
-		// otherwise use next interpolator if available (normal case)
-		const shouldUseCurrentInterpolator =
-			props.current.gesture.isDragging ||
-			hasTriggeredGestureWhileInFlight.value;
+		const isInGestureMode = isDragging || isGesturingDuringCloseAnimation.value;
 
-		const interpolator = shouldUseCurrentInterpolator
+		const hasPushedScreenWhileClosing =
+			!isInGestureMode && isNextClosing && stackProgress > progress;
+
+		// Select interpolator
+		//  - If in gesture mode, use current screen's interpolator since we're driving
+		//    the animation from this screen (dragging back to dismiss next).
+		const interpolator = isInGestureMode
 			? currentInterpolator
 			: (nextInterpolator ?? currentInterpolator);
 
-		/**
-		 * Maintainer Note:
-		 * To avoid unnecessary jumps in off directions, we have to snap back to the currents progress.
-		 * While this still introduces a 'snap back' animation, it's still very rare that a user would encounter this unless
-		 * they're spamming things out. Not ideal, but this is the best way to go about dealing with fast rapid gestures.
-		 *
-		 * The alternative was preventing users from actually being able to drag back while animation was still in flight. But there was a significant delay
-		 * when waiting for gestures to register again.
-		 */
-		const effectiveProps = shouldUseCurrentInterpolator
-			? { ...props, progress: props.current.progress, next: undefined }
-			: props;
+		if (!interpolator) return NO_STYLES;
+
+		// Build effective props with corrected progress
+		//  - Gesture mode: use current.progress only (avoids jumps during drag)
+		//  - Pushed while closing: use stackProgress (includes new screen)
+		//  - Normal: use derived progress as-is
+
+		let effectiveProgress = progress;
+		let effectiveNext = next;
+
+		if (isInGestureMode) {
+			effectiveProgress = current.progress;
+			effectiveNext = undefined;
+		} else if (hasPushedScreenWhileClosing) {
+			effectiveProgress = stackProgress;
+		}
 
 		try {
-			if (!interpolator) return NO_STYLES;
 			return interpolator({
-				...effectiveProps,
-				bounds,
+				...props,
+				progress: effectiveProgress,
+				next: effectiveNext,
+				bounds: createBounds(props),
 			});
 		} catch (err) {
 			if (__DEV__) {

package/src/shared/types/animation.types.ts

@@ -182,7 +182,18 @@ export type TransitionInterpolatedStyle = {
 	contentStyle?: StyleProps;
 
 	/**
-	 * Animated style for a semi-transparent overlay. Styles are only applied when Transition.View is present.
+	 * Animated style for the semi-transparent backdrop layer behind screen content.
+	 *
+	 * @example
+	 * backdropStyle: {
+	 *   backgroundColor: "black",
+	 *   opacity: interpolate(progress, [0, 1], [0, 0.5]),
+	 * }
+	 */
+	backdropStyle?: StyleProps;
+
+	/**
+	 * @deprecated Use `backdropStyle` instead. Will be removed in next major version.
 	 */
 	overlayStyle?: StyleProps;
 
@@ -198,9 +209,25 @@ export type TransitionInterpolatedStyle = {
 export type AnimationConfig = WithSpringConfig | WithTimingConfig;
 
 /**
- * Defines separate animation configurations for opening and closing a screen.
+ * Defines separate animation configurations for screen transitions and snap point changes.
  */
 export interface TransitionSpec {
+	/**
+	 * Animation config for opening/entering a screen.
+	 */
 	open?: AnimationConfig;
+	/**
+	 * Animation config for closing/exiting a screen.
+	 */
 	close?: AnimationConfig;
+	/**
+	 * Animation config for expanding to a higher snap point.
+	 * Uses lower intensity than `open` to match smaller movement distances.
+	 */
+	expand?: AnimationConfig;
+	/**
+	 * Animation config for collapsing to a lower snap point.
+	 * Uses lower intensity than `close` to match smaller movement distances.
+	 */
+	collapse?: AnimationConfig;
 }

package/src/shared/types/screen.types.ts

@@ -136,4 +136,33 @@ export type ScreenTransitionConfig = {
 	 * @default false
 	 */
 	experimental_enableHighRefreshRate?: boolean;
+
+	/**
+	 * Describes heights where a screen can rest, as fractions of screen height.
+	 * Pass an array of ascending values from 0 to 1.
+	 *
+	 * @example
+	 * snapPoints={[0.5, 1.0]} // 50% and 100% of screen height
+	 *
+	 * @default [1.0]
+	 */
+	snapPoints?: number[];
+
+	/**
+	 * The initial snap point index when the screen opens.
+	 *
+	 * @default 0
+	 */
+	initialSnapIndex?: number;
+
+	/**
+	 * Controls how touches interact with the backdrop area (outside the screen content).
+	 *
+	 * - `'block'`: Backdrop catches all touches (default for most screens)
+	 * - `'passthrough'`: Touches pass through to content behind (default for component stacks)
+	 * - `'dismiss'`: Tapping backdrop dismisses the screen
+	 *
+	 * @default 'block' (or 'passthrough' for component stacks)
+	 */
+	backdropBehavior?: "block" | "passthrough" | "dismiss";
 };

package/src/shared/utils/animation/{start-screen-transition.ts → animate-to-progress.ts}

@@ -4,8 +4,14 @@ import type { AnimationStoreMap } from "../../stores/animation.store";
 import type { TransitionSpec } from "../../types/animation.types";
 import { animate } from "./animate";
 
-interface StartScreenTransitionProps {
-	target: "open" | "close";
+interface AnimateToProgressProps {
+	/**
+	 * Target for the animation:
+	 * - "open" = animate to progress 1
+	 * - "close" = animate to progress 0
+	 * - number = animate to specific progress value (e.g., 0.5 for snap point)
+	 */
+	target: "open" | "close" | number;
 	spec?: TransitionSpec;
 	onAnimationFinish?: (finished: boolean) => void;
 	animations: AnimationStoreMap;
@@ -13,16 +19,22 @@ interface StartScreenTransitionProps {
 	initialVelocity?: number;
 }
 
-export const startScreenTransition = ({
+export const animateToProgress = ({
 	target,
 	spec,
 	onAnimationFinish,
 	animations,
 	initialVelocity,
-}: StartScreenTransitionProps) => {
+}: AnimateToProgressProps) => {
 	"worklet";
-	const value = target === "open" ? 1 : 0;
-	const config = target === "open" ? spec?.open : spec?.close;
+
+	// Determine target value and direction
+	const isClosing =
+		target === "close" || (typeof target === "number" && target === 0);
+	const value = typeof target === "number" ? target : target === "open" ? 1 : 0;
+
+	// Select spec based on direction (closing uses close spec, otherwise open)
+	const config = isClosing ? spec?.close : spec?.open;
 
 	const isSpringConfig =
 		!!config && !("duration" in config) && !("easing" in config);
@@ -34,7 +46,7 @@ export const startScreenTransition = ({
 
 	const { progress, animating, closing, entering } = animations;
 
-	if (target === "close") {
+	if (isClosing) {
 		closing.set(TRUE);
 		entering.set(FALSE);
 	} else {

package/src/shared/utils/gesture/check-gesture-activation.ts

@@ -308,3 +308,81 @@ export const applyOffsetRules = ({
 		isSwipingLeft,
 	};
 };
+
+interface ScrollAwareActivationParams {
+	swipeInfo: {
+		isSwipingDown: boolean;
+		isSwipingUp: boolean;
+		isSwipingRight: boolean;
+		isSwipingLeft: boolean;
+	};
+	directions: Directions;
+	scrollX: number;
+	scrollY: number;
+	maxScrollX: number;
+	maxScrollY: number;
+	hasSnapPoints?: boolean;
+	canExpandMore?: boolean;
+}
+
+type GestureDirection =
+	| "vertical"
+	| "vertical-inverted"
+	| "horizontal"
+	| "horizontal-inverted";
+
+/**
+ * Checks if a gesture should activate based on scroll position.
+ * Returns the direction to activate for, or null if activation should not occur.
+ */
+export function checkScrollAwareActivation({
+	swipeInfo,
+	directions,
+	scrollX,
+	scrollY,
+	maxScrollX,
+	maxScrollY,
+	hasSnapPoints,
+	canExpandMore,
+}: ScrollAwareActivationParams): {
+	shouldActivate: boolean;
+	direction: GestureDirection | null;
+} {
+	"worklet";
+
+	const { isSwipingDown, isSwipingUp, isSwipingRight, isSwipingLeft } =
+		swipeInfo;
+
+	if (directions.vertical && isSwipingDown && scrollY <= 0) {
+		return { shouldActivate: true, direction: "vertical" };
+	}
+
+	if (directions.horizontal && isSwipingRight && scrollX <= 0) {
+		return { shouldActivate: true, direction: "horizontal" };
+	}
+
+	if (directions.verticalInverted && isSwipingUp && scrollY >= maxScrollY) {
+		return { shouldActivate: true, direction: "vertical-inverted" };
+	}
+
+	if (directions.horizontalInverted && isSwipingLeft && scrollX >= maxScrollX) {
+		return { shouldActivate: true, direction: "horizontal-inverted" };
+	}
+
+	if (hasSnapPoints && canExpandMore) {
+		// Vertical sheet: swipe up at scroll top → expand
+		const enabledYAxis = directions.vertical || directions.verticalInverted;
+		const enabledXAxis = directions.horizontal || directions.horizontalInverted;
+
+		if (enabledYAxis && isSwipingUp && scrollY <= 0) {
+			return { shouldActivate: true, direction: "vertical-inverted" };
+		}
+
+		// Horizontal sheet: swipe left at scroll left → expand
+		if (enabledXAxis && isSwipingLeft && scrollX <= 0) {
+			return { shouldActivate: true, direction: "horizontal-inverted" };
+		}
+	}
+
+	return { shouldActivate: false, direction: null };
+}

package/src/shared/utils/gesture/determine-snap-target.ts

@@ -0,0 +1,75 @@
+interface DetermineSnapTargetProps {
+	currentProgress: number;
+	snapPoints: number[];
+	/** Velocity along the snap axis (positive = toward dismiss) */
+	velocity: number;
+	/** Screen dimension along the snap axis (width or height) */
+	dimension: number;
+	/** How much velocity affects the snap decision (0-1). Default 0.15 */
+	velocityFactor?: number;
+	/** Whether dismiss (progress=0) is allowed. Default true */
+	canDismiss?: boolean;
+}
+
+interface DetermineSnapTargetResult {
+	targetProgress: number;
+	shouldDismiss: boolean;
+}
+
+/**
+ * Determines which snap point to animate to based on current progress and velocity.
+ *
+ * Logic: Snap to whichever point is closest, factoring in velocity.
+ * The "zones" between snap points are split at midpoints.
+ * Velocity can push you into the next zone.
+ */
+export function determineSnapTarget({
+	currentProgress,
+	snapPoints,
+	velocity,
+	dimension,
+	velocityFactor = 0.15,
+	canDismiss = true,
+}: DetermineSnapTargetProps): DetermineSnapTargetResult {
+	"worklet";
+
+	// Convert velocity to progress units (positive = toward dismiss = decreasing progress)
+	const velocityInProgress = (velocity / dimension) * velocityFactor;
+
+	// Project where we'd end up with velocity
+	const projectedProgress = currentProgress - velocityInProgress;
+
+	// Build all possible targets: dismiss (0) only if allowed, plus all snap points
+	const allTargets = canDismiss
+		? [0, ...snapPoints].sort((a, b) => a - b)
+		: [...snapPoints].sort((a, b) => a - b);
+
+	// Find the target whose zone contains the projected progress
+	// Zones are split at midpoints between adjacent targets
+	let targetProgress = allTargets[0];
+
+	for (let i = 0; i < allTargets.length; i++) {
+		const current = allTargets[i];
+		const next = allTargets[i + 1];
+
+		if (next === undefined) {
+			// Last target - if we're above the midpoint to here, snap to it
+			targetProgress = current;
+			break;
+		}
+
+		const midpoint = (current + next) / 2;
+
+		if (projectedProgress < midpoint) {
+			targetProgress = current;
+			break;
+		}
+
+		targetProgress = next;
+	}
+
+	return {
+		targetProgress,
+		shouldDismiss: targetProgress === 0,
+	};
+}

package/src/shared/utils/gesture/validate-snap-points.ts

@@ -0,0 +1,37 @@
+interface ValidateSnapPointsResult {
+	hasSnapPoints: boolean;
+	snapPoints: number[];
+	minSnapPoint: number;
+	maxSnapPoint: number;
+}
+
+interface ValidateSnapPointsOptions {
+	snapPoints?: number[];
+	canDismiss?: boolean;
+}
+
+export const validateSnapPoints = ({
+	snapPoints,
+	canDismiss,
+}: ValidateSnapPointsOptions): ValidateSnapPointsResult => {
+	if (!snapPoints) {
+		return {
+			hasSnapPoints: false,
+			snapPoints: [],
+			minSnapPoint: -1,
+			maxSnapPoint: -1,
+		};
+	}
+
+	const sortedSnaps = snapPoints.slice().sort((a, b) => a - b);
+	// Clamp to snap point bounds (dismiss at 0 only if allowed)
+	const minProgress = canDismiss ? 0 : sortedSnaps[0];
+	const maxProgress = sortedSnaps[sortedSnaps.length - 1];
+
+	return {
+		hasSnapPoints: true,
+		snapPoints: sortedSnaps,
+		minSnapPoint: minProgress,
+		maxSnapPoint: maxProgress,
+	};
+};

package/src/shared/utils/gesture/velocity.ts

@@ -34,6 +34,15 @@ const normalize = (velocityPixelsPerSecond: number, screenSize: number) => {
 	);
 };
 
+/**
+ * Normalizes translation to -1...1 range (for gesture tracking).
+ * Used to convert pixel translation to normalized gesture values.
+ */
+const normalizeTranslation = (translation: number, dimension: number) => {
+	"worklet";
+	return clamp(translation / Math.max(1, dimension), -1, 1);
+};
+
 /**
  * Calculates a normalized velocity that moves the current value toward zero.
  * Used for spring-back animations when dismissing gestures.
@@ -137,6 +146,7 @@ const shouldPassDismissalThreshold = (
 
 export const velocity = {
 	normalize,
+	normalizeTranslation,
 	calculateRestoreVelocity,
 	calculateProgressVelocity,
 	shouldPassDismissalThreshold,

package/lib/commonjs/shared/components/root-transition-aware.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_react","require","_reactNative","_reactNativeReanimated","_interopRequireWildcard","_constants","_useStackPointerEvents","_styles","_jsxRuntime","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","RootTransitionAware","exports","memo","children","stylesMap","useScreenStyles","pointerEvents","useStackPointerEvents","animatedContentStyle","useAnimatedStyle","value","contentStyle","NO_STYLES","animatedOverlayStyle","overlayStyle","jsxs","View","style","styles","container","jsx","StyleSheet","absoluteFillObject","content","create","flex"],"sourceRoot":"../../../../src","sources":["shared/components/root-transition-aware.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AACA,IAAAE,sBAAA,GAAAC,uBAAA,CAAAH,OAAA;AACA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,sBAAA,GAAAL,OAAA;AACA,IAAAM,OAAA,GAAAN,OAAA;AAAsE,IAAAO,WAAA,GAAAP,OAAA;AAAA,SAAAG,wBAAAK,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAP,uBAAA,YAAAA,CAAAK,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAM/D,MAAMkB,mBAAmB,GAAAC,OAAA,CAAAD,mBAAA,gBAAG,IAAAE,WAAI,EAAC,CAAC;EAAEC;AAAgB,CAAC,KAAK;EAChE,MAAM;IAAEC;EAAU,CAAC,GAAG,IAAAC,uBAAe,EAAC,CAAC;EACvC,MAAMC,aAAa,GAAG,IAAAC,4CAAqB,EAAC,CAAC;EAE7C,MAAMC,oBAAoB,GAAG,IAAAC,uCAAgB,EAAC,MAAM;IACnD,SAAS;;IACT,OAAOL,SAAS,CAACM,KAAK,CAACC,YAAY,IAAIC,oBAAS;EACjD,CAAC,CAAC;EAEF,MAAMC,oBAAoB,GAAG,IAAAJ,uCAAgB,EAAC,MAAM;IACnD,SAAS;;IACT,OAAOL,SAAS,CAACM,KAAK,CAACI,YAAY,IAAIF,oBAAS;EACjD,CAAC,CAAC;EAEF,oBACC,IAAAhC,WAAA,CAAAmC,IAAA,EAACzC,YAAA,CAAA0C,IAAI;IAACC,KAAK,EAAE,CAACC,MAAM,CAACC,SAAS,CAAE;IAACb,aAAa,EAAEA,aAAc;IAAAH,QAAA,gBAC7D,IAAAvB,WAAA,CAAAwC,GAAA,EAAC7C,sBAAA,CAAAgB,OAAQ,CAACyB,IAAI;MACbC,KAAK,EAAE,CAACI,uBAAU,CAACC,kBAAkB,EAAET,oBAAoB,CAAE;MAC7DP,aAAa,EAAC;IAAM,CACpB,CAAC,eACF,IAAA1B,WAAA,CAAAwC,GAAA,EAAC7C,sBAAA,CAAAgB,OAAQ,CAACyB,IAAI;MACbC,KAAK,EAAE,CAACC,MAAM,CAACK,OAAO,EAAEf,oBAAoB,CAAE;MAC9CF,aAAa,EAAEA,aAAc;MAAAH,QAAA,EAE5BA;IAAQ,CACK,CAAC;EAAA,CACX,CAAC;AAET,CAAC,CAAC;AAEF,MAAMe,MAAM,GAAGG,uBAAU,CAACG,MAAM,CAAC;EAChCL,SAAS,EAAE;IACVM,IAAI,EAAE;EACP,CAAC;EACDF,OAAO,EAAE;IACRE,IAAI,EAAE;EACP;AACD,CAAC,CAAC","ignoreList":[]}