react-native-screen-transitions 4.0.0-alpha.9 → 4.1.0-alpha.0

package/src/providers/screen/gestures/ownership/gesture-ownership-bridge.tsx

@@ -1,173 +0,0 @@
-import { useLayoutEffect, useMemo } from "react";
-import { GestureStore } from "../../../../stores/gesture.store";
-import {
-	type ClaimedDirections,
-	DIRECTIONS,
-	type Direction,
-	NO_CLAIMS,
-} from "../../../../types/ownership.types";
-import {
-	type BaseDescriptor,
-	useDescriptorsStore,
-} from "../../../screen/descriptors";
-import { useBlankStackStore } from "../../../stack/blank-stack.provider";
-import { useScreenGestureStore } from "../gestures.provider";
-import { resolveScreenGestureConfig } from "../shared/policy";
-import type { ScreenGestureSource } from "../types";
-import { resolveShadowingClaimDirections } from "./shadowing-claims";
-
-type ShadowedAncestor = {
-	ancestor: ScreenGestureSource;
-	directions: Direction[];
-};
-
-const NO_SHADOWED_ANCESTORS: ShadowedAncestor[] = [];
-
-const findShadowedDirections = (
-	claimedDirections: ClaimedDirections,
-	ancestorDirections: ClaimedDirections,
-) => {
-	const shadowedDirections: Direction[] = [];
-
-	for (const direction of DIRECTIONS) {
-		if (claimedDirections[direction] && ancestorDirections[direction]) {
-			shadowedDirections.push(direction);
-		}
-	}
-
-	return shadowedDirections;
-};
-
-const findShadowedAncestors = (
-	ancestorGestures: readonly ScreenGestureSource[],
-	claimedDirections: ClaimedDirections,
-) => {
-	if (ancestorGestures.length === 0) {
-		return NO_SHADOWED_ANCESTORS;
-	}
-
-	const ancestors: ShadowedAncestor[] = [];
-	for (const ancestor of ancestorGestures) {
-		const directions = findShadowedDirections(
-			claimedDirections,
-			ancestor.claimedDirections,
-		);
-
-		if (directions.length > 0) {
-			ancestors.push({ ancestor, directions });
-		}
-	}
-
-	return ancestors.length ? ancestors : NO_SHADOWED_ANCESTORS;
-};
-
-const registerShadowingClaims = (
-	shadowedAncestors: ShadowedAncestor[],
-	currentScreenKey: string,
-) => {
-	const isDismissing = GestureStore.getValue(currentScreenKey, "dismissing");
-
-	for (const { ancestor, directions } of shadowedAncestors) {
-		const newClaims = { ...ancestor.childDirectionClaims.get() };
-		for (const direction of directions) {
-			newClaims[direction] = { routeKey: currentScreenKey, isDismissing };
-		}
-		ancestor.childDirectionClaims.set(newClaims);
-	}
-};
-
-const clearShadowingClaims = (
-	shadowedAncestors: ShadowedAncestor[],
-	currentScreenKey: string,
-) => {
-	for (const { ancestor, directions } of shadowedAncestors) {
-		const currentClaims = ancestor.childDirectionClaims.get();
-		const newClaims = { ...currentClaims };
-		let needsUpdate = false;
-
-		for (const direction of directions) {
-			if (currentClaims[direction]?.routeKey === currentScreenKey) {
-				newClaims[direction] = null;
-				needsUpdate = true;
-			}
-		}
-
-		if (needsUpdate) {
-			ancestor.childDirectionClaims.set(newClaims);
-		}
-	}
-};
-
-const getDescriptorIsFirstKey = (descriptor: BaseDescriptor): boolean => {
-	const navigationState = descriptor.navigation.getState();
-	const routes = navigationState?.routes ?? [];
-	return routes.findIndex((route) => route.key === descriptor.route.key) === 0;
-};
-
-const getDescriptorClaimedDirections = (
-	descriptor: BaseDescriptor | undefined,
-	ancestorGestures: readonly ScreenGestureSource[],
-): ClaimedDirections => {
-	if (!descriptor) {
-		return NO_CLAIMS;
-	}
-
-	return resolveScreenGestureConfig({
-		options: descriptor.options,
-		isFirstKey: getDescriptorIsFirstKey(descriptor),
-		ancestorGestures,
-	}).participation.claimedDirections;
-};
-
-function ActiveGestureOwnershipBridge() {
-	const gestureContext = useScreenGestureStore();
-	const previous = useDescriptorsStore((store) => store.previous);
-	const isCurrentScreenClosing = useBlankStackStore(
-		(store) =>
-			store.scenesByKey[gestureContext.routeKey]?.activity === "closing",
-	);
-	const {
-		claimedDirections,
-		ancestorGestures,
-		routeKey: currentScreenKey,
-	} = gestureContext;
-	const effectiveClaimedDirections = useMemo(
-		() =>
-			resolveShadowingClaimDirections({
-				isCurrentScreenClosing,
-				currentClaimedDirections: claimedDirections,
-				previousClaimedDirections: getDescriptorClaimedDirections(
-					previous,
-					ancestorGestures,
-				),
-			}),
-		[isCurrentScreenClosing, claimedDirections, previous, ancestorGestures],
-	);
-	const shadowedAncestors = useMemo(
-		() => findShadowedAncestors(ancestorGestures, effectiveClaimedDirections),
-		[ancestorGestures, effectiveClaimedDirections],
-	);
-
-	useLayoutEffect(() => {
-		if (!shadowedAncestors.length) {
-			return;
-		}
-
-		registerShadowingClaims(shadowedAncestors, currentScreenKey);
-
-		return () => {
-			clearShadowingClaims(shadowedAncestors, currentScreenKey);
-		};
-	}, [shadowedAncestors, currentScreenKey]);
-
-	return null;
-}
-
-/** Keeps gesture ownership subscriptions attached only to participating screens. */
-export function GestureOwnershipBridge() {
-	const isTopMostScreen = useDescriptorsStore(
-		(store) => store.derivations.isTopMostScreen,
-	);
-
-	return isTopMostScreen ? <ActiveGestureOwnershipBridge /> : null;
-}

package/src/providers/screen/gestures/ownership/resolve-ownership.ts

@@ -1,90 +0,0 @@
-import type {
-	ClaimedDirections,
-	Direction,
-} from "../../../../types/ownership.types";
-import {
-	DIRECTIONS,
-	type DirectionOwnership,
-	NO_OWNERSHIP,
-	type OwnershipStatus,
-} from "../../../../types/ownership.types";
-import type { DirectionClaim } from "../types";
-
-/**
- * Minimal interface for ancestor context needed for ownership resolution.
- * This allows the function to be used without importing the full GestureContextType.
- */
-interface AncestorClaimsContext {
-	claimedDirections: ClaimedDirections;
-}
-
-/**
- * Resolves ownership status for all directions relative to the current screen.
- *
- * For each direction:
- * 1. If the current screen claims it → 'self' (should activate)
- * 2. Else, walk up ancestors looking for a claim → 'ancestor' (should fail to bubble)
- * 3. If no one claims it → 'none' (should fail, no gesture response)
- *
- * This is computed during render (JS thread) and the result can be safely
- * used in worklets since it's a plain object.
- *
- * @param selfClaims - The directions claimed by the current screen
- * @param ancestors - Nearest-first ancestor gesture values from screen topology.
- * @returns Ownership status for all four directions
- */
-export function resolveOwnership(
-	selfClaims: ClaimedDirections,
-	ancestors: readonly AncestorClaimsContext[],
-): DirectionOwnership {
-	const result: DirectionOwnership = { ...NO_OWNERSHIP };
-
-	for (const direction of DIRECTIONS) {
-		result[direction] = resolveDirectionOwnership(
-			direction,
-			selfClaims,
-			ancestors,
-		);
-	}
-
-	return result;
-}
-
-/**
- * Resolves ownership for a single direction.
- */
-function resolveDirectionOwnership(
-	direction: Direction,
-	selfClaims: ClaimedDirections,
-	ancestors: readonly AncestorClaimsContext[],
-): OwnershipStatus {
-	// Check self first
-	if (selfClaims[direction]) {
-		return "self";
-	}
-
-	// Walk ancestors looking for a claim
-	for (const ancestor of ancestors) {
-		if (ancestor.claimedDirections?.[direction]) {
-			return "ancestor";
-		}
-	}
-
-	// No one claims this direction
-	return "none";
-}
-
-/**
- * Returns true when the current screen should fail and defer to a child claim.
- */
-export function shouldDeferToChildClaim(
-	childClaim: DirectionClaim,
-	selfRouteKey: string,
-): boolean {
-	"worklet";
-	if (!childClaim) return false;
-	if (childClaim.routeKey === selfRouteKey) return false;
-	// A closing child still owns its axis until its claim is cleaned up; otherwise
-	// an ancestor can steal the next drag while the previous screen is visible.
-	return true;
-}

package/src/providers/screen/gestures/scroll-coordination/walk-up-scroll-gesture-coordination.ts

@@ -1,88 +0,0 @@
-import type { SharedValue } from "react-native-reanimated";
-import type { Direction } from "../../../../types/ownership.types";
-import type {
-	PanGesture,
-	PinchGesture,
-	ScreenGestureSource,
-	ScrollGestureAxis,
-	ScrollGestureState,
-} from "../types";
-
-/** Walks up the gesture tree until it finds the owner for a specific direction. */
-function findGestureOwnerForDirection(
-	ancestors: readonly ScreenGestureSource[],
-	direction: Direction,
-): ScreenGestureSource | null {
-	for (const ancestor of ancestors) {
-		if (ancestor.claimedDirections?.[direction]) return ancestor;
-	}
-
-	return null;
-}
-
-const getDirectionsForAxis = (
-	axis: ScrollGestureAxis,
-): readonly [Direction, Direction] =>
-	axis === "vertical"
-		? ["vertical", "vertical-inverted"]
-		: ["horizontal", "horizontal-inverted"];
-
-const collectAncestorPinchGestures = (
-	ancestors: readonly ScreenGestureSource[],
-) => {
-	const pinchGestures: ScreenGestureSource["pinchGesture"][] = [];
-
-	for (const ancestor of ancestors) {
-		if (!pinchGestures.includes(ancestor.pinchGesture)) {
-			pinchGestures.push(ancestor.pinchGesture);
-		}
-	}
-
-	return pinchGestures;
-};
-
-const collectAxisOwners = (
-	ancestors: readonly ScreenGestureSource[],
-	directions: readonly [Direction, Direction],
-) => {
-	const seenOwners: ScreenGestureSource[] = [];
-	const panGestures: ScreenGestureSource["panGesture"][] = [];
-	const scrollStates: ScreenGestureSource["scrollState"][] = [];
-	const ownerRouteKeys: string[] = [];
-
-	for (const direction of directions) {
-		const owner = findGestureOwnerForDirection(ancestors, direction);
-
-		if (!owner || seenOwners.includes(owner)) {
-			continue;
-		}
-
-		seenOwners.push(owner);
-		panGestures.push(owner.panGesture);
-		scrollStates.push(owner.scrollState);
-		ownerRouteKeys.push(owner.routeKey);
-	}
-
-	return { panGestures, scrollStates, ownerRouteKeys };
-};
-
-interface WalkUpScrollGestureCoordinationResult {
-	panGestures: PanGesture[];
-	pinchGestures: PinchGesture[];
-	scrollStates: SharedValue<ScrollGestureState | null>[];
-	ownerRouteKeys: string[];
-}
-
-export function walkUpScrollGestureCoordination(
-	ancestors: readonly ScreenGestureSource[],
-	axis: ScrollGestureAxis,
-): WalkUpScrollGestureCoordinationResult {
-	const axisOwners = collectAxisOwners(ancestors, getDirectionsForAxis(axis));
-
-	return {
-		panGestures: axisOwners.panGestures,
-		pinchGestures: collectAncestorPinchGestures(ancestors),
-		scrollStates: axisOwners.scrollStates,
-		ownerRouteKeys: axisOwners.ownerRouteKeys,
-	};
-}

package/src/providers/screen/styles/helpers/collect-interpolator-shared-values.ts

@@ -1,75 +0,0 @@
-import type { SharedValue } from "react-native-reanimated";
-import type { ScreenStyleInterpolator } from "../../../../types/animation.types";
-
-type WorkletClosure = Record<string, unknown>;
-
-type ClosureCarrier = {
-	__closure?: WorkletClosure;
-};
-
-type SharedValueLike = SharedValue<unknown> & {
-	_isReanimatedSharedValue: true;
-};
-
-const isSharedValueLike = (value: unknown): value is SharedValueLike =>
-	(value as Partial<SharedValueLike> | null)?._isReanimatedSharedValue === true;
-
-const getWorkletClosure = (value: unknown): WorkletClosure | undefined => {
-	if (
-		value === null ||
-		(typeof value !== "object" && typeof value !== "function")
-	) {
-		return undefined;
-	}
-
-	const closure = (value as Partial<ClosureCarrier>).__closure;
-	return closure && typeof closure === "object" ? closure : undefined;
-};
-
-const isPlainObject = (value: unknown): value is Record<string, unknown> =>
-	value !== null &&
-	typeof value === "object" &&
-	Object.getPrototypeOf(value) === Object.prototype;
-
-export const collectInterpolatorSharedValues = (
-	interpolators: Array<ScreenStyleInterpolator | undefined>,
-): SharedValue<unknown>[] => {
-	const sharedValues: SharedValue<unknown>[] = [];
-	const seen = new Set<unknown>();
-
-	const visit = (value: unknown) => {
-		if (value === null || value === undefined || seen.has(value)) {
-			return;
-		}
-		seen.add(value);
-
-		if (isSharedValueLike(value)) {
-			sharedValues.push(value);
-			return;
-		}
-
-		if (typeof value === "function") {
-			visit(getWorkletClosure(value));
-			return;
-		}
-
-		if (Array.isArray(value)) {
-			for (let index = 0; index < value.length; index++) {
-				visit(value[index]);
-			}
-			return;
-		}
-
-		if (isPlainObject(value)) {
-			for (const item of Object.values(value)) {
-				visit(item);
-			}
-		}
-	};
-
-	for (let index = 0; index < interpolators.length; index++) {
-		visit(getWorkletClosure(interpolators[index]));
-	}
-
-	return sharedValues;
-};

package/src/utils/resolve-chain-target.ts

@@ -1,33 +0,0 @@
-export type ChainTarget = { depth: number };
-
-type ResolveChainTargetParams<T> = {
-	target: ChainTarget | undefined;
-	self: T | null | undefined;
-	ancestors: readonly T[];
-};
-
-export function resolveChainTarget<T>({
-	target,
-	self,
-	ancestors,
-}: ResolveChainTargetParams<T>): T | null {
-	"worklet";
-	if (!self) {
-		return null;
-	}
-
-	const depth = target?.depth ?? 0;
-	if (!Number.isInteger(depth)) {
-		return null;
-	}
-
-	if (depth === 0) {
-		return self;
-	}
-
-	if (depth > 0) {
-		return null;
-	}
-
-	return ancestors[Math.abs(depth) - 1] ?? null;
-}