react-native-screen-transitions 3.6.0-alpha.0 → 3.6.0-alpha.2

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

@@ -16,6 +16,7 @@ import type {
 import type {
 	GestureActivationArea,
 	GestureDirections,
+	GestureProgressMode,
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
 	ScrollGestureState,
@@ -27,7 +28,7 @@ import type {
 	DirectionOwnership,
 } from "../../../types/ownership.types";
 import type { ScreenTransitionConfig } from "../../../types/screen.types";
-import type { EffectiveSnapPointsResult } from "./helpers/validate-snap-points";
+import type { EffectiveSnapPointsResult } from "./shared/snap-points";
 
 export type PanGesture = ReturnType<typeof Gesture.Pan>;
 export type PinchGesture = ReturnType<typeof Gesture.Pinch>;
@@ -41,7 +42,12 @@ export type PinchGestureEvent =
 	| GestureUpdateEvent<PinchGestureHandlerEventPayload>
 	| GestureStateChangeEvent<PinchGestureHandlerEventPayload>;
 
-export type { ScrollGestureAxis, ScrollGestureAxisState, ScrollGestureState };
+export type {
+	GestureProgressMode,
+	ScrollGestureAxis,
+	ScrollGestureAxisState,
+	ScrollGestureState,
+};
 
 export type DirectionClaim = {
 	routeKey: string;
@@ -55,7 +61,7 @@ export type DirectionClaimMap = {
 	"horizontal-inverted": DirectionClaim;
 };
 
-export const NO_CLAIMS: DirectionClaimMap = {
+export const NO_DIRECTION_CLAIMS: DirectionClaimMap = {
 	vertical: null,
 	"vertical-inverted": null,
 	horizontal: null,
@@ -96,13 +102,11 @@ export interface PanGesturePolicy {
 	gestureDirection: NonNullable<ScreenTransitionConfig["gestureDirection"]>;
 	panActivationDirections: GestureDirections;
 	snapAxisDirections: SnapPanDirectionConfig;
-	gestureDrivesProgress: boolean;
+	gestureProgressMode: GestureProgressMode;
 	gestureSensitivity: NonNullable<ScreenTransitionConfig["gestureSensitivity"]>;
 	gestureVelocityImpact: number;
 	gestureSnapVelocityImpact: number;
 	gestureReleaseVelocityScale: number;
-	/** @deprecated v3 compatibility only. Removed in the next gesture runtime. */
-	gestureReleaseVelocityMax: number;
 	gestureActivationArea: GestureActivationArea;
 	gestureSnapLocked: boolean;
 	sheetScrollGestureBehavior: NonNullable<
@@ -118,13 +122,11 @@ export interface PinchGesturePolicy {
 	snapDirections: SnapPinchDirectionConfig;
 	pinchInEnabled: boolean;
 	pinchOutEnabled: boolean;
-	gestureDrivesProgress: boolean;
+	gestureProgressMode: GestureProgressMode;
 	gestureSensitivity: NonNullable<ScreenTransitionConfig["gestureSensitivity"]>;
 	gestureSnapVelocityImpact: number;
 	gestureSnapLocked: boolean;
 	gestureReleaseVelocityScale: number;
-	/** @deprecated v3 compatibility only. Removed in the next gesture runtime. */
-	gestureReleaseVelocityMax: number;
 	transitionSpec: TransitionSpec | undefined;
 }
 
@@ -134,22 +136,20 @@ export interface GestureRuntimeStores {
 	system: SystemStoreMap;
 }
 
-export interface PanGestureRuntime {
-	participation: ScreenGestureParticipation;
-	policy: PanGesturePolicy;
-	stores: GestureRuntimeStores;
-	gestureProgressBaseline: SharedValue<number>;
-	lockedSnapPoint: SharedValue<number>;
-}
+export type GesturePolicy = PanGesturePolicy | PinchGesturePolicy;
 
-export interface PinchGestureRuntime {
+export interface GestureRuntime<TPolicy extends GesturePolicy> {
 	participation: ScreenGestureParticipation;
-	policy: PinchGesturePolicy;
+	policy: TPolicy;
 	stores: GestureRuntimeStores;
 	gestureProgressBaseline: SharedValue<number>;
 	lockedSnapPoint: SharedValue<number>;
 }
 
+export type PanGestureRuntime = GestureRuntime<PanGesturePolicy>;
+
+export type PinchGestureRuntime = GestureRuntime<PinchGesturePolicy>;
+
 export interface GestureDimensions {
 	width: number;
 	height: number;
@@ -160,6 +160,7 @@ export interface PanTrackState {
 	y: number;
 	normX: number;
 	normY: number;
+	velocity: number;
 }
 
 export interface PinchTrackState {
@@ -171,42 +172,37 @@ export interface PanReleaseResult {
 	target: number;
 	shouldDismiss: boolean;
 	initialVelocity: number;
+	commitProgress?: number;
+	resetNormalizedValuesImmediately?: boolean;
 	transitionSpec: TransitionSpec | undefined;
 	resetSpec: AnimationConfig | undefined;
 }
 
-export interface PinchReleaseResult {
+export interface PanReleasePlan {
 	target: number;
 	shouldDismiss: boolean;
-	initialVelocity: number;
+	progressVelocity: number;
+	resetVelocityX: number;
+	resetVelocityY: number;
+	resetVelocityNormX: number;
+	resetVelocityNormY: number;
+	releaseVelocity: number;
+	resetNormalizedValues: boolean;
+	resetNormalizedValuesImmediately: boolean;
+	preserveRawValues: boolean;
+	commitProgress?: number;
 	transitionSpec: TransitionSpec | undefined;
 	resetSpec: AnimationConfig | undefined;
 }
 
-export interface PanBehaviorStrategy {
-	primeStart: (runtime: PanGestureRuntime) => void;
-	resolveProgress: (
-		runtime: PanGestureRuntime,
-		dimensions: GestureDimensions,
-		track: PanTrackState,
-	) => number;
-	resolveRelease: (
-		event: PanGestureEvent,
-		runtime: PanGestureRuntime,
-		dimensions: GestureDimensions,
-	) => PanReleaseResult;
-}
-
-export interface PinchBehaviorStrategy {
-	primeStart: (runtime: PinchGestureRuntime) => void;
-	resolveProgress: (
-		runtime: PinchGestureRuntime,
-		track: PinchTrackState,
-	) => number;
-	resolveRelease: (
-		event: PinchGestureEvent,
-		runtime: PinchGestureRuntime,
-	) => PinchReleaseResult;
+export interface PinchReleaseResult {
+	target: number;
+	shouldDismiss: boolean;
+	initialVelocity: number;
+	commitProgress?: number;
+	resetValuesImmediately?: boolean;
+	transitionSpec: TransitionSpec | undefined;
+	resetSpec: AnimationConfig | undefined;
 }
 
 export interface PanBehavior {

package/src/shared/providers/screen/options/helpers.ts

@@ -1,7 +1,7 @@
 import {
 	DEFAULT_GESTURE_ACTIVATION_AREA,
 	DEFAULT_GESTURE_DIRECTION,
-	DEFAULT_GESTURE_DRIVES_PROGRESS,
+	DEFAULT_GESTURE_PROGRESS_MODE,
 	DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
 	DEFAULT_GESTURE_SENSITIVITY,
 	DEFAULT_GESTURE_SNAP_LOCKED,
@@ -17,6 +17,11 @@ import type {
 	TransitionInterpolatedStyle,
 } from "../../../types";
 import type { BackdropBehavior } from "../../../types/screen.types";
+import {
+	gestureProgressModeDrivesProgress,
+	isGestureProgressMode,
+	resolveGestureProgressMode,
+} from "../../../utils/gesture-progress-mode";
 import { resolveSheetScrollGestureBehavior } from "../../../utils/resolve-screen-transition-options";
 import type {
 	RequiredScreenOption,
@@ -134,73 +139,173 @@ const resolveBackdropBehaviorOption = (
 		: fallback;
 };
 
+const resolveGestureProgressModeOption = (
+	gestureProgressMode: unknown,
+	gestureDrivesProgress: unknown,
+	fallback: RequiredScreenOption<"gestureProgressMode">,
+): RequiredScreenOption<"gestureProgressMode"> => {
+	"worklet";
+	if (isGestureProgressMode(gestureProgressMode)) {
+		return gestureProgressMode;
+	}
+
+	return resolveGestureProgressMode({
+		gestureDrivesProgress:
+			typeof gestureDrivesProgress === "boolean"
+				? gestureDrivesProgress
+				: undefined,
+		fallback,
+	});
+};
+
+const areGestureActivationAreasEqual = (
+	left: RequiredScreenOption<"gestureActivationArea">,
+	right: RequiredScreenOption<"gestureActivationArea">,
+) => {
+	"worklet";
+	if (left === right) return true;
+
+	if (
+		typeof left !== "object" ||
+		left === null ||
+		typeof right !== "object" ||
+		right === null
+	) {
+		return false;
+	}
+
+	return (
+		left.left === right.left &&
+		left.right === right.right &&
+		left.top === right.top &&
+		left.bottom === right.bottom
+	);
+};
+
+const areGestureDirectionsEqual = (
+	left: RequiredScreenOption<"gestureDirection">,
+	right: RequiredScreenOption<"gestureDirection">,
+) => {
+	"worklet";
+	if (left === right) return true;
+	if (!Array.isArray(left) || !Array.isArray(right)) return false;
+	if (left.length !== right.length) return false;
+
+	for (let i = 0; i < left.length; i++) {
+		if (left[i] !== right[i]) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+const areScreenOptionsEqual = (
+	left: ScreenOptionsState,
+	right: ScreenOptionsState,
+) => {
+	"worklet";
+	return (
+		left.gestureEnabled === right.gestureEnabled &&
+		left.experimental_allowDisabledGestureTracking ===
+			right.experimental_allowDisabledGestureTracking &&
+		areGestureDirectionsEqual(left.gestureDirection, right.gestureDirection) &&
+		left.gestureSensitivity === right.gestureSensitivity &&
+		left.gestureVelocityImpact === right.gestureVelocityImpact &&
+		left.gestureSnapVelocityImpact === right.gestureSnapVelocityImpact &&
+		left.gestureReleaseVelocityScale === right.gestureReleaseVelocityScale &&
+		left.gestureResponseDistance === right.gestureResponseDistance &&
+		left.gestureProgressMode === right.gestureProgressMode &&
+		left.gestureDrivesProgress === right.gestureDrivesProgress &&
+		areGestureActivationAreasEqual(
+			left.gestureActivationArea,
+			right.gestureActivationArea,
+		) &&
+		left.gestureSnapLocked === right.gestureSnapLocked &&
+		left.sheetScrollGestureBehavior === right.sheetScrollGestureBehavior &&
+		left.backdropBehavior === right.backdropBehavior &&
+		left.baseOptions === right.baseOptions
+	);
+};
+
 export const resolveBaseScreenOptions = (
 	options: ScreenTransitionOptions,
-): ScreenOptionsSnapshot => ({
-	gestureEnabled: resolveBooleanOption(options.gestureEnabled, undefined),
-	experimental_allowDisabledGestureTracking: resolveBooleanOption(
-		options.experimental_allowDisabledGestureTracking,
-		false,
-	),
-	gestureDirection: resolveGestureDirectionOption(
-		options.gestureDirection,
-		DEFAULT_GESTURE_DIRECTION,
-	),
-	gestureSensitivity: resolveNumberOption(
-		options.gestureSensitivity,
-		DEFAULT_GESTURE_SENSITIVITY,
-	),
-	gestureVelocityImpact: resolveNumberOption(
-		options.gestureVelocityImpact,
-		DEFAULT_GESTURE_VELOCITY_IMPACT,
-	),
-	gestureSnapVelocityImpact: resolveNumberOption(
-		options.gestureSnapVelocityImpact,
-		DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT,
-	),
-	gestureReleaseVelocityScale: resolveNumberOption(
-		options.gestureReleaseVelocityScale,
-		DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
-	),
-	gestureResponseDistance: resolveNumberOption(
-		options.gestureResponseDistance,
-		undefined,
-	),
-	gestureDrivesProgress: resolveBooleanOption(
+): ScreenOptionsSnapshot => {
+	const gestureProgressMode = resolveGestureProgressModeOption(
+		options.gestureProgressMode,
 		options.gestureDrivesProgress,
-		DEFAULT_GESTURE_DRIVES_PROGRESS,
-	),
-	gestureActivationArea: resolveGestureActivationAreaOption(
-		options.gestureActivationArea,
-		DEFAULT_GESTURE_ACTIVATION_AREA,
-	),
-	gestureSnapLocked: resolveBooleanOption(
-		options.gestureSnapLocked,
-		DEFAULT_GESTURE_SNAP_LOCKED,
-	),
-	sheetScrollGestureBehavior: resolveSheetScrollGestureBehaviorOption(
-		resolveSheetScrollGestureBehavior(options),
-		DEFAULT_SHEET_SCROLL_GESTURE_BEHAVIOR,
-	),
-	backdropBehavior: resolveBackdropBehaviorOption(
-		options.backdropBehavior,
-		undefined,
-	),
-});
+		DEFAULT_GESTURE_PROGRESS_MODE,
+	);
+
+	return {
+		gestureEnabled: resolveBooleanOption(options.gestureEnabled, undefined),
+		experimental_allowDisabledGestureTracking: resolveBooleanOption(
+			options.experimental_allowDisabledGestureTracking,
+			false,
+		),
+		gestureDirection: resolveGestureDirectionOption(
+			options.gestureDirection,
+			DEFAULT_GESTURE_DIRECTION,
+		),
+		gestureSensitivity: resolveNumberOption(
+			options.gestureSensitivity,
+			DEFAULT_GESTURE_SENSITIVITY,
+		),
+		gestureVelocityImpact: resolveNumberOption(
+			options.gestureVelocityImpact,
+			DEFAULT_GESTURE_VELOCITY_IMPACT,
+		),
+		gestureSnapVelocityImpact: resolveNumberOption(
+			options.gestureSnapVelocityImpact,
+			DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT,
+		),
+		gestureReleaseVelocityScale: resolveNumberOption(
+			options.gestureReleaseVelocityScale,
+			DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
+		),
+		gestureResponseDistance: resolveNumberOption(
+			options.gestureResponseDistance,
+			undefined,
+		),
+		gestureProgressMode,
+		gestureDrivesProgress:
+			gestureProgressModeDrivesProgress(gestureProgressMode),
+		gestureActivationArea: resolveGestureActivationAreaOption(
+			options.gestureActivationArea,
+			DEFAULT_GESTURE_ACTIVATION_AREA,
+		),
+		gestureSnapLocked: resolveBooleanOption(
+			options.gestureSnapLocked,
+			DEFAULT_GESTURE_SNAP_LOCKED,
+		),
+		sheetScrollGestureBehavior: resolveSheetScrollGestureBehaviorOption(
+			resolveSheetScrollGestureBehavior(options),
+			DEFAULT_SHEET_SCROLL_GESTURE_BEHAVIOR,
+		),
+		backdropBehavior: resolveBackdropBehaviorOption(
+			options.backdropBehavior,
+			undefined,
+		),
+	};
+};
 
 export const syncScreenOptionsBase = (
 	screenOptions: ScreenOptionsContextValue,
 	base: ScreenOptionsSnapshot,
 ) => {
 	"worklet";
-	screenOptions.set({
+	const next = {
 		...base,
 		gestureDirection: cloneGestureDirection(base.gestureDirection),
 		gestureActivationArea: cloneGestureActivationArea(
 			base.gestureActivationArea,
 		),
 		baseOptions: base,
-	});
+	};
+
+	if (!areScreenOptionsEqual(screenOptions.get(), next)) {
+		screenOptions.set(next);
+	}
 };
 
 export const syncScreenOptionsOverrides = (
@@ -210,6 +315,11 @@ export const syncScreenOptionsOverrides = (
 	"worklet";
 	const options = raw?.options;
 	const base = screenOptions.get().baseOptions;
+	const gestureProgressMode = resolveGestureProgressModeOption(
+		options?.gestureProgressMode,
+		options?.gestureDrivesProgress,
+		base.gestureProgressMode,
+	);
 
 	const next: ScreenOptionsState = {
 		gestureEnabled: resolveBooleanOption(
@@ -244,10 +354,9 @@ export const syncScreenOptionsOverrides = (
 			options?.gestureResponseDistance,
 			base.gestureResponseDistance,
 		),
-		gestureDrivesProgress: resolveBooleanOption(
-			options?.gestureDrivesProgress,
-			base.gestureDrivesProgress,
-		),
+		gestureProgressMode,
+		gestureDrivesProgress:
+			gestureProgressModeDrivesProgress(gestureProgressMode),
 		gestureActivationArea: resolveGestureActivationAreaOption(
 			options?.gestureActivationArea,
 			base.gestureActivationArea,
@@ -267,5 +376,7 @@ export const syncScreenOptionsOverrides = (
 		baseOptions: base,
 	};
 
-	screenOptions.set(next);
+	if (!areScreenOptionsEqual(screenOptions.get(), next)) {
+		screenOptions.set(next);
+	}
 };

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

@@ -17,6 +17,7 @@ export type ScreenOptionsSnapshot = {
 	gestureSnapVelocityImpact: RequiredScreenOption<"gestureSnapVelocityImpact">;
 	gestureReleaseVelocityScale: RequiredScreenOption<"gestureReleaseVelocityScale">;
 	gestureResponseDistance: OptionalScreenOption<"gestureResponseDistance">;
+	gestureProgressMode: RequiredScreenOption<"gestureProgressMode">;
 	gestureDrivesProgress: RequiredScreenOption<"gestureDrivesProgress">;
 	gestureActivationArea: RequiredScreenOption<"gestureActivationArea">;
 	gestureSnapLocked: RequiredScreenOption<"gestureSnapLocked">;

package/src/shared/providers/screen/styles/helpers/preserve-animated-props-only.ts

@@ -0,0 +1,22 @@
+import { NO_STYLES } from "../../../../constants";
+import type { NormalizedTransitionInterpolatedStyle } from "../../../../types/animation.types";
+
+export const preserveAnimatedPropsOnly = (
+	stylesMap: NormalizedTransitionInterpolatedStyle,
+): NormalizedTransitionInterpolatedStyle => {
+	"worklet";
+	let hasProps = false;
+	const propsOnly: NormalizedTransitionInterpolatedStyle = {};
+
+	for (const slotId in stylesMap) {
+		const slot = stylesMap[slotId];
+		if (!slot || slot.props === undefined) {
+			continue;
+		}
+
+		propsOnly[slotId] = { props: slot.props };
+		hasProps = true;
+	}
+
+	return hasProps ? propsOnly : NO_STYLES;
+};

package/src/shared/providers/screen/styles/helpers/resolve-slot-styles/index.ts

@@ -149,6 +149,160 @@ const writeResolvedSlotOutput = ({
 	context.resolvedStylesMap[slotId] = resolvedSlot;
 };
 
+const areTransformItemsEqual = (left: unknown, right: unknown): boolean => {
+	"worklet";
+	if (left === right) {
+		return true;
+	}
+
+	if (
+		typeof left !== "object" ||
+		left === null ||
+		typeof right !== "object" ||
+		right === null
+	) {
+		return false;
+	}
+
+	const leftObject = left as Record<string, unknown>;
+	const rightObject = right as Record<string, unknown>;
+
+	for (const key in leftObject) {
+		if (leftObject[key] !== rightObject[key]) {
+			return false;
+		}
+	}
+
+	for (const key in rightObject) {
+		if (!(key in leftObject)) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+const areTransformArraysEqual = (left: unknown, right: unknown): boolean => {
+	"worklet";
+	if (left === right) {
+		return true;
+	}
+
+	if (!Array.isArray(left) || !Array.isArray(right)) {
+		return false;
+	}
+
+	if (left.length !== right.length) {
+		return false;
+	}
+
+	for (let i = 0; i < left.length; i++) {
+		if (!areTransformItemsEqual(left[i], right[i])) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+const areFlatObjectsEqual = (left: unknown, right: unknown): boolean => {
+	"worklet";
+	if (left === right) {
+		return true;
+	}
+
+	if (
+		typeof left !== "object" ||
+		left === null ||
+		typeof right !== "object" ||
+		right === null ||
+		Array.isArray(left) ||
+		Array.isArray(right)
+	) {
+		return false;
+	}
+
+	const leftObject = left as Record<string, unknown>;
+	const rightObject = right as Record<string, unknown>;
+
+	for (const key in leftObject) {
+		const leftValue = leftObject[key];
+		const rightValue = rightObject[key];
+
+		if (key === "transform") {
+			if (!areTransformArraysEqual(leftValue, rightValue)) {
+				return false;
+			}
+			continue;
+		}
+
+		if (!areTransformItemsEqual(leftValue, rightValue)) {
+			return false;
+		}
+	}
+
+	for (const key in rightObject) {
+		if (!(key in leftObject)) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+const areSlotsEqual = (
+	left: NormalizedTransitionSlotStyle | undefined,
+	right: NormalizedTransitionSlotStyle | undefined,
+) => {
+	"worklet";
+	if (left === right) {
+		return true;
+	}
+
+	if (!left || !right) {
+		return false;
+	}
+
+	return (
+		areFlatObjectsEqual(left.style, right.style) &&
+		areFlatObjectsEqual(left.props, right.props)
+	);
+};
+
+export const reuseEqualResolvedSlots = ({
+	resolvedStylesMap,
+	previousResolvedStylesMap,
+}: {
+	resolvedStylesMap: NormalizedTransitionInterpolatedStyle;
+	previousResolvedStylesMap: NormalizedTransitionInterpolatedStyle;
+}): NormalizedTransitionInterpolatedStyle => {
+	"worklet";
+	let changed = false;
+	const stableStylesMap: NormalizedTransitionInterpolatedStyle = {};
+
+	for (const slotId in resolvedStylesMap) {
+		const nextSlot = resolvedStylesMap[slotId];
+		const previousSlot = previousResolvedStylesMap[slotId];
+
+		if (areSlotsEqual(nextSlot, previousSlot)) {
+			stableStylesMap[slotId] = previousSlot;
+			continue;
+		}
+
+		changed = true;
+		stableStylesMap[slotId] = nextSlot;
+	}
+
+	for (const slotId in previousResolvedStylesMap) {
+		if (!(slotId in resolvedStylesMap)) {
+			changed = true;
+			break;
+		}
+	}
+
+	return changed ? stableStylesMap : previousResolvedStylesMap;
+};
+
 const appendResolvedSlot = (
 	context: ResolveSlotStylesContext,
 	slotId: string,

package/src/shared/providers/screen/styles/helpers/visibility-gate.ts

@@ -0,0 +1,57 @@
+import { LifecycleTransitionRequestKind } from "../../../../stores/system.store";
+
+type ScreenVisibilityGateState = {
+	isFloatingOverlay?: boolean;
+	hasVisibilityGateOpened: boolean;
+	pendingLifecycleStartBlockCount: number;
+	pendingLifecycleRequestKind: LifecycleTransitionRequestKind;
+	progress: number;
+	entering: number;
+};
+
+type ScreenVisibilityGateDecision = {
+	shouldBlock: boolean;
+	shouldOpenGate: boolean;
+};
+
+export const resolveScreenVisibilityGate = ({
+	isFloatingOverlay,
+	hasVisibilityGateOpened,
+	pendingLifecycleStartBlockCount,
+	pendingLifecycleRequestKind,
+	progress,
+	entering,
+}: ScreenVisibilityGateState): ScreenVisibilityGateDecision => {
+	"worklet";
+	if (isFloatingOverlay || hasVisibilityGateOpened) {
+		return {
+			shouldBlock: false,
+			shouldOpenGate: false,
+		};
+	}
+
+	const hasPendingLifecycleBlock = pendingLifecycleStartBlockCount > 0;
+	const isPendingOpen =
+		pendingLifecycleRequestKind === LifecycleTransitionRequestKind.Open;
+	const isOpening = isPendingOpen || !!entering;
+
+	// Keep the screen hidden until the first transformed opening frame exists.
+	// The lifecycle request is cleared before the RAF-scheduled progress
+	// animation starts, so `entering` carries the gate through that one-frame gap.
+	const isWaitingForOpenToStart = progress <= 0;
+
+	const shouldBlock =
+		(hasPendingLifecycleBlock || isWaitingForOpenToStart) && isOpening;
+
+	return {
+		shouldBlock,
+		shouldOpenGate: !shouldBlock && progress > 0,
+	};
+};
+
+export const shouldBlockScreenVisibility = (
+	state: ScreenVisibilityGateState,
+) => {
+	"worklet";
+	return resolveScreenVisibilityGate(state).shouldBlock;
+};