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

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

@@ -0,0 +1,27 @@
+import type { TagID } from "../types";
+
+type GroupTag = {
+	group: string;
+	id: string;
+};
+
+export const parseGroupTag = (tag: string): GroupTag | null => {
+	"worklet";
+	const separatorIndex = tag.indexOf(":");
+	if (separatorIndex === -1) return null;
+
+	return {
+		group: tag.slice(0, separatorIndex),
+		id: tag.slice(separatorIndex + 1),
+	};
+};
+
+export const createGroupTag = (group: string, id: string): TagID => {
+	"worklet";
+	return `${group}:${id}`;
+};
+
+export const getGroupName = (tagOrGroup: string): string => {
+	"worklet";
+	return parseGroupTag(tagOrGroup)?.group ?? tagOrGroup;
+};

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

@@ -1,25 +1,3 @@
-import type { ScreenIdentifier, ScreenKey } from "../types";
-
-export function collectIdentifierKeys(
-	identifier: ScreenIdentifier | null | undefined,
-): ScreenKey[] {
-	"worklet";
-	if (!identifier) return [];
-
-	const allKeys: ScreenKey[] = [identifier.screenKey];
-	const ancestors = identifier.ancestorKeys;
-	if (ancestors && ancestors.length > 0) {
-		for (let i = 0; i < ancestors.length; i++) {
-			const key = ancestors[i];
-			if (!allKeys.includes(key)) {
-				allKeys.push(key);
-			}
-		}
-	}
-
-	return allKeys;
-}
-
 export const hasAnyKeys = (record: Record<string, unknown>) => {
 	"worklet";
 	for (const _key in record) {

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

@@ -0,0 +1,131 @@
+import type { ScreenKey, TagLink } from "../types";
+import { findLatestIndex } from "./find-latest";
+import { matchesScreenKey } from "./matching";
+
+type LinkSide = "source" | "destination";
+
+export const isSameScreenFamily = (
+	a: { screenKey: ScreenKey },
+	b: { screenKey: ScreenKey },
+): boolean => {
+	"worklet";
+	return a.screenKey === b.screenKey;
+};
+
+export function findLatestPendingSourceLinkIndex(
+	stack: TagLink[],
+	expectedSourceScreenKey?: ScreenKey,
+): number {
+	"worklet";
+	return findLatestIndex(stack, (link) => {
+		if (link.destination !== null) return false;
+		return (
+			!expectedSourceScreenKey ||
+			matchesScreenKey(link.source, expectedSourceScreenKey)
+		);
+	});
+}
+
+function findLatestSourceIndex(
+	stack: TagLink[],
+	expectedSourceScreenKey?: ScreenKey,
+): number {
+	"worklet";
+	if (!expectedSourceScreenKey) return -1;
+
+	return findLatestIndex(stack, (link) =>
+		matchesScreenKey(link.source, expectedSourceScreenKey),
+	);
+}
+
+function findLatestCompletedSourceIndex(
+	stack: TagLink[],
+	screenKey?: ScreenKey,
+): number {
+	"worklet";
+	if (!screenKey) return -1;
+
+	return findLatestIndex(
+		stack,
+		(link) => !!link.destination && matchesScreenKey(link.source, screenKey),
+	);
+}
+
+function findLatestCompletedDestinationIndex(
+	stack: TagLink[],
+	screenKey?: ScreenKey,
+): number {
+	"worklet";
+	if (!screenKey) return -1;
+
+	return findLatestIndex(
+		stack,
+		(link) =>
+			!!link.destination && matchesScreenKey(link.destination, screenKey),
+	);
+}
+
+export function selectSourceUpdateTargetIndex(
+	stack: TagLink[],
+	screenKey: ScreenKey,
+): number {
+	"worklet";
+	const completedIndex = findLatestCompletedSourceIndex(stack, screenKey);
+	if (completedIndex !== -1) {
+		return completedIndex;
+	}
+
+	return findLatestSourceIndex(stack, screenKey);
+}
+
+export function findLinkIndexForDestinationWrite(
+	stack: TagLink[],
+	destinationScreenKey?: ScreenKey,
+	expectedSourceScreenKey?: ScreenKey,
+): number {
+	"worklet";
+	const existingDestinationIndex = findLatestCompletedDestinationIndex(
+		stack,
+		destinationScreenKey,
+	);
+	if (existingDestinationIndex !== -1) {
+		return existingDestinationIndex;
+	}
+
+	const pendingSourceIndex = findLatestPendingSourceLinkIndex(
+		stack,
+		expectedSourceScreenKey,
+	);
+	if (pendingSourceIndex !== -1) {
+		return pendingSourceIndex;
+	}
+
+	return findLatestSourceIndex(stack, expectedSourceScreenKey);
+}
+
+export function hasLinkSide(
+	stack: TagLink[] | undefined,
+	screenKey: ScreenKey,
+	side: LinkSide,
+): boolean {
+	"worklet";
+	if (!stack || stack.length === 0) return false;
+
+	return (
+		findLatestIndex(stack, (link) =>
+			matchesScreenKey(link[side], screenKey),
+		) !== -1
+	);
+}
+
+export function isCompletedLinkForScreenKey(
+	link: TagLink,
+	screenKey: ScreenKey,
+): boolean {
+	"worklet";
+	return (
+		!!link.destination &&
+		(matchesScreenKey(link.source, screenKey) ||
+			matchesScreenKey(link.destination, screenKey))
+	);
+}

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/helpers/tag-state.helpers.ts

@@ -0,0 +1,24 @@
+import type { RegistryState } from "../internals/state";
+import type { TagID, TagState } from "../types";
+import { hasAnyKeys } from "./keys";
+
+export const ensureTagState = (state: RegistryState, tag: TagID): TagState => {
+	"worklet";
+	if (!state[tag]) {
+		state[tag] = {
+			screens: {},
+			linkStack: [],
+		};
+	}
+	return state[tag];
+};
+
+export const pruneTagState = (state: RegistryState, tag: TagID) => {
+	"worklet";
+	const tagState = state[tag];
+	if (!tagState) return;
+
+	if (!hasAnyKeys(tagState.screens) && tagState.linkStack.length === 0) {
+		delete state[tag];
+	}
+};

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 { clear } from "./internals/clear";
+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,11 @@ 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/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/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,
+};