react-native-screen-transitions 3.13.0-beta.0 → 3.13.0

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

@@ -1,16 +1,10 @@
-import { type ReactNode, useCallback, useLayoutEffect, useMemo } from "react";
-import { useSharedValue } from "react-native-reanimated";
+import { type ReactNode, useMemo } from "react";
 import { createBoundsAccessor } from "../../../utils/bounds";
 import createProvider from "../../../utils/create-provider";
 import { useDescriptorsStore } from "../descriptors";
+import { useCurrentScreenRelationships } from "../use-current-screen-relationships";
 import { useScreenAnimationPipeline } from "./helpers/pipeline";
-import type {
-	RegisterScreenAnimationDescendant,
-	ScreenAnimationAncestorDescendantRegistrar,
-	ScreenAnimationDescendantSources,
-	ScreenAnimationSource,
-	ScreenAnimationTransitionSource,
-} from "./types";
+import type { ScreenAnimationTransitionSource } from "./types";
 
 type Props = {
 	children: ReactNode;
@@ -19,209 +13,76 @@ type Props = {
 export type ScreenAnimationContextValue = ReturnType<
 	typeof useScreenAnimationPipeline
 > & {
-	ancestorScreenAnimationSources: ScreenAnimationSource[];
-	descendantScreenAnimationSources: ScreenAnimationDescendantSources;
-	registerDescendantScreenAnimationSource: RegisterScreenAnimationDescendant;
-	ancestorDescendantScreenAnimationRegistrars: ScreenAnimationAncestorDescendantRegistrar[];
+	transitionSources: readonly ScreenAnimationTransitionSource[];
+	transitionOriginIndex: number;
+	transitionSourcesThroughSelf: readonly ScreenAnimationTransitionSource[];
+	transitionSourcesFromSelf: readonly ScreenAnimationTransitionSource[];
 };
 
-export type ScreenAnimationContextResult = {
-	key: string;
-	value: ScreenAnimationContextValue;
-};
-
-export const { ScreenAnimationProvider, useScreenAnimationStore } =
-	createProvider("ScreenAnimation", {
-		guarded: true,
-		global: true,
-	})<Props, ScreenAnimationContextValue>(
-		(_props, { useParentStore }): ScreenAnimationContextResult => {
-			const currentScreenKey = useDescriptorsStore(
-				(store) => store.derivations.currentScreenKey,
-			);
-			const parentScreenInterpolatorProps = useParentStore(
-				(parentContext) => parentContext?.screenInterpolatorProps,
-			);
-			const parentScreenInterpolatorPropsRevision = useParentStore(
-				(parentContext) => parentContext?.screenInterpolatorPropsRevision,
-			);
-			const parentAncestorScreenAnimationSources = useParentStore(
-				(parentContext) => parentContext?.ancestorScreenAnimationSources,
-			);
-			const parentRegisterDescendantScreenAnimationSource = useParentStore(
-				(parentContext) =>
-					parentContext?.registerDescendantScreenAnimationSource,
-			);
-			const parentAncestorDescendantScreenAnimationRegistrars = useParentStore(
-				(parentContext) =>
-					parentContext?.ancestorDescendantScreenAnimationRegistrars,
-			);
-
-			const parentInterpolatorUpdatesEnabled = useParentStore(
-				(parentContext) => parentContext?.interpolatorUpdatesEnabled,
-			);
-
-			const {
-				interpolatorUpdatesEnabled,
-				screenInterpolatorProps,
-				screenInterpolatorPropsRevision,
-				selectedInterpolatorOptions,
-				nextInterpolator,
-				currentInterpolator,
-			} = useScreenAnimationPipeline(parentInterpolatorUpdatesEnabled ?? true);
-
-			const selfScreenAnimationSource = useMemo<ScreenAnimationSource>(
-				() => ({
-					screenInterpolatorProps,
-					screenInterpolatorPropsRevision,
+const EMPTY_TRANSITION_SOURCES: readonly ScreenAnimationTransitionSource[] = [];
+
+const createScreenAnimationProvider = createProvider("ScreenAnimation", {
+	global: true,
+})<Props, ScreenAnimationContextValue>;
+
+export const {
+	ScreenAnimationProvider,
+	useOptionalScreenAnimationStore,
+	useScreenAnimationStore,
+}: ReturnType<typeof createScreenAnimationProvider> =
+	createScreenAnimationProvider((_props) => {
+		const currentScreenKey = useDescriptorsStore(
+			(store) => store.derivations.currentScreenKey,
+		);
+		const relationships = useCurrentScreenRelationships();
+		const pipeline = useScreenAnimationPipeline();
+
+		const screenAnimationSource = useMemo<ScreenAnimationTransitionSource>(
+			() => ({
+				screenInterpolatorProps: pipeline.screenInterpolatorProps,
+				screenInterpolatorPropsRevision:
+					pipeline.screenInterpolatorPropsRevision,
+				boundsAccessor: createBoundsAccessor(() => {
+					"worklet";
+					return pipeline.screenInterpolatorProps.get();
 				}),
-				[screenInterpolatorProps, screenInterpolatorPropsRevision],
-			);
-
-			const selfScreenAnimationTransitionSource =
-				useMemo<ScreenAnimationTransitionSource>(
-					() => ({
-						...selfScreenAnimationSource,
-						boundsAccessor: createBoundsAccessor(() => {
-							"worklet";
-							return selfScreenAnimationSource.screenInterpolatorProps.get();
-						}),
-					}),
-					[selfScreenAnimationSource],
-				);
-
-			const descendantScreenAnimationSources = useSharedValue<
-				ScreenAnimationDescendantSources["value"]
-			>([]);
-
-			const registerDescendantScreenAnimationSource =
-				useCallback<RegisterScreenAnimationDescendant>(
-					(source, depth) => {
-						descendantScreenAnimationSources.modify(
-							<T extends ScreenAnimationDescendantSources["value"]>(
-								currentSources: T,
-							): T => {
-								"worklet";
-								const existingIndex = currentSources.findIndex(
-									(currentSource) => currentSource.source === source,
-								);
-
-								if (
-									existingIndex !== -1 &&
-									currentSources[existingIndex]?.depth === depth
-								) {
-									return currentSources;
-								}
-
-								const nextSources =
-									existingIndex === -1
-										? [...currentSources, { source, depth }]
-										: currentSources.map((currentSource, index) =>
-												index === existingIndex
-													? { source, depth }
-													: currentSource,
-											);
-
-								return nextSources.sort((a, b) => a.depth - b.depth) as T;
-							},
-						);
-
-						return () => {
-							descendantScreenAnimationSources.modify(
-								<T extends ScreenAnimationDescendantSources["value"]>(
-									currentSources: T,
-								): T => {
-									"worklet";
-									return currentSources.filter(
-										(currentSource) => currentSource.source !== source,
-									) as T;
-								},
-							);
-						};
-					},
-					[descendantScreenAnimationSources],
-				);
-
-			const ancestorScreenAnimationSources = useMemo(() => {
-				if (
-					!parentScreenInterpolatorProps ||
-					!parentScreenInterpolatorPropsRevision ||
-					!parentAncestorScreenAnimationSources
-				) {
-					return [];
-				}
-
-				return [
-					{
-						screenInterpolatorProps: parentScreenInterpolatorProps,
-						screenInterpolatorPropsRevision:
-							parentScreenInterpolatorPropsRevision,
-					},
-					...parentAncestorScreenAnimationSources,
-				];
-			}, [
-				parentScreenInterpolatorProps,
-				parentScreenInterpolatorPropsRevision,
-				parentAncestorScreenAnimationSources,
-			]);
-
-			const ancestorDescendantScreenAnimationRegistrars = useMemo(() => {
-				if (!parentRegisterDescendantScreenAnimationSource) {
-					return [];
-				}
-
-				// Each provider exposes its own descendant registrar and forwards ancestor
-				// registrars, letting a mounted child register with every ancestor scope.
-				return [
-					{
-						register: parentRegisterDescendantScreenAnimationSource,
-						depth: 1,
-					},
-					...(parentAncestorDescendantScreenAnimationRegistrars ?? []).map(
-						(registrar) => ({
-							register: registrar.register,
-							depth: registrar.depth + 1,
-						}),
-					),
-				];
-			}, [
-				parentRegisterDescendantScreenAnimationSource,
-				parentAncestorDescendantScreenAnimationRegistrars,
-			]);
-
-			useLayoutEffect(() => {
-				const cleanups = ancestorDescendantScreenAnimationRegistrars.map(
-					(registrar) =>
-						registrar.register(
-							selfScreenAnimationTransitionSource,
-							registrar.depth,
-						),
-				);
-
-				return () => {
-					for (const cleanup of cleanups) {
-						cleanup();
-					}
-				};
-			}, [
-				ancestorDescendantScreenAnimationRegistrars,
-				selfScreenAnimationTransitionSource,
-			]);
-
-			return {
-				key: currentScreenKey,
-				value: {
-					interpolatorUpdatesEnabled,
-					screenInterpolatorProps,
-					screenInterpolatorPropsRevision,
-					selectedInterpolatorOptions,
-					nextInterpolator,
-					currentInterpolator,
-					ancestorScreenAnimationSources,
-					descendantScreenAnimationSources,
-					registerDescendantScreenAnimationSource,
-					ancestorDescendantScreenAnimationRegistrars,
-				},
-			};
-		},
-	);
+			}),
+			[
+				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],
+		);
+
+		return {
+			key: currentScreenKey,
+			value: {
+				...pipeline,
+				transitionSources,
+				transitionOriginIndex: ancestorSources.length,
+				transitionSourcesThroughSelf,
+				transitionSourcesFromSelf,
+			},
+		};
+	});

package/src/shared/providers/screen/animation/helpers/accessors/use-build-transition-accessor.ts

@@ -3,13 +3,8 @@ import type {
 	ScreenInterpolationProps,
 	ScreenTransitionTarget,
 } from "../../../../../types/animation.types";
-import { createBoundsAccessor } from "../../../../../utils/bounds";
 import type { ScreenAnimationContextValue } from "../../animation.provider";
-import type {
-	ScreenAnimationDescendantSources,
-	ScreenAnimationSource,
-	ScreenAnimationTransitionSource,
-} from "../../types";
+import type { ScreenAnimationTransitionSource } from "../../types";
 
 type TransitionSourceIndex = number;
 
@@ -17,10 +12,7 @@ export type TransitionAccessorSource = ScreenAnimationTransitionSource;
 
 type TransitionAccessorStore = Pick<
 	ScreenAnimationContextValue,
-	| "screenInterpolatorProps"
-	| "screenInterpolatorPropsRevision"
-	| "ancestorScreenAnimationSources"
-	| "descendantScreenAnimationSources"
+	"transitionSources" | "transitionOriginIndex"
 >;
 
 const resolveTargetIndex = (
@@ -48,29 +40,9 @@ const resolveTargetIndex = (
 export const createTransitionAccessor = (
 	sources: readonly TransitionAccessorSource[],
 	originIndex = 0,
-	descendantSources?: ScreenAnimationDescendantSources,
 ) => {
 	"worklet";
 
-	const getSources = (): readonly TransitionAccessorSource[] => {
-		"worklet";
-		if (!descendantSources) {
-			return sources;
-		}
-
-		const descendants = descendantSources.get();
-		if (descendants.length === 0) {
-			return sources;
-		}
-
-		const currentSources = sources.slice();
-		for (let index = 0; index < descendants.length; index++) {
-			currentSources.push(descendants[index].source);
-		}
-
-		return currentSources;
-	};
-
 	const buildScope = (
 		sourceIndex: TransitionSourceIndex,
 		currentSources: readonly TransitionAccessorSource[],
@@ -104,64 +76,21 @@ export const createTransitionAccessor = (
 
 	return (target?: ScreenTransitionTarget): ScreenInterpolationProps | null => {
 		"worklet";
-		const currentSources = getSources();
-		const targetIndex = resolveTargetIndex(
-			target,
-			originIndex,
-			currentSources.length,
-		);
+		const targetIndex = resolveTargetIndex(target, originIndex, sources.length);
 		if (targetIndex === -1) {
 			return null;
 		}
 
-		return buildScope(targetIndex, currentSources);
+		return buildScope(targetIndex, sources);
 	};
 };
 
-const buildSourceBoundsAccessor = (source: ScreenAnimationSource) => {
-	"worklet";
-	return createBoundsAccessor(() => {
-		"worklet";
-		return source.screenInterpolatorProps.get();
-	});
-};
-
 export const useBuildTransitionAccessor = ({
-	screenInterpolatorProps,
-	screenInterpolatorPropsRevision,
-	ancestorScreenAnimationSources,
-	descendantScreenAnimationSources,
+	transitionSources,
+	transitionOriginIndex,
 }: TransitionAccessorStore) => {
-	return useMemo(() => {
-		const selfSource = {
-			screenInterpolatorProps,
-			screenInterpolatorPropsRevision,
-		};
-
-		const transitionSources: TransitionAccessorSource[] =
-			ancestorScreenAnimationSources.map((source) => ({
-				...source,
-				boundsAccessor: buildSourceBoundsAccessor(source),
-			}));
-
-		const selfTransitionSource = {
-			...selfSource,
-			boundsAccessor: buildSourceBoundsAccessor(selfSource),
-		};
-
-		transitionSources.reverse();
-		const originIndex = transitionSources.length;
-		transitionSources.push(selfTransitionSource);
-
-		return createTransitionAccessor(
-			transitionSources,
-			originIndex,
-			descendantScreenAnimationSources,
-		);
-	}, [
-		screenInterpolatorProps,
-		screenInterpolatorPropsRevision,
-		ancestorScreenAnimationSources,
-		descendantScreenAnimationSources,
-	]);
+	return useMemo(
+		() => createTransitionAccessor(transitionSources, transitionOriginIndex),
+		[transitionSources, transitionOriginIndex],
+	);
 };

package/src/shared/providers/screen/animation/helpers/hydrate-transition-state/types.ts

@@ -11,7 +11,6 @@ import type { BaseStackRoute } from "../../../../../types/stack.types";
 export type BuiltState = {
 	transitionProgress: SharedValue<number>;
 	visualProgress: SharedValue<number>;
-	stackProgress: SharedValue<number>;
 	willAnimate: SharedValue<number>;
 	closing: SharedValue<number>;
 	progressAnimating: SharedValue<number>;

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

@@ -11,7 +11,10 @@ import {
 	createScreenTransitionState,
 	DEFAULT_SCREEN_TRANSITION_STATE,
 } from "../../../../constants";
-import { useStack } from "../../../../hooks/navigation/use-stack";
+import {
+	useStack,
+	useStackProgressEntries,
+} from "../../../../hooks/navigation/use-stack";
 import type {
 	ScreenInterpolationProps,
 	ScreenStyleInterpolator,
@@ -23,9 +26,8 @@ import { buildScreenTransitionOptions } from "./build-screen-transition-options"
 import { updateDerivations } from "./derivations";
 import { hasTransitionsEnabled } from "./has-transitions-enabled";
 import { hydrateTransitionState } from "./hydrate-transition-state";
-import { shouldUpdateScreenInterpolator } from "./interpolator-participation";
 import type { SelectedInterpolatorOptions } from "./selected-interpolator-options";
-import { resolveStackProgress } from "./stack-progress";
+import { readStackProgress, type StackProgressEntry } from "./stack-progress";
 import { useBuildTransitionState } from "./use-build-transition-state";
 import { toPlainRoute, toPlainValue } from "./worklet";
 
@@ -35,7 +37,6 @@ export type ScreenInterpolatorFrame = Omit<
 >;
 
 interface ScreenAnimationPipeline {
-	interpolatorUpdatesEnabled: boolean;
 	screenInterpolatorProps: SharedValue<ScreenInterpolatorFrame>;
 	screenInterpolatorPropsRevision: DerivedValue<number>;
 	selectedInterpolatorOptions: SharedValue<SelectedInterpolatorOptions>;
@@ -214,6 +215,8 @@ const hydrateInterpolatorFrame = <TFrame extends ScreenInterpolatorFrame>({
 	prevAnimation,
 	nextHasTransitions,
 	interpolatorOptions,
+	stackProgressEntries,
+	currentRouteKey,
 }: {
 	frame: TFrame;
 	dimensions: ScreenInterpolatorFrame["layouts"]["screen"];
@@ -223,6 +226,8 @@ const hydrateInterpolatorFrame = <TFrame extends ScreenInterpolatorFrame>({
 	prevAnimation: BuiltTransitionState | undefined;
 	nextHasTransitions: boolean;
 	interpolatorOptions: SelectedInterpolatorOptions;
+	stackProgressEntries: readonly StackProgressEntry[];
+	currentRouteKey: string;
 }): TFrame => {
 	"worklet";
 	const shouldApplyOptionsToCurrent = interpolatorOptions.owner === "current";
@@ -230,12 +235,6 @@ const hydrateInterpolatorFrame = <TFrame extends ScreenInterpolatorFrame>({
 		interpolatorOptions.owner === "next" &&
 		!!nextAnimation &&
 		nextHasTransitions;
-	const previousCurrentProgress = currentAnimation?.visualProgress.get();
-	const previousNextProgress =
-		nextAnimation && nextHasTransitions
-			? nextAnimation.visualProgress.get()
-			: undefined;
-
 	frame.previous = prevAnimation
 		? hydrateTransitionState(prevAnimation, dimensions)
 		: undefined;
@@ -262,45 +261,31 @@ const hydrateInterpolatorFrame = <TFrame extends ScreenInterpolatorFrame>({
 
 	updateDerivations(frame);
 
-	frame.stackProgress = resolveStackProgress(
-		currentAnimation?.stackProgress,
+	frame.stackProgress = readStackProgress(
+		stackProgressEntries,
+		currentRouteKey,
 		frame.progress,
-		frame.current.progress,
-		previousCurrentProgress,
-		frame.next?.progress,
-		previousNextProgress,
 	);
 	frame.logicallySettled = frame.active.settled;
 
 	return frame;
 };
 
-export function useScreenAnimationPipeline(
-	parentInterpolatorUpdatesEnabled = true,
-): ScreenAnimationPipeline {
+export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 	const transitionsAlwaysOn = useStack(
 		(stack) => stack.flags.TRANSITIONS_ALWAYS_ON,
 	);
 	const dimensions = useWindowDimensions();
 	const insets = useSafeAreaInsets();
+	const stackProgressEntries = useStackProgressEntries();
 
 	const currDescriptor = useDescriptorsStore((store) => store.current);
 	const nextDescriptor = useDescriptorsStore((store) => store.next);
 	const prevDescriptor = useDescriptorsStore((store) => store.previous);
-	const currentActivity = useStack((stack) => {
-		const routeIndex = stack.routeKeys.indexOf(currDescriptor.route.key);
-		return stack.scenes[routeIndex]?.activity;
-	});
-	const interpolatorUpdatesEnabled =
-		parentInterpolatorUpdatesEnabled &&
-		shouldUpdateScreenInterpolator(
-			currentActivity ?? "active",
-			currDescriptor.options.experimental_updateInactiveInterpolators === true,
-		);
-
 	const currentAnimation = useBuildTransitionState(currDescriptor);
 	const nextAnimation = useBuildTransitionState(nextDescriptor);
 	const prevAnimation = useBuildTransitionState(prevDescriptor);
+	const currentRouteKey = currDescriptor.route.key;
 
 	const nextRouteKey = nextDescriptor?.route?.key;
 	const nextHasTransitions =
@@ -326,50 +311,40 @@ export function useScreenAnimationPipeline(
 		});
 
 	const propsRevisionState = useSharedValue({ value: 0 });
-	const screenInterpolatorPropsRevision = useDerivedValue<number>(
-		interpolatorUpdatesEnabled
-			? () => {
-					"worklet";
-					screenInterpolatorProps.modify((frame) => {
-						"worklet";
-						const interpolatorOptions = selectedInterpolatorOptions.get();
-						return hydrateInterpolatorFrame({
-							frame,
-							dimensions,
-							insets,
-							currentAnimation,
-							nextAnimation,
-							prevAnimation,
-							nextHasTransitions,
-							interpolatorOptions,
-						});
-					}, false);
-
-					// Critical reactive dependency for `screenInterpolatorProps`.
-					//
-					// `screenInterpolatorProps` is mutated in place to avoid allocating a large
-					// interpolator frame every tick. Consumers must read this revision before
-					// reading `screenInterpolatorProps`, otherwise Reanimated may not subscribe
-					// to frame updates and can observe stale transition state.
-					propsRevisionState.modify((revision) => {
-						"worklet";
-						revision.value += 1;
-						return revision;
-					}, false);
-
-					return propsRevisionState.get().value;
-				}
-			: () => {
-					"worklet";
-					return propsRevisionState.get().value;
-				},
-	);
+	const screenInterpolatorPropsRevision = useDerivedValue<number>(() => {
+		"worklet";
+		screenInterpolatorProps.modify((frame) => {
+			"worklet";
+			const interpolatorOptions = selectedInterpolatorOptions.get();
+			return hydrateInterpolatorFrame({
+				frame,
+				dimensions,
+				insets,
+				currentAnimation,
+				nextAnimation,
+				prevAnimation,
+				nextHasTransitions,
+				interpolatorOptions,
+				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;
+	const currentInterpolator = currDescriptor.options.screenStyleInterpolator;
 
 	return {
-		interpolatorUpdatesEnabled,
 		screenInterpolatorProps,
 		screenInterpolatorPropsRevision,
 		selectedInterpolatorOptions,

package/src/shared/providers/screen/animation/helpers/read-screen-animation-revisions.ts

@@ -1,39 +1,15 @@
 import type { SharedValue } from "react-native-reanimated";
-import type {
-	ScreenAnimationDescendantSources,
-	ScreenAnimationSource,
-	ScreenInterpolatorPropsRevision,
-} from "../types";
+import type { ScreenAnimationTransitionSource } from "../types";
 
 type ScreenInterpolatorExternalDeps = Pick<SharedValue<unknown>, "get">[];
 
 export const readScreenAnimationRevisions = (
-	screenInterpolatorPropsRevision: ScreenInterpolatorPropsRevision,
-	ancestorScreenAnimationSources: ScreenAnimationSource[],
-	descendantScreenAnimationSources: ScreenAnimationDescendantSources,
-	screenInterpolatorExternalDeps?: ScreenInterpolatorExternalDeps,
+	sources: readonly ScreenAnimationTransitionSource[],
+	externalRevisions: ScreenInterpolatorExternalDeps = [],
 ) => {
 	"worklet";
-	screenInterpolatorPropsRevision.get();
-
-	for (let index = 0; index < ancestorScreenAnimationSources.length; index++) {
-		ancestorScreenAnimationSources[
-			index
-		]?.screenInterpolatorPropsRevision.get();
-	}
-
-	const descendantSources = descendantScreenAnimationSources.get();
-	for (let index = 0; index < descendantSources.length; index++) {
-		descendantSources[index]?.source.screenInterpolatorPropsRevision.get();
-	}
-
-	if (screenInterpolatorExternalDeps) {
-		for (
-			let index = 0;
-			index < screenInterpolatorExternalDeps.length;
-			index++
-		) {
-			screenInterpolatorExternalDeps[index]?.get();
-		}
+	for (const source of sources) {
+		source.screenInterpolatorPropsRevision.get();
 	}
+	for (const revision of externalRevisions) revision.get();
 };