react-native-screen-transitions 3.4.0 → 3.5.0

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

@@ -1,186 +1,149 @@
 import type { MeasuredDimensions, StyleProps } from "react-native-reanimated";
+import { hasAnyKeys } from "../helpers/keys";
 import { matchesScreenKey } from "../helpers/matching";
 import type {
+	BoundaryConfig,
+	EntryPatch,
+	MeasuredEntry,
 	NavigatorKey,
+	ScreenEntry,
 	ScreenKey,
-	Snapshot,
 	TagID,
 	TagLink,
 	TagState,
 } from "../types";
-import { createEmptyTagState, type RegistryState, registry } from "./state";
+import { type RegistryState, registry } from "./state";
 
 const LINK_HISTORY_LIMIT = 3;
 
+type LinkSourceWriteMode = "capture" | "refresh";
+type LinkDestinationWriteMode = "attach" | "refresh";
+
 const ensureTagState = (state: RegistryState, tag: TagID): TagState => {
 	"worklet";
 	if (!state[tag]) {
-		state[tag] = createEmptyTagState();
+		state[tag] = {
+			screens: {},
+			linkStack: [],
+		};
 	}
 	return state[tag];
 };
 
-const isSameScreenFamily = (
-	a: { screenKey: ScreenKey; ancestorKeys?: ScreenKey[] },
-	b: { screenKey: ScreenKey; ancestorKeys?: ScreenKey[] },
-): boolean => {
+const ensureScreenEntry = (
+	tagState: TagState,
+	screenKey: ScreenKey,
+): ScreenEntry => {
 	"worklet";
-	return (
-		a.screenKey === b.screenKey ||
-		(a.ancestorKeys?.includes(b.screenKey) ?? false) ||
-		(b.ancestorKeys?.includes(a.screenKey) ?? false)
-	);
+	if (!tagState.screens[screenKey]) {
+		tagState.screens[screenKey] = {
+			bounds: null,
+			styles: {},
+		};
+	}
+	return tagState.screens[screenKey];
 };
 
-const trimLinkHistory = (tagState: TagState) => {
+const hasMeasuredEntry = (
+	entry: ScreenEntry | undefined,
+): entry is MeasuredEntry => {
 	"worklet";
-	const overLimit = tagState.linkStack.length - LINK_HISTORY_LIMIT;
-	if (overLimit <= 0) return;
-	tagState.linkStack.splice(0, overLimit);
+	return entry?.bounds !== null && entry?.bounds !== undefined;
 };
 
-function getSnapshot(tag: TagID, key: ScreenKey): Snapshot | null {
+const pruneTagState = (state: RegistryState, tag: TagID) => {
 	"worklet";
-	const tagState = registry.value[tag];
-	if (!tagState) return null;
+	const tagState = state[tag];
+	if (!tagState) return;
 
-	if (tagState.snapshots[key]) {
-		const snap = tagState.snapshots[key];
-		return { bounds: snap.bounds, styles: snap.styles };
+	if (!hasAnyKeys(tagState.screens) && tagState.linkStack.length === 0) {
+		delete state[tag];
 	}
+};
 
-	for (const screenKey in tagState.snapshots) {
-		const snap = tagState.snapshots[screenKey];
-		if (snap.ancestorKeys?.includes(key)) {
-			return { bounds: snap.bounds, styles: snap.styles };
-		}
-	}
-
-	return null;
-}
-
-function registerSnapshot(
-	tag: TagID,
-	screenKey: ScreenKey,
-	bounds: MeasuredDimensions,
-	styles: StyleProps = {},
-	ancestorKeys?: ScreenKey[],
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) {
+const applyEntryPatch = (entry: ScreenEntry, patch: EntryPatch) => {
 	"worklet";
-	registry.modify(<T extends RegistryState>(state: T): T => {
-		"worklet";
-		const tagState = ensureTagState(state, tag);
-		tagState.snapshots[screenKey] = {
-			bounds,
-			styles,
-			ancestorKeys,
-			navigatorKey,
-			ancestorNavigatorKeys,
-		};
-		return state;
-	});
-}
+	if (patch.bounds !== undefined) {
+		entry.bounds = patch.bounds;
+	}
 
-function setLinkSource(
-	tag: TagID,
-	screenKey: ScreenKey,
-	bounds: MeasuredDimensions,
-	styles: StyleProps = {},
-	ancestorKeys?: ScreenKey[],
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) {
-	"worklet";
-	registry.modify(<T extends RegistryState>(state: T): T => {
-		"worklet";
-		const tagState = ensureTagState(state, tag);
-		const stack = tagState.linkStack;
-		const topIndex = stack.length - 1;
-		const topLink = topIndex >= 0 ? stack[topIndex] : null;
+	if (patch.styles !== undefined) {
+		entry.styles = patch.styles ?? {};
+	}
 
-		const source = {
-			screenKey,
-			ancestorKeys,
-			navigatorKey,
-			ancestorNavigatorKeys,
-			bounds,
-			styles,
-		};
+	if (patch.boundaryConfig !== undefined) {
+		if (patch.boundaryConfig === null) {
+			delete entry.boundaryConfig;
+		} else {
+			entry.boundaryConfig = patch.boundaryConfig;
+		}
+	}
 
-		if (
-			topLink &&
-			topLink.destination === null &&
-			isSameScreenFamily(topLink.source, source)
-		) {
-			topLink.source = source;
-			return state;
+	if (patch.ancestorKeys !== undefined) {
+		if (patch.ancestorKeys === null) {
+			delete entry.ancestorKeys;
+		} else {
+			entry.ancestorKeys = patch.ancestorKeys;
 		}
+	}
 
-		stack.push({ source, destination: null });
-		trimLinkHistory(tagState);
+	if (patch.navigatorKey !== undefined) {
+		if (patch.navigatorKey === null) {
+			delete entry.navigatorKey;
+		} else {
+			entry.navigatorKey = patch.navigatorKey;
+		}
+	}
 
-		return state;
-	});
-}
+	if (patch.ancestorNavigatorKeys !== undefined) {
+		if (patch.ancestorNavigatorKeys === null) {
+			delete entry.ancestorNavigatorKeys;
+		} else {
+			entry.ancestorNavigatorKeys = patch.ancestorNavigatorKeys;
+		}
+	}
+};
 
-function updateLinkSource(
-	tag: TagID,
+const findMatchingScreenEntry = (
+	tagState: TagState | undefined,
 	screenKey: ScreenKey,
-	bounds: MeasuredDimensions,
-	styles: StyleProps = {},
-	ancestorKeys?: ScreenKey[],
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) {
+	shouldMatch: (entry: ScreenEntry) => boolean,
+): ScreenEntry | null => {
 	"worklet";
-	registry.modify(<T extends RegistryState>(state: T): T => {
-		"worklet";
-		const tagState = state[tag];
-		const stack = tagState?.linkStack;
-		if (!stack || stack.length === 0) return state;
-
-		let targetIndex = -1;
-
-		for (let i = stack.length - 1; i >= 0; i--) {
-			const link = stack[i];
-			if (link.destination && matchesScreenKey(link.source, screenKey)) {
-				targetIndex = i;
-				break;
-			}
-		}
+	if (!tagState) return null;
 
-		if (targetIndex === -1) {
-			for (let i = stack.length - 1; i >= 0; i--) {
-				if (matchesScreenKey(stack[i].source, screenKey)) {
-					targetIndex = i;
-					break;
-				}
-			}
-		}
+	const direct = tagState.screens[screenKey];
+	if (direct && shouldMatch(direct)) {
+		return direct;
+	}
 
-		if (targetIndex === -1) {
-			return state;
+	for (const entryScreenKey in tagState.screens) {
+		const entry = tagState.screens[entryScreenKey];
+		if (!shouldMatch(entry)) continue;
+		if (entry.ancestorKeys?.includes(screenKey)) {
+			return entry;
 		}
+	}
 
-		stack[targetIndex].source = {
-			screenKey,
-			ancestorKeys,
-			navigatorKey,
-			ancestorNavigatorKeys,
-			bounds,
-			styles,
-		};
+	return null;
+};
 
-		return state;
-	});
-}
+const isSameScreenFamily = (
+	a: { screenKey: ScreenKey; ancestorKeys?: ScreenKey[] },
+	b: { screenKey: ScreenKey; ancestorKeys?: ScreenKey[] },
+): boolean => {
+	"worklet";
+	return (
+		a.screenKey === b.screenKey ||
+		(a.ancestorKeys?.includes(b.screenKey) ?? false) ||
+		(b.ancestorKeys?.includes(a.screenKey) ?? false)
+	);
+};
 
-const findLatestPendingIndex = (
+function findLatestPendingIndex(
 	stack: TagLink[],
 	expectedSourceScreenKey?: ScreenKey,
-): number => {
+): number {
 	"worklet";
 	for (let i = stack.length - 1; i >= 0; i--) {
 		const link = stack[i];
@@ -194,12 +157,12 @@ const findLatestPendingIndex = (
 		return i;
 	}
 	return -1;
-};
+}
 
-const findLatestSourceIndex = (
+function findLatestSourceIndex(
 	stack: TagLink[],
 	expectedSourceScreenKey?: ScreenKey,
-): number => {
+): number {
 	"worklet";
 	if (!expectedSourceScreenKey) return -1;
 
@@ -210,33 +173,136 @@ const findLatestSourceIndex = (
 	}
 
 	return -1;
-};
+}
+
+function findLatestCompletedSourceIndex(
+	stack: TagLink[],
+	screenKey?: ScreenKey,
+): number {
+	"worklet";
+	if (!screenKey) return -1;
+
+	for (let i = stack.length - 1; i >= 0; i--) {
+		const link = stack[i];
+		if (link.destination && matchesScreenKey(link.source, screenKey)) {
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+function findLatestCompletedDestinationIndex(
+	stack: TagLink[],
+	screenKey?: ScreenKey,
+): number {
+	"worklet";
+	if (!screenKey) return -1;
+
+	for (let i = stack.length - 1; i >= 0; i--) {
+		const link = stack[i];
+		if (link.destination && matchesScreenKey(link.destination, screenKey)) {
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+function selectSourceUpdateTargetIndex(
+	stack: TagLink[],
+	screenKey: ScreenKey,
+): number {
+	"worklet";
+	const completedIndex = findLatestCompletedSourceIndex(stack, screenKey);
+	if (completedIndex !== -1) {
+		return completedIndex;
+	}
+
+	return findLatestSourceIndex(stack, screenKey);
+}
+
+function selectDestinationWriteTargetIndex(
+	stack: TagLink[],
+	screenKey?: ScreenKey,
+	expectedSourceScreenKey?: ScreenKey,
+): number {
+	"worklet";
+	const completedIndex = findLatestCompletedDestinationIndex(stack, screenKey);
+	if (completedIndex !== -1) {
+		return completedIndex;
+	}
+
+	const pendingIndex = findLatestPendingIndex(stack, expectedSourceScreenKey);
+	if (pendingIndex !== -1) {
+		return pendingIndex;
+	}
 
-function setLinkDestination(
+	return findLatestSourceIndex(stack, expectedSourceScreenKey);
+}
+
+function getEntry(tag: TagID, key: ScreenKey): ScreenEntry | null {
+	"worklet";
+	return findMatchingScreenEntry(registry.get()[tag], key, () => true);
+}
+
+function getMeasuredEntry(tag: TagID, key: ScreenKey): MeasuredEntry | null {
+	"worklet";
+	const entry = findMatchingScreenEntry(registry.get()[tag], key, (candidate) =>
+		hasMeasuredEntry(candidate),
+	);
+	return (entry as MeasuredEntry | null) ?? null;
+}
+
+function getEntryConfig(
+	tag: TagID,
+	screenKey: ScreenKey,
+): BoundaryConfig | null {
+	"worklet";
+	return getEntry(tag, screenKey)?.boundaryConfig ?? null;
+}
+
+function setEntry(tag: TagID, screenKey: ScreenKey, patch: EntryPatch) {
+	"worklet";
+	registry.modify(<T extends RegistryState>(state: T): T => {
+		"worklet";
+		const tagState = ensureTagState(state, tag);
+		const entry = ensureScreenEntry(tagState, screenKey);
+		applyEntryPatch(entry, patch);
+		return state;
+	});
+}
+
+function removeEntry(tag: TagID, screenKey: ScreenKey) {
+	"worklet";
+	registry.modify(<T extends RegistryState>(state: T): T => {
+		"worklet";
+		const tagState = state[tag];
+		if (!tagState?.screens[screenKey]) {
+			return state;
+		}
+
+		delete tagState.screens[screenKey];
+		pruneTagState(state, tag);
+
+		return state;
+	});
+}
+
+function setSource(
+	mode: LinkSourceWriteMode,
 	tag: TagID,
 	screenKey: ScreenKey,
 	bounds: MeasuredDimensions,
 	styles: StyleProps = {},
 	ancestorKeys?: ScreenKey[],
-	expectedSourceScreenKey?: ScreenKey,
 	navigatorKey?: NavigatorKey,
 	ancestorNavigatorKeys?: NavigatorKey[],
 ) {
 	"worklet";
 	registry.modify(<T extends RegistryState>(state: T): T => {
 		"worklet";
-		const tagState = state[tag];
-		const stack = tagState?.linkStack;
-		if (!stack || stack.length === 0) return state;
-
-		let targetIndex = findLatestPendingIndex(stack, expectedSourceScreenKey);
-		if (targetIndex === -1) {
-			targetIndex = findLatestSourceIndex(stack, expectedSourceScreenKey);
-		}
-		if (targetIndex === -1) return state;
-
-		const targetLink = stack[targetIndex];
-		targetLink.destination = {
+		const source = {
 			screenKey,
 			ancestorKeys,
 			navigatorKey,
@@ -245,11 +311,44 @@ function setLinkDestination(
 			styles,
 		};
 
+		if (mode === "capture") {
+			const tagState = ensureTagState(state, tag);
+			const stack = tagState.linkStack;
+			const topIndex = stack.length - 1;
+			const topLink = topIndex >= 0 ? stack[topIndex] : null;
+
+			if (
+				topLink &&
+				topLink.destination === null &&
+				isSameScreenFamily(topLink.source, source)
+			) {
+				topLink.source = source;
+				return state;
+			}
+
+			stack.push({ source, destination: null });
+
+			const overLimit = tagState.linkStack.length - LINK_HISTORY_LIMIT;
+			if (overLimit > 0) {
+				tagState.linkStack.splice(0, overLimit);
+			}
+
+			return state;
+		}
+
+		const stack = state[tag]?.linkStack;
+		if (!stack || stack.length === 0) return state;
+		const targetIndex = selectSourceUpdateTargetIndex(stack, screenKey);
+		if (targetIndex === -1) return state;
+
+		stack[targetIndex].source = source;
+
 		return state;
 	});
 }
 
-function updateLinkDestination(
+function setDestination(
+	mode: LinkDestinationWriteMode,
 	tag: TagID,
 	screenKey: ScreenKey,
 	bounds: MeasuredDimensions,
@@ -262,31 +361,14 @@ function updateLinkDestination(
 	"worklet";
 	registry.modify(<T extends RegistryState>(state: T): T => {
 		"worklet";
-		const tagState = state[tag];
-		const stack = tagState?.linkStack;
+		const stack = state[tag]?.linkStack;
 		if (!stack || stack.length === 0) return state;
-
-		let targetIndex = -1;
-
-		for (let i = stack.length - 1; i >= 0; i--) {
-			const link = stack[i];
-			if (link.destination && matchesScreenKey(link.destination, screenKey)) {
-				targetIndex = i;
-				break;
-			}
-		}
-
-		if (targetIndex === -1) {
-			targetIndex = findLatestPendingIndex(stack, expectedSourceScreenKey);
-		}
-
-		if (targetIndex === -1) {
-			targetIndex = findLatestSourceIndex(stack, expectedSourceScreenKey);
-		}
-
-		if (targetIndex === -1) {
-			return state;
-		}
+		const targetIndex = selectDestinationWriteTargetIndex(
+			stack,
+			mode === "refresh" ? screenKey : undefined,
+			expectedSourceScreenKey,
+		);
+		if (targetIndex === -1) return state;
 
 		stack[targetIndex].destination = {
 			screenKey,
@@ -303,7 +385,7 @@ function updateLinkDestination(
 
 function getActiveLink(tag: TagID, screenKey?: ScreenKey): TagLink | null {
 	"worklet";
-	const tagState = registry.value[tag];
+	const tagState = registry.get()[tag];
 	const stack = tagState?.linkStack;
 	if (!stack || stack.length === 0) {
 		return null;
@@ -328,58 +410,23 @@ function getActiveLink(tag: TagID, screenKey?: ScreenKey): TagLink | null {
 	return null;
 }
 
-function hasPendingLink(tag: TagID): boolean {
-	"worklet";
-	const tagState = registry.value[tag];
-	const stack = tagState?.linkStack;
-	if (!stack || stack.length === 0) return false;
-
-	for (let i = stack.length - 1; i >= 0; i--) {
-		if (stack[i].destination === null) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-function hasPendingLinkFromSource(
+function getPendingLink(
 	tag: TagID,
-	sourceScreenKey: ScreenKey,
-): boolean {
-	"worklet";
-	const tagState = registry.value[tag];
-	const stack = tagState?.linkStack;
-	if (!stack || stack.length === 0) return false;
-
-	for (let i = stack.length - 1; i >= 0; i--) {
-		const link = stack[i];
-		if (link.destination !== null) continue;
-		if (matchesScreenKey(link.source, sourceScreenKey)) return true;
-	}
-
-	return false;
-}
-
-function getLatestPendingSourceScreenKey(tag: TagID): ScreenKey | null {
+	sourceScreenKey?: ScreenKey,
+): TagLink | null {
 	"worklet";
-	const tagState = registry.value[tag];
+	const tagState = registry.get()[tag];
 	const stack = tagState?.linkStack;
 	if (!stack || stack.length === 0) return null;
 
-	for (let i = stack.length - 1; i >= 0; i--) {
-		const link = stack[i];
-		if (link.destination === null) {
-			return link.source.screenKey;
-		}
-	}
-
-	return null;
+	const targetIndex = findLatestPendingIndex(stack, sourceScreenKey);
+	if (targetIndex === -1) return null;
+	return stack[targetIndex] ?? null;
 }
 
 function hasSourceLink(tag: TagID, screenKey: ScreenKey): boolean {
 	"worklet";
-	const tagState = registry.value[tag];
+	const tagState = registry.get()[tag];
 	const stack = tagState?.linkStack;
 	if (!stack || stack.length === 0) return false;
 
@@ -392,7 +439,7 @@ function hasSourceLink(tag: TagID, screenKey: ScreenKey): boolean {
 
 function hasDestinationLink(tag: TagID, screenKey: ScreenKey): boolean {
 	"worklet";
-	const tagState = registry.value[tag];
+	const tagState = registry.get()[tag];
 	const stack = tagState?.linkStack;
 	if (!stack || stack.length === 0) return false;
 
@@ -404,16 +451,15 @@ function hasDestinationLink(tag: TagID, screenKey: ScreenKey): boolean {
 }
 
 export {
-	getSnapshot,
-	registerSnapshot,
-	setLinkSource,
-	updateLinkSource,
-	setLinkDestination,
-	updateLinkDestination,
 	getActiveLink,
-	hasPendingLink,
-	hasPendingLinkFromSource,
-	getLatestPendingSourceScreenKey,
-	hasSourceLink,
+	getEntry,
+	getEntryConfig,
+	getMeasuredEntry,
+	getPendingLink,
 	hasDestinationLink,
+	hasSourceLink,
+	removeEntry,
+	setDestination,
+	setEntry,
+	setSource,
 };

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

@@ -70,11 +70,10 @@ function resolveTransitionPair(
 	context: ResolveTransitionContext,
 ): ResolvedTransitionPair {
 	"worklet";
-	const tagState = registry.value[tag];
+	const tagState = registry.get()[tag];
 	const stack = tagState?.linkStack;
 
 	let matchedLink: TagLink | null = null;
-	let usedPending = false;
 
 	if (tagState && stack && stack.length > 0) {
 		if (context.entering) {
@@ -88,7 +87,6 @@ function resolveTransitionPair(
 					tagState,
 					context.previousScreenKey,
 				);
-				usedPending = !!matchedLink;
 			}
 
 			if (!matchedLink) {
@@ -122,7 +120,6 @@ function resolveTransitionPair(
 					tagState,
 					context.currentScreenKey,
 				);
-				usedPending = !!matchedLink;
 			}
 		}
 	}
@@ -141,7 +138,6 @@ function resolveTransitionPair(
 		destinationStyles,
 		sourceScreenKey,
 		destinationScreenKey,
-		usedPending,
 	};
 }
 

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

@@ -1,10 +1,10 @@
 import { makeMutable } from "react-native-reanimated";
-import type { GroupState, PresenceState, TagID, TagState } from "../types";
+import type { GroupState, TagID, TagState } from "../types";
 
 export const createEmptyTagState = (): TagState => {
 	"worklet";
 	return {
-		snapshots: {},
+		screens: {},
 		linkStack: [],
 	};
 };
@@ -13,5 +13,4 @@ export type RegistryState = Record<TagID, TagState>;
 export type GroupsState = Record<string, GroupState>;
 
 export const registry = makeMutable<RegistryState>({});
-export const presence = makeMutable<PresenceState>({});
 export const groups = makeMutable<GroupsState>({});