react-native-screen-transitions 3.12.0 → 3.13.0-beta.1

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

@@ -0,0 +1,415 @@
+import type { SharedValue } from "react-native-reanimated";
+import {
+	registerWorkletScreen,
+	screenBelongsToScope,
+	unregisterWorkletScreen,
+} from "../../../factories/screen-topology";
+import {
+	ensurePairDestinationRequests,
+	ensurePairGroups,
+	ensurePairLinks,
+	ensurePairSourceRequests,
+	getDestinationScreenKeyFromPairKey,
+	getGroupKeyFromTag,
+	getLinkKeyFromTag,
+	getSourceScreenKeyFromPairKey,
+} from "../helpers/link-pairs.helpers";
+import type {
+	BoundsScreenNode,
+	BoundTag,
+	EntryPatch,
+	LinkKey,
+	LinkPairsState,
+	ScreenKey,
+	ScreenPairKey,
+	TagID,
+} from "../types";
+import { removeEntry, setEntry } from "./entries";
+import { boundaryRegistry, boundsScreens, pairs } from "./state";
+
+type MeasurementRequest = {
+	type: "source" | "destination";
+	pairKey: ScreenPairKey;
+};
+
+type RegisterScreenParams = {
+	screenKey: ScreenKey;
+	parentScreenKey?: ScreenKey;
+	animationProgress: SharedValue<number>;
+	pendingLifecycleStartBlockCount: SharedValue<number>;
+};
+
+type RegisterBoundaryParams = {
+	boundTag: BoundTag;
+	screenKey: ScreenKey;
+	entry: EntryPatch;
+};
+
+type RequestBoundaryMeasurementsParams = {
+	pairKey: ScreenPairKey;
+	tag: TagID;
+	destination: boolean;
+	refresh: boolean;
+};
+
+const getRequestedLinkKey = (
+	state: LinkPairsState,
+	pairKey: ScreenPairKey,
+	tag: TagID,
+): LinkKey => {
+	"worklet";
+	const requestedLinkKey = getLinkKeyFromTag(tag);
+	const group = getGroupKeyFromTag(tag);
+	return group
+		? (state[pairKey]?.groups[group]?.activeId ?? requestedLinkKey)
+		: requestedLinkKey;
+};
+
+const getConcreteTag = (
+	state: LinkPairsState,
+	pairKey: ScreenPairKey,
+	tag: TagID,
+): TagID => {
+	"worklet";
+	const group = getGroupKeyFromTag(tag);
+	const linkKey = getRequestedLinkKey(state, pairKey, tag);
+	return group ? `${group}:${linkKey}` : linkKey;
+};
+
+const hasRegisteredDestination = (
+	pairKey: ScreenPairKey,
+	tag: TagID,
+): boolean => {
+	"worklet";
+	const destinationRoot = getDestinationScreenKeyFromPairKey(pairKey);
+	if (!destinationRoot) return false;
+
+	const screens = boundaryRegistry.get()[tag]?.screens;
+	for (const screenKey in screens) {
+		if (screenBelongsToScope(screenKey, destinationRoot)) return true;
+	}
+
+	return false;
+};
+
+const hasRegisteredSource = (pairKey: ScreenPairKey, tag: TagID): boolean => {
+	"worklet";
+	const sourceRoot = getSourceScreenKeyFromPairKey(pairKey);
+	const screens = boundaryRegistry.get()[tag]?.screens;
+	for (const screenKey in screens) {
+		if (screenBelongsToScope(screenKey, sourceRoot)) return true;
+	}
+
+	return false;
+};
+
+const claimDestinationBlock = (pairKey: ScreenPairKey, tag: TagID) => {
+	"worklet";
+	const state = pairs.get();
+	const linkKey = getRequestedLinkKey(state, pairKey, tag);
+	const pair = state[pairKey];
+	if (
+		!pair?.destinationRequests?.[linkKey] ||
+		pair.blockedDestinations?.[linkKey]
+	) {
+		return;
+	}
+
+	const concreteTag = getConcreteTag(state, pairKey, tag);
+	if (
+		!hasRegisteredSource(pairKey, concreteTag) ||
+		!hasRegisteredDestination(pairKey, concreteTag)
+	) {
+		return;
+	}
+
+	const destinationRoot = getDestinationScreenKeyFromPairKey(pairKey);
+	const destinationScreen = boundsScreens.get()[destinationRoot];
+	if (!destinationScreen || destinationScreen.animationProgress.get() > 0) {
+		return;
+	}
+
+	destinationScreen.pendingLifecycleStartBlockCount.modify(
+		<T extends number>(count: T): T => {
+			"worklet";
+			return (count + 1) as T;
+		},
+	);
+
+	pairs.modify(<T extends LinkPairsState>(current: T): T => {
+		"worklet";
+		const currentPair = current[pairKey];
+		if (!currentPair) return current;
+		if (!currentPair.blockedDestinations) {
+			currentPair.blockedDestinations = {};
+		}
+		currentPair.blockedDestinations[linkKey] = true;
+		return current;
+	});
+};
+
+const releaseDestinationBlock = (pairKey: ScreenPairKey, linkKey: LinkKey) => {
+	"worklet";
+	const pair = pairs.get()[pairKey];
+	if (!pair?.blockedDestinations?.[linkKey]) return;
+
+	const destinationRoot = getDestinationScreenKeyFromPairKey(pairKey);
+	const destinationScreen = boundsScreens.get()[destinationRoot];
+	destinationScreen?.pendingLifecycleStartBlockCount.modify(
+		<T extends number>(count: T): T => {
+			"worklet";
+			return Math.max(0, count - 1) as T;
+		},
+	);
+
+	pairs.modify(<T extends LinkPairsState>(state: T): T => {
+		"worklet";
+		delete state[pairKey]?.blockedDestinations?.[linkKey];
+		return state;
+	});
+};
+
+const releaseDestinationBlockWhenReady = (
+	pairKey: ScreenPairKey,
+	linkKey: LinkKey,
+) => {
+	"worklet";
+	const pair = pairs.get()[pairKey];
+	const link = pair?.links[linkKey];
+	if (!link?.source || !link.destination) return;
+	if (link.source.escapeClipping && !pair.portalReadySources?.[linkKey]) return;
+	releaseDestinationBlock(pairKey, linkKey);
+};
+
+export function registerScreen(params: RegisterScreenParams) {
+	"worklet";
+	const node: BoundsScreenNode = {
+		animationProgress: params.animationProgress,
+		pendingLifecycleStartBlockCount: params.pendingLifecycleStartBlockCount,
+	};
+	registerWorkletScreen({
+		screenKey: params.screenKey,
+		parentScreenKey: params.parentScreenKey,
+	});
+	boundsScreens.modify(<T extends typeof boundsScreens.value>(state: T): T => {
+		"worklet";
+		(state as typeof boundsScreens.value)[params.screenKey] = node;
+		return state;
+	});
+
+	const state = pairs.get();
+	for (const pairKey in state) {
+		const requests = state[pairKey]?.destinationRequests;
+		for (const linkKey in requests) {
+			claimDestinationBlock(pairKey, linkKey);
+		}
+	}
+}
+
+export function unregisterScreen(screenKey: ScreenKey) {
+	"worklet";
+	unregisterWorkletScreen(screenKey);
+	boundsScreens.modify(<T extends typeof boundsScreens.value>(state: T): T => {
+		"worklet";
+		delete state[screenKey];
+		return state;
+	});
+}
+
+export function registerBoundary({
+	boundTag,
+	screenKey,
+	entry,
+}: RegisterBoundaryParams) {
+	"worklet";
+	setEntry(boundTag.tag, screenKey, entry);
+
+	const state = pairs.get();
+	for (const pairKey in state) {
+		const linkKey = getRequestedLinkKey(state, pairKey, boundTag.tag);
+		if (state[pairKey]?.destinationRequests?.[linkKey]) {
+			claimDestinationBlock(pairKey, boundTag.tag);
+		}
+	}
+}
+
+export function unregisterBoundary(boundTag: BoundTag, screenKey: ScreenKey) {
+	"worklet";
+	removeEntry(boundTag.tag, screenKey);
+	if (!boundsScreens.get()[screenKey]) return;
+
+	const state = pairs.get();
+	for (const pairKey in state) {
+		const concreteTag = getConcreteTag(state, pairKey, boundTag.tag);
+		const type =
+			screenBelongsToScope(screenKey, getSourceScreenKeyFromPairKey(pairKey)) &&
+			!hasRegisteredSource(pairKey, concreteTag)
+				? "source"
+				: screenBelongsToScope(
+							screenKey,
+							getDestinationScreenKeyFromPairKey(pairKey),
+						) && !hasRegisteredDestination(pairKey, concreteTag)
+					? "destination"
+					: null;
+		if (!type) continue;
+
+		abandonBoundaryMeasurement({
+			type,
+			pairKey,
+			tag: getRequestedLinkKey(state, pairKey, boundTag.tag),
+		});
+	}
+}
+
+export function requestBoundaryMeasurements({
+	pairKey,
+	tag,
+	destination,
+	refresh,
+}: RequestBoundaryMeasurementsParams) {
+	"worklet";
+	const requestedLinkKey = getLinkKeyFromTag(tag);
+	const group = getGroupKeyFromTag(tag);
+	const previousActiveId = group
+		? pairs.get()[pairKey]?.groups[group]?.activeId
+		: undefined;
+
+	if (previousActiveId && previousActiveId !== requestedLinkKey) {
+		releaseDestinationBlock(pairKey, previousActiveId);
+	}
+
+	pairs.modify(<T extends LinkPairsState>(state: T): T => {
+		"worklet";
+		const groups = ensurePairGroups(state, pairKey);
+		if (group && groups[group]?.activeId !== requestedLinkKey) {
+			groups[group] = {
+				activeId: requestedLinkKey,
+				initialId: groups[group]?.initialId ?? requestedLinkKey,
+			};
+			if (previousActiveId) {
+				delete state[pairKey]?.sourceRequests?.[previousActiveId];
+				delete state[pairKey]?.destinationRequests?.[previousActiveId];
+			}
+		}
+
+		const linkKey = getRequestedLinkKey(state, pairKey, tag);
+		const pair = state[pairKey];
+		const link = ensurePairLinks(state, pairKey)[linkKey];
+		const refreshing = !!pair?.refreshingLinks?.[linkKey];
+		const startsRefresh = refresh && !refreshing;
+
+		if (!pair.refreshingLinks) pair.refreshingLinks = {};
+		if (refresh) {
+			pair.refreshingLinks[linkKey] = true;
+		} else {
+			delete pair.refreshingLinks[linkKey];
+		}
+
+		if (!link?.source || startsRefresh) {
+			ensurePairSourceRequests(state, pairKey)[linkKey] = true;
+			delete pair.portalReadySources?.[linkKey];
+		}
+
+		if (destination) {
+			if (group) {
+				if (!pair.destinationGroupDemands) pair.destinationGroupDemands = {};
+				pair.destinationGroupDemands[group] = true;
+			} else {
+				if (!pair.destinationLinkDemands) pair.destinationLinkDemands = {};
+				pair.destinationLinkDemands[linkKey] = true;
+			}
+
+			if (!link?.destination || startsRefresh) {
+				ensurePairDestinationRequests(state, pairKey)[linkKey] = true;
+			}
+		}
+
+		return state;
+	});
+
+	if (destination) claimDestinationBlock(pairKey, tag);
+}
+
+export function getBoundaryMeasurementRequest(
+	tag: TagID,
+	screenKey: ScreenKey,
+	state: LinkPairsState = pairs.get(),
+): MeasurementRequest | null {
+	"worklet";
+	const linkKey = getLinkKeyFromTag(tag);
+	const group = getGroupKeyFromTag(tag);
+	let match: MeasurementRequest | null = null;
+
+	for (const pairKey in state) {
+		const pair = state[pairKey];
+		if (group && pair?.groups[group]?.activeId !== linkKey) continue;
+
+		const sourceRoot = getSourceScreenKeyFromPairKey(pairKey);
+		if (
+			pair?.sourceRequests?.[linkKey] &&
+			screenBelongsToScope(screenKey, sourceRoot)
+		) {
+			match = { type: "source", pairKey };
+		}
+
+		const destinationRoot = getDestinationScreenKeyFromPairKey(pairKey);
+		if (
+			pair?.destinationRequests?.[linkKey] &&
+			destinationRoot &&
+			screenBelongsToScope(screenKey, destinationRoot)
+		) {
+			match = { type: "destination", pairKey };
+		}
+	}
+
+	return match;
+}
+
+export function completeBoundaryMeasurement(
+	target: MeasurementRequest,
+	tag: TagID,
+) {
+	"worklet";
+	const linkKey = getLinkKeyFromTag(tag);
+	releaseDestinationBlockWhenReady(target.pairKey, linkKey);
+}
+
+export function markBoundaryPortalReady(pairKey: ScreenPairKey, tag: TagID) {
+	"worklet";
+	const linkKey = getLinkKeyFromTag(tag);
+	pairs.modify(<T extends LinkPairsState>(state: T): T => {
+		"worklet";
+		const pair = state[pairKey];
+		if (!pair) return state;
+		if (!pair.portalReadySources) pair.portalReadySources = {};
+		pair.portalReadySources[linkKey] = true;
+		return state;
+	});
+	releaseDestinationBlockWhenReady(pairKey, linkKey);
+}
+
+export function abandonBoundaryMeasurement(
+	params: MeasurementRequest & { tag: TagID },
+) {
+	"worklet";
+	const linkKey = getLinkKeyFromTag(params.tag);
+	const pair = pairs.get()[params.pairKey];
+	const hasPendingRequest =
+		params.type === "source"
+			? !!pair?.sourceRequests?.[linkKey]
+			: !!pair?.destinationRequests?.[linkKey];
+	const hasDestinationBlock = !!pair?.blockedDestinations?.[linkKey];
+	if (!hasPendingRequest && !hasDestinationBlock) return;
+
+	pairs.modify(<T extends LinkPairsState>(state: T): T => {
+		"worklet";
+		if (params.type === "source") {
+			delete state[params.pairKey]?.sourceRequests?.[linkKey];
+		} else {
+			delete state[params.pairKey]?.destinationRequests?.[linkKey];
+		}
+		return state;
+	});
+
+	releaseDestinationBlock(params.pairKey, linkKey);
+}

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

@@ -62,43 +62,6 @@ function getEntry(tag: TagID, key: ScreenKey): Entry | null {
 	return boundaryRegistry.get()[tag]?.screens[key] ?? null;
 }
 
-function getMatchingSourceScreenKey(
-	tag: TagID,
-	destinationScreenKey: ScreenKey,
-	preferredScreenKey?: ScreenKey,
-	excludedScreenKeys?: readonly ScreenKey[],
-): ScreenKey | null {
-	"worklet";
-	const screens = boundaryRegistry.get()[tag]?.screens;
-	if (!screens) return null;
-	const isExcluded = (screenKey: ScreenKey) => {
-		"worklet";
-		for (let index = 0; index < (excludedScreenKeys?.length ?? 0); index++) {
-			if (excludedScreenKeys?.[index] === screenKey) {
-				return true;
-			}
-		}
-		return false;
-	};
-	if (
-		preferredScreenKey &&
-		preferredScreenKey !== destinationScreenKey &&
-		!isExcluded(preferredScreenKey) &&
-		screens[preferredScreenKey]
-	) {
-		return preferredScreenKey;
-	}
-
-	let latestScreenKey: ScreenKey | null = null;
-	for (const screenKey in screens) {
-		if (screenKey !== destinationScreenKey && !isExcluded(screenKey)) {
-			latestScreenKey = screenKey;
-		}
-	}
-
-	return latestScreenKey;
-}
-
 function setEntry(tag: TagID, screenKey: ScreenKey, patch: EntryPatch) {
 	"worklet";
 	boundaryRegistry.modify(<T extends BoundaryEntriesState>(state: T): T => {
@@ -127,4 +90,4 @@ function removeEntry(tag: TagID, screenKey: ScreenKey) {
 	});
 }
 
-export { getEntry, getMatchingSourceScreenKey, removeEntry, setEntry };
+export { getEntry, removeEntry, setEntry };

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

@@ -1,4 +1,5 @@
 import type { MeasuredDimensions, StyleProps } from "react-native-reanimated";
+import { screenBelongsToScope } from "../../../factories/screen-topology";
 import {
 	createGroupTag,
 	ensurePairGroups,
@@ -11,7 +12,6 @@ import {
 	getDestination as getPairDestination,
 	getLink as getPairLink,
 	getSource as getPairSource,
-	getSourceScreenKeyFromPairKey,
 } from "../helpers/link-pairs.helpers";
 import type {
 	BoundaryRuntimeFlags,
@@ -315,33 +315,21 @@ function setDestination(
 			group,
 			runtimeFlags,
 		);
+		delete state[pairKey]?.destinationRequests?.[linkKey];
 
 		return state;
 	});
 }
 
 function setActiveGroupId(pairKey: ScreenPairKey, group: GroupKey, tag: TagID) {
-	"worklet";
-	pairs.modify(<T extends LinkPairsState>(state: T): T => {
-		"worklet";
-		writeGroup(state, pairKey, group, getLinkKeyFromTag(tag));
-		return state;
-	});
-}
-
-function requestSourceMeasure(pairKey: ScreenPairKey, tag: TagID) {
 	"worklet";
 	pairs.modify(<T extends LinkPairsState>(state: T): T => {
 		"worklet";
 		const linkKey = getLinkKeyFromTag(tag);
-		const link = getPairLink(state, pairKey, linkKey);
-
-		if (link?.source || state[pairKey]?.sourceRequests?.[linkKey]) {
-			return state;
+		writeGroup(state, pairKey, group, linkKey);
+		if (!getPairLink(state, pairKey, linkKey)?.source) {
+			ensurePairSourceRequests(state, pairKey)[linkKey] = true;
 		}
-
-		ensurePairSourceRequests(state, pairKey)[linkKey] = true;
-
 		return state;
 	});
 }
@@ -374,14 +362,18 @@ function getResolvedLink(
 	const state = pairs.get();
 	const linkKey = getLinkKeyFromTag(tag);
 	const group = getGroupKeyFromTag(tag);
-	const link = getPairLink(state, pairKey, linkKey);
+	const activeId = group
+		? state[pairKey]?.groups?.[group]?.activeId
+		: undefined;
+	const resolvedLinkKey = activeId ?? linkKey;
+	const link = getPairLink(state, pairKey, resolvedLinkKey);
 
 	// Group active ids can update before the new member has a full source/destination
 	// link. As soon as the requested member has source bounds, prefer it; only
 	// fall back while the requested member has no source yet.
 	if (!group || hasSourceLink(link)) {
 		return {
-			tag,
+			tag: group ? createGroupTag(group, resolvedLinkKey) : tag,
 			link,
 		};
 	}
@@ -404,34 +396,34 @@ function getResolvedLink(
 	};
 }
 
-function getPairKeyForSource(
+function getPairKeyForDestination(
 	tag: TagID,
 	screenKey: ScreenKey,
 ): ScreenPairKey | null {
 	"worklet";
 	const state = pairs.get();
-	const linkKey = getLinkKeyFromTag(tag);
+	const group = getGroupKeyFromTag(tag);
 	for (const pairKey in state) {
-		if (getSourceScreenKeyFromPairKey(pairKey) !== screenKey) continue;
+		const resolvedLink = getResolvedLink(pairKey, tag).link;
+		if (!resolvedLink) continue;
 		if (
-			getResolvedLink(pairKey, tag).link?.destination ||
-			state[pairKey]?.sourceRequests?.[linkKey]
+			screenBelongsToScope(
+				screenKey,
+				getDestinationScreenKeyFromPairKey(pairKey),
+			) ||
+			resolvedLink.destination?.screenKey === screenKey
 		) {
 			return pairKey;
 		}
-	}
-	return null;
-}
 
-function getPairKeyForDestination(
-	tag: TagID,
-	screenKey: ScreenKey,
-): ScreenPairKey | null {
-	"worklet";
-	const state = pairs.get();
-	for (const pairKey in state) {
-		if (getDestinationScreenKeyFromPairKey(pairKey) !== screenKey) continue;
-		if (getResolvedLink(pairKey, tag).link) return pairKey;
+		if (!group) continue;
+		const links = state[pairKey]?.links;
+		for (const linkKey in links) {
+			const link = links[linkKey];
+			if (link?.group === group && link.destination?.screenKey === screenKey) {
+				return pairKey;
+			}
+		}
 	}
 	return null;
 }
@@ -457,10 +449,8 @@ export {
 	getDestination,
 	getLink,
 	getPairKeyForDestination,
-	getPairKeyForSource,
 	getResolvedLink,
 	getSource,
-	requestSourceMeasure,
 	setActiveGroupId,
 	setDestination,
 	setSource,

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

@@ -1,5 +1,11 @@
 import { makeMutable } from "react-native-reanimated";
-import type { Entry, LinkPairsState, ScreenKey, TagID } from "../types";
+import type {
+	BoundsScreenState,
+	Entry,
+	LinkPairsState,
+	ScreenKey,
+	TagID,
+} from "../types";
 
 export type BoundaryEntriesState = Record<
 	TagID,
@@ -31,3 +37,6 @@ export const boundaryRegistry = makeMutable<BoundaryEntriesState>({});
  * }
  */
 export const pairs = makeMutable<LinkPairsState>({});
+
+/** Bounds-only runtime values keyed by screen. Relationships live in topology. */
+export const boundsScreens = makeMutable<BoundsScreenState>({});

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

@@ -1,4 +1,8 @@
-import type { MeasuredDimensions, StyleProps } from "react-native-reanimated";
+import type {
+	MeasuredDimensions,
+	SharedValue,
+	StyleProps,
+} from "react-native-reanimated";
 import type { BoundsMethod } from "../../types/bounds.types";
 import type { ScreenKey } from "../../types/screen.types";
 import type {
@@ -128,6 +132,19 @@ export type LinkPairState = {
 	links: Record<LinkKey, TagLink>;
 	groups: Record<GroupKey, LinkGroupState>;
 	sourceRequests?: Record<LinkKey, true>;
+	destinationRequests?: Record<LinkKey, true>;
+	destinationLinkDemands?: Record<LinkKey, true>;
+	destinationGroupDemands?: Record<GroupKey, true>;
+	refreshingLinks?: Record<LinkKey, true>;
+	blockedDestinations?: Record<LinkKey, true>;
+	portalReadySources?: Record<LinkKey, true>;
 };
 
 export type LinkPairsState = Record<ScreenPairKey, LinkPairState>;
+
+export type BoundsScreenNode = {
+	animationProgress: SharedValue<number>;
+	pendingLifecycleStartBlockCount: SharedValue<number>;
+};
+
+export type BoundsScreenState = Record<ScreenKey, BoundsScreenNode>;

package/src/shared/types/providers/blank-stack-provider.types.ts

@@ -36,6 +36,7 @@ export interface BlankStackStoreValue<
 	routes: TDescriptor["route"][];
 	scenes: BaseStackScene<TDescriptor>[];
 	scenesByKey: Record<string, BaseStackScene<TDescriptor>>;
+	paintDriverRouteKeyByRouteKey: ReadonlyMap<string, string>;
 	focusedIndex: number;
 	requestDismiss: (payload: { route: BaseStackRoute }) => boolean;
 	shouldShowFloatOverlay: boolean;

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

@@ -66,12 +66,15 @@ const createBoundsAccessorParts = ({
 			styles: (options?: BoundsComputeOptions): BoundsStyleResult => {
 				"worklet";
 				// Keep the component at its base layout for pre-animation refresh
-				// measurement, then remove generated styles again after settlement.
-				if (!props.active.animating) {
+				// measurement, then remove generated styles again after settlement. The
+				// pre-animation pass still has to reach the bounds coordinator so both
+				// endpoints are captured before generated transforms attach.
+				const shouldRenderStyles = !!props.active.animating;
+				if (!shouldRenderStyles && !props.active.willAnimate) {
 					return NO_STYLES;
 				}
 
-				return prepareBoundStyles({
+				const preparedStyles = prepareBoundStyles({
 					props,
 					options: {
 						...options,
@@ -79,6 +82,8 @@ const createBoundsAccessorParts = ({
 						group: normalizedIdentity.group,
 					},
 				}) as BoundsStyleResult;
+
+				return shouldRenderStyles ? preparedStyles : NO_STYLES;
 			},
 			values: getValues,
 			math: <T extends BoundsComputeOptions = BoundsComputeOptions>(