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

package/src/shared/providers/screen/styles/hooks/use-maybe-block-visibility.tsx

@@ -1,40 +1,59 @@
 import {
 	useAnimatedProps,
+	useAnimatedReaction,
 	useAnimatedStyle,
-	useDerivedValue,
+	useSharedValue,
 } from "react-native-reanimated";
 import { AnimationStore } from "../../../../stores/animation.store";
 import { SystemStore } from "../../../../stores/system.store";
 import { useDescriptorDerivations } from "../../descriptors";
+import { resolveScreenVisibilityGate } from "../helpers/visibility-gate";
 
 export const useMaybeBlockVisibility = (isFloatingOverlay?: boolean) => {
 	const { currentScreenKey } = useDescriptorDerivations();
-	const progress = AnimationStore.getValue(currentScreenKey, "progress");
+	const { entering, progress } = AnimationStore.getBag(currentScreenKey);
 
-	const { pendingLifecycleStartBlockCount } =
+	const { pendingLifecycleStartBlockCount, pendingLifecycleRequestKind } =
 		SystemStore.getBag(currentScreenKey);
 
-	const shouldBlockVisibility = useDerivedValue(() => {
-		"worklet";
+	const hasVisibilityGateOpened = useSharedValue(false);
+	const shouldBlockVisibility = useSharedValue(!isFloatingOverlay);
 
-		if (isFloatingOverlay) {
-			return false;
-		}
+	/**
+	 * Visibility has to start blocked before the first animated style pass.
+	 *
+	 * `useDerivedValue` can publish its computed value after `useAnimatedStyle`
+	 * has already read the initial one, which briefly exposes an unhydrated
+	 * screen. Keep the visible state in an eagerly initialized shared value, then
+	 * let the reaction open it once the visibility gate allows the first
+	 * transformed frame to render.
+	 */
+	useAnimatedReaction(
+		() => {
+			"worklet";
 
-		const hasPendingLifecycleBlock = pendingLifecycleStartBlockCount.get() > 0;
+			return resolveScreenVisibilityGate({
+				isFloatingOverlay,
+				hasVisibilityGateOpened: hasVisibilityGateOpened.get(),
+				pendingLifecycleStartBlockCount: pendingLifecycleStartBlockCount.get(),
+				pendingLifecycleRequestKind: pendingLifecycleRequestKind.get(),
+				progress: progress.get(),
+				entering: entering.get(),
+			});
+		},
+		(gate) => {
+			"worklet";
 
-		// Hide the screen during the tiny pre-animation open window as well.
-		// The destination measurement blocker can be registered one frame after
-		// mount, which would otherwise flash the reset state before the block
-		// count turns visible to this provider.
-		const isWaitingForOpenToStart = progress.get() <= 0;
+			if (gate.shouldOpenGate) {
+				hasVisibilityGateOpened.set(true);
+			}
 
-		return hasPendingLifecycleBlock || isWaitingForOpenToStart;
-	});
+			shouldBlockVisibility.set(gate.shouldBlock);
+		},
+	);
 
 	const animatedStyle = useAnimatedStyle(() => {
 		"worklet";
-
 		return {
 			opacity: shouldBlockVisibility.get() ? 0 : 1,
 		};

package/src/shared/providers/screen/styles/hooks/use-resolved-slot-style-map.tsx

@@ -9,6 +9,7 @@ import { useScreenAnimationContext } from "../../animation";
 import {
 	type ResettableStyleStatesBySlot,
 	resolveSlotStyles,
+	reuseEqualResolvedSlots,
 } from "../helpers/resolve-slot-styles";
 
 interface UseResolvedStylesMapParams {
@@ -20,15 +21,17 @@ export const useResolvedStylesMap = ({
 	currentStylesMap,
 	ancestorStylesMap,
 }: UseResolvedStylesMapParams) => {
-	const { screenInterpolatorProps, screenInterpolatorFrameUpdater } =
+	const { screenInterpolatorProps, screenInterpolatorPropsRevision } =
 		useScreenAnimationContext();
 	const previousStyleStatesBySlot = useSharedValue<ResettableStyleStatesBySlot>(
 		{},
 	);
+	const previousResolvedStylesMap =
+		useSharedValue<NormalizedTransitionInterpolatedStyle>(NO_STYLES);
 
 	return useDerivedValue(() => {
 		"worklet";
-		screenInterpolatorFrameUpdater.get();
+		screenInterpolatorPropsRevision.get();
 
 		const props = screenInterpolatorProps.get();
 		// Keep missing local slots alive while another route drives this screen.
@@ -44,7 +47,12 @@ export const useResolvedStylesMap = ({
 			});
 
 		previousStyleStatesBySlot.set(nextPreviousStyleStatesBySlot);
+		const stableResolvedStylesMap = reuseEqualResolvedSlots({
+			resolvedStylesMap,
+			previousResolvedStylesMap: previousResolvedStylesMap.get(),
+		});
+		previousResolvedStylesMap.set(stableResolvedStylesMap);
 
-		return resolvedStylesMap;
+		return stableResolvedStylesMap;
 	});
 };

package/src/shared/stores/animation.store.ts

@@ -8,11 +8,9 @@ import { createStore } from "../utils/create-store";
 export type AnimationStoreMap = {
 	progress: SharedValue<number>;
 	willAnimate: SharedValue<number>;
-	animating: SharedValue<number>;
+	progressAnimating: SharedValue<number>;
 	closing: SharedValue<number>;
 	entering: SharedValue<number>;
-	settled: SharedValue<number>;
-	logicallySettled: SharedValue<number>;
 };
 
 function createAnimationBag(): AnimationStoreMap {
@@ -20,10 +18,8 @@ function createAnimationBag(): AnimationStoreMap {
 		progress: makeMutable(0),
 		willAnimate: makeMutable(0),
 		closing: makeMutable(0),
-		animating: makeMutable(0),
+		progressAnimating: makeMutable(0),
 		entering: makeMutable(0),
-		settled: makeMutable(1),
-		logicallySettled: makeMutable(1),
 	};
 }
 
@@ -37,10 +33,8 @@ export const AnimationStore = createStore<AnimationStoreMap>({
 	disposeBag: (bag) => {
 		cancelAnimation(bag.progress);
 		cancelAnimation(bag.willAnimate);
-		cancelAnimation(bag.animating);
+		cancelAnimation(bag.progressAnimating);
 		cancelAnimation(bag.closing);
 		cancelAnimation(bag.entering);
-		cancelAnimation(bag.settled);
-		cancelAnimation(bag.logicallySettled);
 	},
 });

package/src/shared/stores/bounds/helpers/entries.helpers.ts

@@ -1,16 +1,9 @@
 import type { EntryPatch, ScreenEntry, ScreenKey, TagState } from "../types";
 
-type EntryPatchOptionalField =
-	| "boundaryConfig"
-	| "ancestorKeys"
-	| "navigatorKey"
-	| "ancestorNavigatorKeys";
+type EntryPatchOptionalField = "boundaryConfig";
 
 const ENTRY_PATCH_OPTIONAL_FIELDS = [
 	"boundaryConfig",
-	"ancestorKeys",
-	"navigatorKey",
-	"ancestorNavigatorKeys",
 ] as const satisfies readonly EntryPatchOptionalField[];
 
 export const ensureScreenEntry = (
@@ -58,17 +51,5 @@ export const findMatchingScreenEntry = (
 	"worklet";
 	if (!tagState) return null;
 
-	const direct = tagState.screens[screenKey];
-	if (direct) {
-		return direct;
-	}
-
-	for (const entryScreenKey in tagState.screens) {
-		const entry = tagState.screens[entryScreenKey];
-		if (entry.ancestorKeys?.includes(screenKey)) {
-			return entry;
-		}
-	}
-
-	return null;
+	return tagState.screens[screenKey] ?? null;
 };

package/src/shared/stores/bounds/helpers/link.helpers.ts

@@ -5,15 +5,11 @@ import { matchesScreenKey } from "./matching";
 type LinkSide = "source" | "destination";
 
 export const isSameScreenFamily = (
-	a: { screenKey: ScreenKey; ancestorKeys?: ScreenKey[] },
-	b: { screenKey: ScreenKey; ancestorKeys?: ScreenKey[] },
+	a: { screenKey: ScreenKey },
+	b: { screenKey: ScreenKey },
 ): boolean => {
 	"worklet";
-	return (
-		a.screenKey === b.screenKey ||
-		(a.ancestorKeys?.includes(b.screenKey) ?? false) ||
-		(b.ancestorKeys?.includes(a.screenKey) ?? false)
-	);
+	return a.screenKey === b.screenKey;
 };
 
 export function findLatestPendingSourceLinkIndex(

package/src/shared/stores/bounds/helpers/matching.ts

@@ -1,4 +1,4 @@
-import type { NavigatorKey, ScreenIdentifier, ScreenKey } from "../types";
+import type { ScreenIdentifier, ScreenKey } from "../types";
 
 export function matchesScreenKey(
 	identifier: ScreenIdentifier | null | undefined,
@@ -7,19 +7,5 @@ export function matchesScreenKey(
 	"worklet";
 	if (!identifier) return false;
 
-	if (identifier.screenKey === key) return true;
-
-	return identifier.ancestorKeys?.includes(key) ?? false;
-}
-
-export function matchesNavigatorKey(
-	identifier: ScreenIdentifier | null | undefined,
-	key: NavigatorKey,
-): boolean {
-	"worklet";
-	if (!identifier) return false;
-
-	if (identifier.navigatorKey === key) return true;
-
-	return identifier.ancestorNavigatorKeys?.includes(key) ?? false;
+	return identifier.screenKey === key;
 }

package/src/shared/stores/bounds/index.ts

@@ -1,4 +1,4 @@
-import { clear, clearByAncestor, clearByBranch } from "./internals/clear";
+import { clear } from "./internals/clear";
 import { getEntry, removeEntry, setEntry } from "./internals/entries";
 import {
 	getGroupActiveId,
@@ -51,7 +51,5 @@ export const BoundStore = {
 	},
 	cleanup: {
 		byScreen: clear,
-		byAncestor: clearByAncestor,
-		byBranch: clearByBranch,
 	},
 };

package/src/shared/stores/bounds/internals/clear.ts

@@ -1,6 +1,6 @@
 import { hasAnyKeys } from "../helpers/keys";
-import { matchesNavigatorKey, matchesScreenKey } from "../helpers/matching";
-import type { NavigatorKey, ScreenEntry, ScreenKey, TagLink } from "../types";
+import { matchesScreenKey } from "../helpers/matching";
+import type { ScreenEntry, ScreenKey, TagLink } from "../types";
 import { type RegistryState, registry } from "./state";
 
 type LinkPredicate = (link: TagLink) => boolean;
@@ -56,43 +56,4 @@ function clear(screenKey: ScreenKey) {
 	);
 }
 
-function clearByAncestor(ancestorKey: ScreenKey) {
-	"worklet";
-	clearRegistry(
-		(entryScreenKey, screenEntry) => {
-			return (
-				entryScreenKey === ancestorKey ||
-				(screenEntry.ancestorKeys?.includes(ancestorKey) ?? false)
-			);
-		},
-		(link) => {
-			return (
-				matchesScreenKey(link.source, ancestorKey) ||
-				matchesScreenKey(link.destination, ancestorKey)
-			);
-		},
-	);
-}
-
-function clearByBranch(branchNavigatorKey: NavigatorKey) {
-	"worklet";
-	if (!branchNavigatorKey) return;
-
-	clearRegistry(
-		(_entryScreenKey, screenEntry) => {
-			return (
-				screenEntry.navigatorKey === branchNavigatorKey ||
-				(screenEntry.ancestorNavigatorKeys?.includes(branchNavigatorKey) ??
-					false)
-			);
-		},
-		(link) => {
-			return (
-				matchesNavigatorKey(link.source, branchNavigatorKey) ||
-				matchesNavigatorKey(link.destination, branchNavigatorKey)
-			);
-		},
-	);
-}
-
-export { clear, clearByAncestor, clearByBranch };
+export { clear };

package/src/shared/stores/bounds/internals/links.ts

@@ -8,7 +8,7 @@ import {
 	selectSourceUpdateTargetIndex,
 } from "../helpers/link.helpers";
 import { ensureTagState } from "../helpers/tag-state.helpers";
-import type { NavigatorKey, ScreenKey, TagID, TagLink } from "../types";
+import type { ScreenKey, TagID, TagLink } from "../types";
 import { type RegistryState, registry } from "./state";
 
 type LinkSourceWriteMode = "capture" | "refresh";
@@ -20,18 +20,12 @@ function setSource(
 	screenKey: ScreenKey,
 	bounds: MeasuredDimensions,
 	styles: StyleProps = {},
-	ancestorKeys?: ScreenKey[],
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
 ) {
 	"worklet";
 	registry.modify(<T extends RegistryState>(state: T): T => {
 		"worklet";
 		const source = {
 			screenKey,
-			ancestorKeys,
-			navigatorKey,
-			ancestorNavigatorKeys,
 			bounds,
 			styles,
 		};
@@ -85,10 +79,7 @@ function setDestination(
 	screenKey: ScreenKey,
 	bounds: MeasuredDimensions,
 	styles: StyleProps = {},
-	ancestorKeys?: ScreenKey[],
 	expectedSourceScreenKey?: ScreenKey,
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
 ) {
 	"worklet";
 	registry.modify(<T extends RegistryState>(state: T): T => {
@@ -107,9 +98,6 @@ function setDestination(
 		const link = stack[targetIndex];
 		const destination = {
 			screenKey,
-			ancestorKeys,
-			navigatorKey,
-			ancestorNavigatorKeys,
 			bounds,
 			styles,
 		};

package/src/shared/stores/bounds/types.ts

@@ -1,13 +1,13 @@
 import type { MeasuredDimensions, StyleProps } from "react-native-reanimated";
 import type { BoundsMethod } from "../../types/bounds.types";
+import type { ScreenKey } from "../../types/screen.types";
 import type {
 	BoundsAnchor,
 	BoundsScaleMode,
 } from "../../utils/bounds/types/options";
 
 export type TagID = string;
-export type ScreenKey = string;
-export type NavigatorKey = string;
+export type { ScreenKey } from "../../types/screen.types";
 
 export type BoundaryConfig = {
 	anchor?: BoundsAnchor;
@@ -20,9 +20,6 @@ export type Entry = {
 	bounds: MeasuredDimensions | null;
 	styles: StyleProps;
 	boundaryConfig?: BoundaryConfig;
-	ancestorKeys?: ScreenKey[];
-	navigatorKey?: NavigatorKey;
-	ancestorNavigatorKeys?: NavigatorKey[];
 };
 
 export type MeasuredEntry = Entry & {
@@ -33,16 +30,10 @@ export type EntryPatch = {
 	bounds?: MeasuredDimensions | null;
 	styles?: StyleProps | null;
 	boundaryConfig?: BoundaryConfig | null;
-	ancestorKeys?: ScreenKey[] | null;
-	navigatorKey?: NavigatorKey | null;
-	ancestorNavigatorKeys?: NavigatorKey[] | null;
 };
 
 export type ScreenIdentifier = {
 	screenKey: ScreenKey;
-	ancestorKeys?: ScreenKey[];
-	navigatorKey?: NavigatorKey;
-	ancestorNavigatorKeys?: NavigatorKey[];
 };
 
 export type TagLink = {

package/src/shared/stores/system.store.ts

@@ -3,6 +3,7 @@ import {
 	makeMutable,
 	type SharedValue,
 } from "react-native-reanimated";
+import { LOGICAL_SETTLE_REQUIRED_FRAMES } from "../constants";
 import type { Layout } from "../types/screen.types";
 import { createStore } from "../utils/create-store";
 
@@ -36,6 +37,11 @@ type SystemStoreState = {
 	 */
 	pendingLifecycleRequestTarget: SharedValue<number>;
 
+	/**
+	 * Number of consecutive frames progress has stayed near its target.
+	 */
+	logicalSettleFrameCount: SharedValue<number>;
+
 	/**
 	 * Number of active blockers preventing a pending lifecycle request from
 	 * starting immediately.
@@ -72,6 +78,7 @@ export const SystemStore = createStore<SystemStoreState, SystemStoreActions>({
 			LifecycleTransitionRequestKind.None,
 		),
 		pendingLifecycleRequestTarget: makeMutable<number>(0),
+		logicalSettleFrameCount: makeMutable(LOGICAL_SETTLE_REQUIRED_FRAMES),
 		pendingLifecycleStartBlockCount: makeMutable<number>(0),
 	}),
 	disposeBag: (bag) => {
@@ -80,6 +87,7 @@ export const SystemStore = createStore<SystemStoreState, SystemStoreActions>({
 		cancelAnimation(bag.measuredContentLayout);
 		cancelAnimation(bag.pendingLifecycleRequestKind);
 		cancelAnimation(bag.pendingLifecycleRequestTarget);
+		cancelAnimation(bag.logicalSettleFrameCount);
 		cancelAnimation(bag.pendingLifecycleStartBlockCount);
 	},
 	actions: (bag) => ({

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

@@ -31,6 +31,7 @@ export type ScreenTransitionOptions = Pick<
 	| "gestureSnapVelocityImpact"
 	| "gestureReleaseVelocityScale"
 	| "gestureResponseDistance"
+	| "gestureProgressMode"
 	| "gestureDrivesProgress"
 	| "gestureActivationArea"
 	| "gestureSnapLocked"
@@ -162,6 +163,22 @@ export type ScreenTransitionState = {
 	snapIndex: number;
 };
 
+export type ScreenTransitionDepthTarget = {
+	/**
+	 * Relative transition depth.
+	 *
+	 * `0` resolves the current transition, negative values resolve ancestors, and
+	 * positive values resolve descendants.
+	 */
+	depth: number;
+};
+
+export type ScreenTransitionTarget = ScreenTransitionDepthTarget;
+
+export type ScreenTransitionAccessor = (
+	target?: ScreenTransitionTarget,
+) => ScreenInterpolationProps | null;
+
 export interface ScreenInterpolationProps {
 	/**
 	 * Values for the screen that came before the current one in the navigation stack.
@@ -222,6 +239,20 @@ export interface ScreenInterpolationProps {
 	 */
 	bounds: BoundsAccessor;
 
+	/**
+	 * Resolves interpolation props for this screen's transition timeline or an
+	 * ancestor transition timeline.
+	 *
+	 * Calling without a target returns the current transition.
+	 * `transition({ depth: -1 })` returns the immediate parent transition.
+	 * `transition({ depth: 1 })` returns the immediate child transition.
+	 * `transition({ depth: 0 })` returns the current transition.
+	 *
+	 * When called from a returned transition scope, targets are resolved relative
+	 * to that scope.
+	 */
+	transition: ScreenTransitionAccessor;
+
 	/**
 	 * The screen state that is currently driving the transition (either current or next, whichever is focused).
 	 */

package/src/shared/types/bounds.types.ts

@@ -212,4 +212,7 @@ export type BoundsAccessor = {
 	) => number;
 };
 
-export type BoundsInterpolationProps = Omit<ScreenInterpolationProps, "bounds">;
+export type BoundsInterpolationProps = Omit<
+	ScreenInterpolationProps,
+	"bounds" | "transition"
+>;

package/src/shared/types/gesture.types.ts

@@ -16,6 +16,8 @@ export type GestureDirection = PanGestureDirection | PinchGestureDirection;
 
 export type ActiveGesture = ResolvedPanGestureDirection | PinchGestureDirection;
 
+export type GestureProgressMode = "progress-driven" | "freeform";
+
 export type SnapPanAxis = "horizontal" | "vertical";
 
 export type ScrollGestureAxis = "vertical" | "horizontal";

package/src/shared/types/index.ts

@@ -4,8 +4,11 @@ export type {
 	AnimationConfig,
 	ScreenInterpolationProps,
 	ScreenStyleInterpolator,
+	ScreenTransitionAccessor,
+	ScreenTransitionDepthTarget,
 	ScreenTransitionOptions,
 	ScreenTransitionState,
+	ScreenTransitionTarget,
 	TransitionInterpolatedStyle,
 	TransitionInterpolatorConfig,
 	TransitionInterpolatorOptions,

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

@@ -3,7 +3,11 @@ import type {
 	ScreenStyleInterpolator,
 	TransitionSpec,
 } from "./animation.types";
-import type { GestureActivationArea, GestureDirection } from "./gesture.types";
+import type {
+	GestureActivationArea,
+	GestureDirection,
+	GestureProgressMode,
+} from "./gesture.types";
 import type { OverlayProps } from "./overlay.types";
 
 export type Layout = {
@@ -219,8 +223,16 @@ export type ScreenTransitionConfig = {
 	 */
 	gestureResponseDistance?: number;
 
+	/**
+	 * Controls whether live gesture displacement drives transition progress or
+	 * stays available as freeform gesture values for custom interpolators.
+	 */
+	gestureProgressMode?: GestureProgressMode;
+
 	/**
 	 * Whether the gesture drives the progress.
+	 *
+	 * @deprecated Use `gestureProgressMode` instead.
 	 */
 	gestureDrivesProgress?: boolean;
 

package/src/shared/utils/animation/animate-to-progress.ts

@@ -22,6 +22,24 @@ interface AnimateToProgressProps {
 	initialVelocity?: number;
 }
 
+const setTransitionLifecycleFlags = (
+	animations: AnimationStoreMap,
+	isClosing: boolean,
+	markEntering: boolean,
+) => {
+	"worklet";
+
+	if (isClosing) {
+		animations.closing.set(TRUE);
+		animations.entering.set(FALSE);
+		return;
+	}
+
+	if (markEntering) {
+		animations.entering.set(TRUE);
+	}
+};
+
 export const animateToProgress = ({
 	target,
 	spec,
@@ -50,7 +68,7 @@ export const animateToProgress = ({
 			? { ...config, velocity: initialVelocity }
 			: config;
 
-	const { progress, willAnimate, animating, closing, entering } = animations;
+	const { progress, willAnimate, progressAnimating, entering } = animations;
 
 	const startAnimation = () => {
 		"worklet";
@@ -59,15 +77,10 @@ export const animateToProgress = ({
 		const shouldClearEnteringOnFinish =
 			!isClosing && (markEntering || entering.get());
 
-		if (isClosing) {
-			closing.set(TRUE);
-			entering.set(FALSE);
-		} else if (markEntering) {
-			entering.set(TRUE);
-		}
+		setTransitionLifecycleFlags(animations, isClosing, markEntering);
 
 		if (!config) {
-			animating.set(FALSE);
+			progressAnimating.set(FALSE);
 			progress.set(value);
 			if (shouldClearEnteringOnFinish) {
 				entering.set(FALSE);
@@ -79,7 +92,7 @@ export const animateToProgress = ({
 			return;
 		}
 
-		animating.set(TRUE); //<-- Do not move this into the callback
+		progressAnimating.set(TRUE); //<-- Do not move this into the callback
 		progress.set(
 			animate(value, effectiveConfig, (finished) => {
 				"worklet";
@@ -93,21 +106,16 @@ export const animateToProgress = ({
 					runOnJS(onAnimationFinish)(finished);
 				}
 
-				// Delay setting animating=FALSE by one frame to ensure final frame is painted
+				// Delay clearing progress animation by one frame to ensure final frame is painted
 				requestAnimationFrame(() => {
-					animating.set(FALSE);
+					progressAnimating.set(FALSE);
 				});
 			}),
 		);
 	};
 
 	if (emitWillAnimate) {
-		if (isClosing) {
-			closing.set(TRUE);
-			entering.set(FALSE);
-		} else if (markEntering) {
-			entering.set(TRUE);
-		}
+		setTransitionLifecycleFlags(animations, isClosing, markEntering);
 
 		willAnimate.set(TRUE);
 		requestAnimationFrame(() => {

package/src/shared/utils/bounds/helpers/create-bounds-accessor-core.ts

@@ -54,6 +54,7 @@ const createBoundsAccessorParts = ({
 			id: options.id,
 			group: options.group,
 		});
+
 		const computed = prepareBoundStyles({
 			props,
 			options,

package/src/shared/utils/bounds/helpers/create-interpolators.ts

@@ -5,13 +5,13 @@ import {
 } from "react-native-reanimated";
 import { ENTER_RANGE, EXIT_RANGE } from "../../../constants";
 import { getEntry } from "../../../stores/bounds/internals/entries";
-import type { ScreenInterpolationProps } from "../../../types/animation.types";
+import type { BoundsInterpolationProps } from "../../../types/bounds.types";
 import type { BoundId } from "../types/options";
 import type { LinkAccessor } from "./create-link-accessor";
 import { interpolateLinkStyle } from "./styles/interpolate-link-style";
 
 type InterpolatorParams = {
-	getProps: () => Omit<ScreenInterpolationProps, "bounds">;
+	getProps: () => BoundsInterpolationProps;
 	getLink: LinkAccessor["getLink"];
 };
 

package/src/shared/utils/bounds/helpers/create-link-accessor.ts

@@ -5,15 +5,15 @@ import type {
 	ResolvedTransitionPair,
 	TagLink,
 } from "../../../stores/bounds/types";
-import type { ScreenInterpolationProps } from "../../../types/animation.types";
 import type {
+	BoundsInterpolationProps,
 	BoundsLink,
 	BoundsLinkComputeOptions,
 } from "../../../types/bounds.types";
 import type { BoundId, BoundsOptionsResult } from "../types/options";
 import { prepareBoundStyles } from "./prepare-bound-styles";
 
-type GetProps = () => Omit<ScreenInterpolationProps, "bounds">;
+type GetProps = () => BoundsInterpolationProps;
 
 export type LinkAccessor = {
 	getMeasured: (tag: BoundId, key?: string) => MeasuredEntry | null;