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

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

@@ -1,27 +1,21 @@
-import type { MeasuredDimensions, StyleProps } from "react-native-reanimated";
 import { clear, clearByAncestor, clearByBranch } from "./internals/clear";
-import { getGroupActiveId, setGroupActiveId } from "./internals/groups";
+import { getEntry, removeEntry, setEntry } from "./internals/entries";
 import {
-	getActiveLink,
-	getEntry,
-	getEntryConfig,
-	getMeasuredEntry,
+	getGroupActiveId,
+	getGroupInitialId,
+	setGroupActiveId,
+	setGroupInitialId,
+} from "./internals/groups";
+import {
+	getMatchedLink,
 	getPendingLink,
 	hasDestinationLink,
 	hasSourceLink,
-	removeEntry,
 	setDestination,
-	setEntry,
 	setSource,
-} from "./internals/registry";
+} from "./internals/links";
 import { resolveTransitionPair } from "./internals/resolver";
-import type {
-	BoundaryConfig,
-	MeasuredEntry,
-	NavigatorKey,
-	ScreenKey,
-	TagID,
-} from "./types";
+import type { MeasuredEntry } from "./types";
 
 export type {
 	BoundaryConfig,
@@ -34,164 +28,16 @@ export type {
 
 export type Snapshot = MeasuredEntry;
 
-const registerSnapshot = (
-	tag: TagID,
-	screenKey: ScreenKey,
-	bounds: MeasuredDimensions,
-	styles: StyleProps = {},
-	ancestorKeys?: ScreenKey[],
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) => {
-	"worklet";
-	setEntry(tag, screenKey, {
-		bounds,
-		styles,
-		ancestorKeys,
-		navigatorKey,
-		ancestorNavigatorKeys,
-	});
-};
-
-const registerBoundaryPresence = (
-	tag: TagID,
-	screenKey: ScreenKey,
-	ancestorKeys?: ScreenKey[],
-	boundaryConfig?: BoundaryConfig,
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) => {
-	"worklet";
-	const currentPresenceCount = getEntry(tag, screenKey)?.presenceCount ?? 0;
-	setEntry(tag, screenKey, {
-		ancestorKeys,
-		boundaryConfig,
-		navigatorKey,
-		ancestorNavigatorKeys,
-		presenceCount: currentPresenceCount + 1,
-	});
-};
-
-const unregisterBoundaryPresence = (tag: TagID, screenKey: ScreenKey) => {
-	"worklet";
-	const currentPresenceCount = getEntry(tag, screenKey)?.presenceCount ?? 0;
-	if (currentPresenceCount > 1) {
-		setEntry(tag, screenKey, { presenceCount: currentPresenceCount - 1 });
-		return;
-	}
-
-	removeEntry(tag, screenKey);
-};
-
-const getLatestPendingSourceScreenKey = (tag: TagID): ScreenKey | null => {
-	"worklet";
-	return getPendingLink(tag)?.source.screenKey ?? null;
-};
-
-const setLinkSource = (
-	tag: TagID,
-	screenKey: ScreenKey,
-	bounds: MeasuredDimensions,
-	styles?: StyleProps,
-	ancestorKeys?: ScreenKey[],
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) => {
-	"worklet";
-	setSource(
-		"capture",
-		tag,
-		screenKey,
-		bounds,
-		styles,
-		ancestorKeys,
-		navigatorKey,
-		ancestorNavigatorKeys,
-	);
-};
-
-const updateLinkSource = (
-	tag: TagID,
-	screenKey: ScreenKey,
-	bounds: MeasuredDimensions,
-	styles?: StyleProps,
-	ancestorKeys?: ScreenKey[],
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) => {
-	"worklet";
-	setSource(
-		"refresh",
-		tag,
-		screenKey,
-		bounds,
-		styles,
-		ancestorKeys,
-		navigatorKey,
-		ancestorNavigatorKeys,
-	);
-};
-
-const setLinkDestination = (
-	tag: TagID,
-	screenKey: ScreenKey,
-	bounds: MeasuredDimensions,
-	styles?: StyleProps,
-	ancestorKeys?: ScreenKey[],
-	expectedSourceScreenKey?: ScreenKey,
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) => {
-	"worklet";
-	setDestination(
-		"attach",
-		tag,
-		screenKey,
-		bounds,
-		styles,
-		ancestorKeys,
-		expectedSourceScreenKey,
-		navigatorKey,
-		ancestorNavigatorKeys,
-	);
-};
-
-const updateLinkDestination = (
-	tag: TagID,
-	screenKey: ScreenKey,
-	bounds: MeasuredDimensions,
-	styles?: StyleProps,
-	ancestorKeys?: ScreenKey[],
-	expectedSourceScreenKey?: ScreenKey,
-	navigatorKey?: NavigatorKey,
-	ancestorNavigatorKeys?: NavigatorKey[],
-) => {
-	"worklet";
-	setDestination(
-		"refresh",
-		tag,
-		screenKey,
-		bounds,
-		styles,
-		ancestorKeys,
-		expectedSourceScreenKey,
-		navigatorKey,
-		ancestorNavigatorKeys,
-	);
-};
-
 export const BoundStore = {
 	entry: {
 		set: setEntry,
 		get: getEntry,
-		getMeasured: getMeasuredEntry,
-		getConfig: getEntryConfig,
 		remove: removeEntry,
 	},
 	link: {
 		setSource,
 		setDestination,
-		getActive: getActiveLink,
+		getMatched: getMatchedLink,
 		getPair: resolveTransitionPair,
 		getPending: getPendingLink,
 		hasSource: hasSourceLink,
@@ -199,37 +45,13 @@ export const BoundStore = {
 	},
 	group: {
 		setActiveId: setGroupActiveId,
+		setInitialId: setGroupInitialId,
 		getActiveId: getGroupActiveId,
+		getInitialId: getGroupInitialId,
 	},
 	cleanup: {
 		byScreen: clear,
 		byAncestor: clearByAncestor,
 		byBranch: clearByBranch,
 	},
-	// Legacy flat aliases used by the v3 tests and older internals. New code should
-	// prefer the explicit entry/link/group/cleanup namespaces above.
-	registerSnapshot,
-	getSnapshot: getMeasuredEntry,
-	setLinkSource,
-	updateLinkSource,
-	setLinkDestination,
-	updateLinkDestination,
-	getActiveLink,
-	resolveTransitionPair,
-	hasPendingLink: (tag: TagID) => getPendingLink(tag) !== null,
-	hasPendingLinkFromSource: (tag: TagID, sourceScreenKey: ScreenKey) =>
-		getPendingLink(tag, sourceScreenKey) !== null,
-	getLatestPendingSourceScreenKey,
-	hasSourceLink,
-	hasDestinationLink,
-	registerBoundaryPresence,
-	unregisterBoundaryPresence,
-	hasBoundaryPresence: (tag: TagID, screenKey: ScreenKey) =>
-		(getEntry(tag, screenKey)?.presenceCount ?? 0) > 0,
-	getBoundaryConfig: getEntryConfig,
-	setGroupActiveId,
-	getGroupActiveId,
-	clear,
-	clearByAncestor,
-	clearByBranch,
 };

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

@@ -0,0 +1,42 @@
+import {
+	applyEntryPatch,
+	ensureScreenEntry,
+	findMatchingScreenEntry,
+} from "../helpers/entries.helpers";
+import { ensureTagState, pruneTagState } from "../helpers/tag-state.helpers";
+import type { EntryPatch, ScreenEntry, ScreenKey, TagID } from "../types";
+import { type RegistryState, registry } from "./state";
+
+function getEntry(tag: TagID, key: ScreenKey): ScreenEntry | null {
+	"worklet";
+	return findMatchingScreenEntry(registry.get()[tag], key);
+}
+
+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;
+	});
+}
+
+export { getEntry, removeEntry, setEntry };

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

@@ -1,20 +1,116 @@
+import {
+	createGroupTag,
+	getGroupName,
+	parseGroupTag,
+} from "../helpers/groups.helpers";
+import type { ScreenKey, TagID, TagLink } from "../types";
+import { getMatchedLink } from "./links";
 import { type GroupsState, groups } from "./state";
 
+type ResolveGroupLinkParams = {
+	tag: TagID;
+	screenKey?: ScreenKey;
+};
+
+type ResolvedGroupLink = {
+	tag: TagID;
+	link: TagLink | null;
+};
+
 function setGroupActiveId(group: string, id: string) {
+	"worklet";
+	groups.modify(<T extends GroupsState>(state: T): T => {
+		"worklet";
+		const mutableState = state as GroupsState;
+		const previous = mutableState[group];
+		mutableState[group] = {
+			activeId: id,
+			initialId: previous?.initialId,
+		};
+		return state;
+	});
+}
+
+function setGroupInitialId(group: string, id: string) {
 	"worklet";
 	groups.modify(<T extends GroupsState>(state: T): T => {
 		"worklet";
 		const mutableState = state as GroupsState;
 		mutableState[group] = {
 			activeId: id,
+			initialId: id,
 		};
 		return state;
 	});
 }
 
-function getGroupActiveId(group: string): string | null {
+function getGroupActiveId(tagOrGroup: string): string | null {
 	"worklet";
-	return groups.get()[group]?.activeId ?? null;
+	return groups.get()[getGroupName(tagOrGroup)]?.activeId ?? null;
+}
+
+function getGroupInitialId(tagOrGroup: string): string | null {
+	"worklet";
+	return groups.get()[getGroupName(tagOrGroup)]?.initialId ?? null;
+}
+
+// Selects the current active group member for this tag.
+function resolveGroupLink({
+	tag,
+	screenKey,
+}: ResolveGroupLinkParams): ResolvedGroupLink {
+	"worklet";
+	const groupTag = parseGroupTag(tag);
+
+	if (!groupTag) {
+		return {
+			tag,
+			link: getMatchedLink(tag, screenKey),
+		};
+	}
+
+	const requestedLink = getMatchedLink(tag, screenKey);
+	if (requestedLink) {
+		return {
+			tag,
+			link: requestedLink,
+		};
+	}
+
+	const activeId = getGroupActiveId(groupTag.group);
+	if (activeId) {
+		const activeTag = createGroupTag(groupTag.group, activeId);
+		const activeLink = getMatchedLink(activeTag, screenKey);
+		if (activeLink) {
+			return {
+				tag: activeTag,
+				link: activeLink,
+			};
+		}
+	}
+
+	const initialId = getGroupInitialId(groupTag.group);
+	if (initialId) {
+		const initialTag = createGroupTag(groupTag.group, initialId);
+		const initialLink = getMatchedLink(initialTag, screenKey);
+		if (initialLink) {
+			return {
+				tag: initialTag,
+				link: initialLink,
+			};
+		}
+	}
+
+	return {
+		tag,
+		link: null,
+	};
 }
 
-export { getGroupActiveId, setGroupActiveId };
+export {
+	getGroupActiveId,
+	getGroupInitialId,
+	resolveGroupLink,
+	setGroupActiveId,
+	setGroupInitialId,
+};

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

@@ -0,0 +1,183 @@
+import type { MeasuredDimensions, StyleProps } from "react-native-reanimated";
+import {
+	findLatestPendingSourceLinkIndex,
+	findLinkIndexForDestinationWrite,
+	hasLinkSide,
+	isCompletedLinkForScreenKey,
+	isSameScreenFamily,
+	selectSourceUpdateTargetIndex,
+} from "../helpers/link.helpers";
+import { ensureTagState } from "../helpers/tag-state.helpers";
+import type { NavigatorKey, ScreenKey, TagID, TagLink } from "../types";
+import { type RegistryState, registry } from "./state";
+
+type LinkSourceWriteMode = "capture" | "refresh";
+type LinkDestinationWriteMode = "attach" | "refresh";
+
+function setSource(
+	mode: LinkSourceWriteMode,
+	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 source = {
+			screenKey,
+			ancestorKeys,
+			navigatorKey,
+			ancestorNavigatorKeys,
+			bounds,
+			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;
+				if (!topLink.initialSource) {
+					topLink.initialSource = source;
+				}
+				return state;
+			}
+
+			stack.push({
+				source,
+				destination: null,
+				initialSource: source,
+			});
+
+			return state;
+		}
+
+		const stack = state[tag]?.linkStack;
+		if (!stack || stack.length === 0) return state;
+		const targetIndex = selectSourceUpdateTargetIndex(stack, screenKey);
+		if (targetIndex === -1) return state;
+
+		const link = stack[targetIndex];
+
+		link.source = source;
+		if (!link.initialSource) {
+			link.initialSource = source;
+		}
+
+		return state;
+	});
+}
+
+function setDestination(
+	mode: LinkDestinationWriteMode,
+	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 stack = state[tag]?.linkStack;
+		if (!stack || stack.length === 0) return state;
+
+		const targetIndex = findLinkIndexForDestinationWrite(
+			stack,
+			mode === "refresh" ? screenKey : undefined,
+			expectedSourceScreenKey,
+		);
+
+		if (targetIndex === -1) return state;
+
+		const link = stack[targetIndex];
+		const destination = {
+			screenKey,
+			ancestorKeys,
+			navigatorKey,
+			ancestorNavigatorKeys,
+			bounds,
+			styles,
+		};
+
+		link.destination = destination;
+		if (!link.initialDestination) {
+			link.initialDestination = destination;
+		}
+
+		return state;
+	});
+}
+
+function getMatchedLink(tag: TagID, screenKey?: ScreenKey): TagLink | null {
+	"worklet";
+	const tagState = registry.get()[tag];
+	const stack = tagState?.linkStack;
+	if (!stack || stack.length === 0) {
+		return null;
+	}
+
+	if (!screenKey) {
+		const lastLink = stack[stack.length - 1];
+		return lastLink ?? null;
+	}
+
+	for (let i = stack.length - 1; i >= 0; i--) {
+		const link = stack[i];
+		if (isCompletedLinkForScreenKey(link, screenKey)) {
+			return link;
+		}
+	}
+
+	return null;
+}
+
+function getPendingLink(
+	tag: TagID,
+	sourceScreenKey?: ScreenKey,
+): TagLink | null {
+	"worklet";
+	const tagState = registry.get()[tag];
+	const stack = tagState?.linkStack;
+	if (!stack || stack.length === 0) return null;
+
+	const pendingSourceLinkIndex = findLatestPendingSourceLinkIndex(
+		stack,
+		sourceScreenKey,
+	);
+	if (pendingSourceLinkIndex === -1) return null;
+	return stack[pendingSourceLinkIndex] ?? null;
+}
+
+function hasSourceLink(tag: TagID, screenKey: ScreenKey): boolean {
+	"worklet";
+	return hasLinkSide(registry.get()[tag]?.linkStack, screenKey, "source");
+}
+
+function hasDestinationLink(tag: TagID, screenKey: ScreenKey): boolean {
+	"worklet";
+	return hasLinkSide(registry.get()[tag]?.linkStack, screenKey, "destination");
+}
+
+export {
+	getMatchedLink,
+	getPendingLink,
+	hasDestinationLink,
+	hasSourceLink,
+	setDestination,
+	setSource,
+};