react-native-screen-transitions 4.0.0-alpha.6 → 4.0.0-alpha.8

package/src/providers/stack/direct.provider.tsx

@@ -1,148 +0,0 @@
-import { type ReactNode, useMemo } from "react";
-import {
-	type StackContextValue,
-	StackProvider,
-} from "../../hooks/navigation/use-stack";
-import type {
-	DirectStackContextValue,
-	DirectStackDescriptorMap,
-	DirectStackProps,
-	DirectStackScene,
-} from "../../types/providers/direct-stack.types";
-import createProvider from "../../utils/create-provider";
-import { isOverlayVisible } from "../../utils/overlay/visibility";
-import { useStackCoreStore } from "./core.provider";
-
-type DirectStackProviderProps = DirectStackProps & {
-	children: ReactNode;
-};
-
-type DirectStackStoreProviderProps = {
-	children: ReactNode;
-	value: DirectStackContextValue;
-};
-
-const { DirectStackProvider: DirectStackStoreProvider, useDirectStackStore } =
-	createProvider("DirectStack", { guarded: true })<
-		DirectStackStoreProviderProps,
-		DirectStackContextValue
-	>(({ children, value }) => ({ children, value }));
-
-function DirectStackProvider({
-	state,
-	navigation,
-	descriptors,
-	describe,
-	children,
-}: DirectStackProviderProps) {
-	const flags = useStackCoreStore((store) => store.flags);
-	const navigatorKey = state.key;
-	const preloadedDescriptors = useMemo(() => {
-		return state.preloadedRoutes.reduce<DirectStackDescriptorMap>(
-			(acc, route) => {
-				acc[route.key] = acc[route.key] || describe(route, true);
-				return acc;
-			},
-			{},
-		);
-	}, [state.preloadedRoutes, describe]);
-
-	const { scenes, shouldShowFloatOverlay, routeKeys, allRoutes } =
-		useMemo(() => {
-			const allRoutes = state.routes.concat(state.preloadedRoutes);
-			const scenes: DirectStackScene[] = [];
-			const routeKeys: string[] = [];
-			const allDescriptors: DirectStackDescriptorMap = {
-				...preloadedDescriptors,
-				...descriptors,
-			};
-			let shouldShowFloatOverlay = false;
-
-			for (let index = 0; index < allRoutes.length; index++) {
-				const route = allRoutes[index];
-				if (!route) {
-					throw new Error(`Missing stack route at index ${index}.`);
-				}
-				const descriptor = allDescriptors[route.key];
-
-				if (!descriptor) {
-					throw new Error(`Missing descriptor for route "${route.key}".`);
-				}
-
-				const isPreloaded =
-					preloadedDescriptors[route.key] !== undefined &&
-					descriptors[route.key] === undefined;
-
-				scenes.push({
-					activity:
-						index === state.index
-							? "active"
-							: index === state.index - 1
-								? "inert"
-								: "inactive",
-					route,
-					descriptor,
-					isPreloaded,
-				});
-				routeKeys.push(route.key);
-
-				if (
-					!shouldShowFloatOverlay &&
-					descriptor.options?.enableTransitions === true &&
-					isOverlayVisible(descriptor.options)
-				) {
-					shouldShowFloatOverlay = true;
-				}
-			}
-
-			return {
-				scenes,
-				shouldShowFloatOverlay,
-				routeKeys,
-				allRoutes,
-			};
-		}, [
-			state.routes,
-			state.preloadedRoutes,
-			state.index,
-			preloadedDescriptors,
-			descriptors,
-		]);
-
-	const focusedIndex = state.index;
-	const stackValue = useMemo<StackContextValue>(
-		() => ({
-			flags,
-			navigatorKey,
-			routeKeys,
-			routes: allRoutes,
-			scenes,
-			focusedIndex,
-		}),
-		[flags, navigatorKey, routeKeys, allRoutes, scenes, focusedIndex],
-	);
-	const directStackValue = {
-		state,
-		navigation,
-		descriptors,
-		scenes,
-		focusedIndex,
-		shouldShowFloatOverlay,
-	};
-
-	return (
-		<StackProvider value={stackValue}>
-			<DirectStackStoreProvider value={directStackValue}>
-				{children}
-			</DirectStackStoreProvider>
-		</StackProvider>
-	);
-}
-
-export type {
-	DirectStackContextValue,
-	DirectStackProps,
-	DirectStackProviderProps,
-	DirectStackScene,
-};
-export { DirectStackProvider, useDirectStackStore };

package/src/types/providers/direct-stack.types.ts

@@ -1,70 +0,0 @@
-import type {
-	Descriptor,
-	NavigationHelpers,
-	NavigationProp,
-	ParamListBase,
-	RouteProp,
-	StackActionHelpers,
-	StackNavigationState,
-} from "@react-navigation/native";
-import type { ScreenTransitionConfig } from "../screen.types";
-import type { DescriptorMap, StackSceneActivity } from "../stack.types";
-
-export type DirectStackNavigationEventMap = {};
-
-export type DirectStackNavigationHelpers = NavigationHelpers<
-	ParamListBase,
-	DirectStackNavigationEventMap
->;
-
-export type DirectStackNavigationProp<
-	ParamList extends ParamListBase,
-	RouteName extends keyof ParamList = string,
-	NavigatorID extends string | undefined = undefined,
-> = NavigationProp<
-	ParamList,
-	RouteName,
-	NavigatorID,
-	StackNavigationState<ParamList>,
-	DirectStackNavigationOptions,
-	DirectStackNavigationEventMap
-> &
-	StackActionHelpers<ParamList>;
-
-export type DirectStackNavigationOptions = ScreenTransitionConfig & {
-	enableTransitions?: boolean;
-};
-
-export type DirectStackDescriptor = Descriptor<
-	DirectStackNavigationOptions,
-	DirectStackNavigationProp<ParamListBase>,
-	RouteProp<ParamListBase>
->;
-
-export type DirectStackDescriptorMap = DescriptorMap<DirectStackDescriptor>;
-
-export interface DirectStackScene {
-	activity: StackSceneActivity;
-	route: StackNavigationState<ParamListBase>["routes"][number];
-	descriptor: DirectStackDescriptor;
-	isPreloaded: boolean;
-}
-
-export interface DirectStackProps {
-	state: StackNavigationState<ParamListBase>;
-	navigation: DirectStackNavigationHelpers;
-	descriptors: DirectStackDescriptorMap;
-	describe: (
-		route: RouteProp<ParamListBase>,
-		placeholder: boolean,
-	) => DirectStackDescriptor;
-}
-
-export interface DirectStackContextValue {
-	state: StackNavigationState<ParamListBase>;
-	navigation: DirectStackNavigationHelpers;
-	descriptors: DirectStackDescriptorMap;
-	scenes: DirectStackScene[];
-	focusedIndex: number;
-	shouldShowFloatOverlay: boolean;
-}

package/src/utils/bounds/navigation/math.ts

@@ -1,188 +0,0 @@
-import { clamp, interpolate } from "react-native-reanimated";
-
-type CombinedScaleMode = "multiply" | "average" | "max" | "min";
-
-const lerp = (from: number, to: number, t: number): number => {
-	"worklet";
-	return from + (to - from) * t;
-};
-
-const safeDivide = (
-	numerator: number,
-	denominator: number,
-	fallback = 0,
-): number => {
-	"worklet";
-	if (denominator === 0) return fallback;
-	return numerator / denominator;
-};
-
-const inverseLerp = (value: number, inMin: number, inMax: number): number => {
-	"worklet";
-	return safeDivide(value - inMin, inMax - inMin, 0);
-};
-
-const mapRangeClamped = (
-	value: number,
-	inMin: number,
-	inMax: number,
-	outMin: number,
-	outMax: number,
-): number => {
-	"worklet";
-	const t = clamp(inverseLerp(value, inMin, inMax), 0, 1);
-	return lerp(outMin, outMax, t);
-};
-
-const applyPowerCurve = (value: number, exponent: number): number => {
-	"worklet";
-	const safeExponent = exponent > 0 ? exponent : 1;
-	const magnitude = Math.abs(value) ** safeExponent;
-	return value < 0 ? -magnitude : magnitude;
-};
-
-const normalizedToScale = ({
-	normalized,
-	outputRange,
-	exponent = 1,
-	positiveOnly = true,
-}: {
-	normalized: number;
-	outputRange: readonly [number, number];
-	exponent?: number;
-	positiveOnly?: boolean;
-}): number => {
-	"worklet";
-	const [outputStart, outputEnd] = outputRange;
-	const raw = positiveOnly
-		? mapRangeClamped(normalized, 0, 1, outputStart, outputEnd)
-		: mapRangeClamped(normalized, -1, 1, outputStart, outputEnd);
-
-	return applyPowerCurve(raw, exponent);
-};
-
-export const combineScales = (
-	scaleX: number,
-	scaleY: number,
-	mode: CombinedScaleMode = "multiply",
-): number => {
-	"worklet";
-
-	switch (mode) {
-		case "average":
-			return (scaleX + scaleY) / 2;
-		case "max":
-			return Math.max(scaleX, scaleY);
-		case "min":
-			return Math.min(scaleX, scaleY);
-		default:
-			return scaleX * scaleY;
-	}
-};
-
-export const computeCenterScaleShift = ({
-	center,
-	containerCenter,
-	scale,
-}: {
-	center: number;
-	containerCenter: number;
-	scale: number;
-}): number => {
-	"worklet";
-	return (center - containerCenter) * (scale - 1);
-};
-
-const compensateTranslationForParentScale = ({
-	translation,
-	parentScale,
-	epsilon,
-}: {
-	translation: number;
-	parentScale: number;
-	epsilon: number;
-}): number => {
-	"worklet";
-	const safeParentScale = Math.max(parentScale, epsilon);
-	return safeDivide(translation, safeParentScale, translation);
-};
-
-export const composeCompensatedTranslation = ({
-	gesture,
-	parentScale,
-	centerShift = 0,
-	epsilon,
-}: {
-	gesture: number;
-	parentScale: number;
-	centerShift?: number;
-	epsilon: number;
-}): number => {
-	"worklet";
-	return (
-		compensateTranslationForParentScale({
-			translation: gesture,
-			parentScale,
-			epsilon,
-		}) + centerShift
-	);
-};
-
-export const resolveDirectionalDragScale = ({
-	normalized,
-	dismissDirection,
-	shrinkMin,
-	growMax,
-	exponent,
-}: {
-	normalized: number;
-	dismissDirection: "positive" | "negative";
-	shrinkMin: number;
-	growMax: number;
-	exponent: number;
-}) => {
-	"worklet";
-
-	const dismissalRelative =
-		dismissDirection === "negative" ? -normalized : normalized;
-
-	if (dismissalRelative >= 0) {
-		return normalizedToScale({
-			normalized: dismissalRelative,
-			outputRange: [1, shrinkMin],
-			exponent,
-		});
-	}
-
-	const oppositeDrag = Math.min(1, Math.abs(dismissalRelative));
-	return interpolate(oppositeDrag, [0, 1], [1, growMax], "clamp");
-};
-
-export const resolveOpacityRangeTuple = ({
-	value,
-	fallback,
-}: {
-	value:
-		| readonly [
-				inputStart: number,
-				inputEnd: number,
-				outputStart?: number,
-				outputEnd?: number,
-		  ]
-		| undefined;
-	fallback: readonly [
-		inputStart: number,
-		inputEnd: number,
-		outputStart?: number,
-		outputEnd?: number,
-	];
-}) => {
-	"worklet";
-
-	return {
-		inputStart: value?.[0] ?? fallback[0],
-		inputEnd: value?.[1] ?? fallback[1],
-		outputStart: value?.[2] ?? fallback[2] ?? 0,
-		outputEnd: value?.[3] ?? fallback[3] ?? 1,
-	};
-};

package/src/utils/platform.ts

@@ -1,8 +0,0 @@
-/**
- * Detects whether the app is running on React Native's new architecture (Fabric).
- */
-declare const global: typeof globalThis;
-
-export function isFabric(): boolean {
-	return "nativeFabricUIManager" in global;
-}