react-native-screen-transitions 3.4.0-alpha.7 → 3.4.0-beta.1

package/src/shared/utils/bounds/zoom/build.ts

@@ -1,7 +1,6 @@
-import { interpolate } from "react-native-reanimated";
+import { interpolate, makeMutable } from "react-native-reanimated";
 import {
 	EPSILON,
-	HIDDEN_STYLE,
 	NAVIGATION_MASK_CONTAINER_STYLE_ID,
 	NAVIGATION_MASK_ELEMENT_STYLE_ID,
 	VISIBLE_STYLE,
@@ -12,27 +11,38 @@ import {
 } from "../../../stores/bounds";
 import type { TransitionInterpolatedStyle } from "../../../types/animation.types";
 import type { Layout } from "../../../types/screen.types";
-import { computeBoundStyles } from "../helpers/compute-bounds-styles";
+import { prepareBoundStyles } from "../helpers/prepare-bound-styles";
 import type { BoundsOptions } from "../types/options";
 import {
 	getZoomAnchor,
 	toNumber,
+	ZOOM_BACKGROUND_SCALE,
+	ZOOM_DRAG_DIRECTIONAL_SCALE_EXPONENT,
 	ZOOM_DRAG_DIRECTIONAL_SCALE_MAX,
 	ZOOM_DRAG_DIRECTIONAL_SCALE_MIN,
 	ZOOM_DRAG_RESISTANCE,
+	ZOOM_DRAG_TRANSLATION_EXPONENT,
+	ZOOM_DRAG_TRANSLATION_NEGATIVE_MAX,
+	ZOOM_DRAG_TRANSLATION_POSITIVE_MAX,
+	ZOOM_FOCUSED_ELEMENT_CLOSE_OPACITY_RANGE,
+	ZOOM_FOCUSED_ELEMENT_OPEN_OPACITY_RANGE,
 	ZOOM_MASK_OUTSET,
 	ZOOM_SHARED_OPTIONS,
+	ZOOM_UNFOCUSED_ELEMENT_CLOSE_OPACITY_RANGE,
+	ZOOM_UNFOCUSED_ELEMENT_OPEN_OPACITY_RANGE,
 } from "./config";
 import {
 	combineScales,
 	composeCompensatedTranslation,
 	computeCenterScaleShift,
-	normalizedToTranslation,
 	resolveDirectionalDragScale,
+	resolveDirectionalDragTranslation,
+	resolveOpacityRangeTuple,
 } from "./math";
 import type { BuildZoomStylesParams, ZoomInterpolatedStyle } from "./types";
 
 const IDENTITY_DRAG_SCALE_OUTPUT = [1, 1] as const;
+const presentedZoomTagByRoute = makeMutable<Record<string, string>>({});
 
 /* -------------------------------------------------------------------------- */
 /*                               LOCAL HELPERS                                */
@@ -94,6 +104,119 @@ function getZoomContentTarget({
 	};
 }
 
+function resolveDragScaleTuple(
+	value:
+		| readonly [shrinkMin: number, growMax: number, exponent?: number]
+		| undefined,
+) {
+	"worklet";
+
+	return {
+		shrinkMin: value?.[0] ?? ZOOM_DRAG_DIRECTIONAL_SCALE_MIN,
+		growMax: value?.[1] ?? ZOOM_DRAG_DIRECTIONAL_SCALE_MAX,
+		exponent: value?.[2] ?? ZOOM_DRAG_DIRECTIONAL_SCALE_EXPONENT,
+	};
+}
+
+function resolveDragTranslationTuple(
+	value:
+		| readonly [negativeMax: number, positiveMax: number, exponent?: number]
+		| undefined,
+) {
+	"worklet";
+
+	return {
+		negativeMax: value?.[0] ?? ZOOM_DRAG_TRANSLATION_NEGATIVE_MAX,
+		positiveMax: value?.[1] ?? ZOOM_DRAG_TRANSLATION_POSITIVE_MAX,
+		exponent: value?.[2] ?? ZOOM_DRAG_TRANSLATION_EXPONENT,
+	};
+}
+
+function resolveBackgroundScale(value: number | undefined) {
+	"worklet";
+
+	return value ?? ZOOM_BACKGROUND_SCALE;
+}
+
+function interpolateOpacityRange(params: {
+	progress: number;
+	range: {
+		inputStart: number;
+		inputEnd: number;
+		outputStart: number;
+		outputEnd: number;
+	};
+}) {
+	"worklet";
+
+	const { progress, range } = params;
+
+	return interpolate(
+		progress,
+		[range.inputStart, range.inputEnd],
+		[range.outputStart, range.outputEnd],
+		"clamp",
+	);
+}
+
+function resolveEffectiveZoomTag(params: {
+	resolvedTag: string;
+	activeRouteKey?: string;
+	entering: boolean;
+	animating: boolean;
+	activeProgress: number;
+	livePairReady: boolean;
+}) {
+	"worklet";
+
+	const {
+		resolvedTag,
+		activeRouteKey,
+		entering,
+		animating,
+		activeProgress,
+		livePairReady,
+	} = params;
+
+	// Only grouped ids need retarget stabilization. Plain ids should keep their
+	// normal behavior with no route-level caching.
+	if (!activeRouteKey || !resolvedTag.includes(":")) {
+		return resolvedTag;
+	}
+
+	const cachedTag = presentedZoomTagByRoute.value[activeRouteKey];
+	const isFreshOpenFrame = entering && activeProgress <= 0.05;
+	const shouldFreezeDuringEnter = entering && animating && !isFreshOpenFrame;
+
+	if (!cachedTag || isFreshOpenFrame) {
+		presentedZoomTagByRoute.modify((state) => ({
+			...state,
+			[activeRouteKey]: resolvedTag,
+		}));
+		return resolvedTag;
+	}
+
+	if (shouldFreezeDuringEnter) {
+		return cachedTag;
+	}
+
+	// After the enter animation, grouped retargeting can still briefly point at a
+	// new active id before that tag has usable bounds. Keep presenting the last
+	// good tag until the next one is transition-ready.
+	if (cachedTag !== resolvedTag && !livePairReady) {
+		return cachedTag;
+	}
+
+	if (cachedTag !== resolvedTag) {
+		presentedZoomTagByRoute.modify((state) => ({
+			...state,
+			[activeRouteKey]: resolvedTag,
+		}));
+	}
+
+	return resolvedTag;
+}
+
 /* -------------------------------------------------------------------------- */
 /*                             BUILD ZOOM STYLES                              */
 /* -------------------------------------------------------------------------- */
@@ -110,56 +233,129 @@ export function buildZoomStyles({
 	/* ------------------------------ Shared Setup ------------------------------ */
 
 	const explicitTarget = zoomOptions?.target;
-	const debug = zoomOptions?.DEBUG === true;
 	const focused = props.focused;
 	const progress = props.progress;
 	const screenLayout = props.layouts.screen;
 	const isEnteringTransition = !props.next;
+	const activeRouteKey = props.active.route.key;
 	const currentRouteKey = props.current?.route.key;
 	const previousRouteKey = props.previous?.route.key;
 	const nextRouteKey = props.next?.route.key;
 	const resolvedZoomAnchor = getZoomAnchor(explicitTarget);
-
-	const zoomComputeParams = {
-		id: resolvedTag,
-		previous: props.previous,
-		current: props.current,
-		next: props.next,
-		progress,
-		dimensions: screenLayout,
-	} as const;
+	const liveResolvedPair = BoundStore.resolveTransitionPair(resolvedTag, {
+		currentScreenKey: currentRouteKey,
+		previousScreenKey: previousRouteKey,
+		nextScreenKey: nextRouteKey,
+		entering: isEnteringTransition,
+	});
+	const effectiveTag = resolveEffectiveZoomTag({
+		resolvedTag,
+		activeRouteKey,
+		entering: !!props.active.entering,
+		animating: !!props.active.animating,
+		activeProgress: props.active.progress,
+		livePairReady: !!liveResolvedPair.sourceBounds,
+	});
 
 	const baseRawOptions = {
-		id: resolvedTag,
+		id: effectiveTag,
 		raw: true,
 		scaleMode: ZOOM_SHARED_OPTIONS.scaleMode,
 	} as const;
 
-	const resolvedPair = BoundStore.resolveTransitionPair(resolvedTag, {
-		currentScreenKey: currentRouteKey,
-		previousScreenKey: previousRouteKey,
-		nextScreenKey: nextRouteKey,
-		entering: isEnteringTransition,
-	});
+	const resolvedPair =
+		effectiveTag === resolvedTag
+			? liveResolvedPair
+			: BoundStore.resolveTransitionPair(effectiveTag, {
+					currentScreenKey: currentRouteKey,
+					previousScreenKey: previousRouteKey,
+					nextScreenKey: nextRouteKey,
+					entering: isEnteringTransition,
+				});
 
 	const sourceBorderRadius = getSourceBorderRadius(resolvedPair);
 	const targetBorderRadius = zoomOptions?.borderRadius ?? sourceBorderRadius;
+	const focusedElementOpacity = {
+		open: resolveOpacityRangeTuple({
+			value: zoomOptions?.focusedElementOpacity?.open,
+			fallback: ZOOM_FOCUSED_ELEMENT_OPEN_OPACITY_RANGE,
+		}),
+		close: resolveOpacityRangeTuple({
+			value: zoomOptions?.focusedElementOpacity?.close,
+			fallback: ZOOM_FOCUSED_ELEMENT_CLOSE_OPACITY_RANGE,
+		}),
+	};
+	const unfocusedElementOpacity = {
+		open: resolveOpacityRangeTuple({
+			value: zoomOptions?.unfocusedElementOpacity?.open,
+			fallback: ZOOM_UNFOCUSED_ELEMENT_OPEN_OPACITY_RANGE,
+		}),
+		close: resolveOpacityRangeTuple({
+			value: zoomOptions?.unfocusedElementOpacity?.close,
+			fallback: ZOOM_UNFOCUSED_ELEMENT_CLOSE_OPACITY_RANGE,
+		}),
+	};
 	const sourceVisibilityStyle = {
-		[resolvedTag]: VISIBLE_STYLE,
+		[effectiveTag]: VISIBLE_STYLE,
 	} satisfies TransitionInterpolatedStyle;
 	const focusedContentSlot = props.navigationMaskEnabled
 		? NAVIGATION_MASK_CONTAINER_STYLE_ID
 		: "content";
 
+	/**
+	 * Local bounds compute helper for navigation zoom.
+	 *
+	 * If you're building a custom transition, prefer the public `bounds()` helper.
+	 * We keep a local version here so zoom can share the same low-level compute path
+	 * without re-entering the decorated public accessor.
+	 */
+	const bounds = <T extends BoundsOptions>(options: T) => {
+		"worklet";
+
+		return prepareBoundStyles({
+			props,
+			options,
+			resolvedPair,
+			syncGroupActiveId: false,
+		});
+	};
+
 	/* --------------------------- Missing Source Guard -------------------------- */
 
-	// To avoid initial flickering, we'll want to hide if there are no source bounds
-	// But to also avoid scenarios where activeId changes in dst and theres a failed measurement,
-	// we should only hide if entering and there is no source bounds.
-	if (!resolvedPair.sourceBounds && props.active.entering) {
-		return {
-			[focusedContentSlot]: HIDDEN_STYLE,
+	// Only the focused entering route should be hidden when source bounds are
+	// missing. During rapid chained pushes, source measurement can briefly race
+	// the focused destination. In that case, degrading to a fullscreen destination
+	// is safer than blanking the entire screen until another gesture/animation
+	// re-runs the pipeline.
+	if (focused && !resolvedPair.sourceBounds && props.active.entering) {
+		const fallbackStyles: ZoomInterpolatedStyle = {
+			[focusedContentSlot]: {
+				style: {
+					opacity: zoomOptions?.debug ? 0.5 : 1,
+					transform: [{ translateX: 0 }, { translateY: 0 }, { scale: 1 }],
+					borderRadius: 0,
+					overflow: "hidden",
+				},
+			},
 		};
+
+		if (props.navigationMaskEnabled) {
+			const { top, right, bottom, left } = ZOOM_MASK_OUTSET;
+			fallbackStyles[NAVIGATION_MASK_ELEMENT_STYLE_ID] = {
+				style: {
+					width: Math.max(1, screenLayout.width + left + right),
+					height: Math.max(1, screenLayout.height + top + bottom),
+					borderRadius: 0,
+					transform: [
+						{ translateX: -left },
+						{ translateY: -top },
+						{ scale: 1 },
+					],
+				},
+			};
+		}
+
+		return fallbackStyles;
 	}
 
 	/* --------------------------- Gesture / Drag Values ------------------------- */
@@ -173,25 +369,44 @@ export function buildZoomStyles({
 	const isVerticalDismiss =
 		initialDirection === "vertical" || initialDirection === "vertical-inverted";
 
-	const dragX = normalizedToTranslation({
+	const horizontalDragTranslation = resolveDragTranslationTuple(
+		zoomOptions?.horizontalDragTranslation,
+	);
+	const verticalDragTranslation = resolveDragTranslationTuple(
+		zoomOptions?.verticalDragTranslation,
+	);
+	const dragX = resolveDirectionalDragTranslation({
 		normalized: normX,
 		dimension: screenLayout.width,
 		resistance: ZOOM_DRAG_RESISTANCE,
+		negativeMax: horizontalDragTranslation.negativeMax,
+		positiveMax: horizontalDragTranslation.positiveMax,
+		exponent: horizontalDragTranslation.exponent,
 	});
-	const dragY = normalizedToTranslation({
+	const dragY = resolveDirectionalDragTranslation({
 		normalized: normY,
 		dimension: screenLayout.height,
 		resistance: ZOOM_DRAG_RESISTANCE,
+		negativeMax: verticalDragTranslation.negativeMax,
+		positiveMax: verticalDragTranslation.positiveMax,
+		exponent: verticalDragTranslation.exponent,
 	});
+	const horizontalDragScale = resolveDragScaleTuple(
+		zoomOptions?.horizontalDragScale,
+	);
+	const verticalDragScale = resolveDragScaleTuple(
+		zoomOptions?.verticalDragScale,
+	);
+	const backgroundScale = resolveBackgroundScale(zoomOptions?.backgroundScale);
 
 	const dragXScale = isHorizontalDismiss
 		? resolveDirectionalDragScale({
 				normalized: normX,
 				dismissDirection:
 					initialDirection === "horizontal-inverted" ? "negative" : "positive",
-				shrinkMin: ZOOM_DRAG_DIRECTIONAL_SCALE_MIN,
-				growMax: ZOOM_DRAG_DIRECTIONAL_SCALE_MAX,
-				exponent: 2,
+				shrinkMin: horizontalDragScale.shrinkMin,
+				growMax: horizontalDragScale.growMax,
+				exponent: horizontalDragScale.exponent,
 			})
 		: IDENTITY_DRAG_SCALE_OUTPUT[0];
 	const dragYScale = isVerticalDismiss
@@ -199,9 +414,9 @@ export function buildZoomStyles({
 				normalized: normY,
 				dismissDirection:
 					initialDirection === "vertical-inverted" ? "negative" : "positive",
-				shrinkMin: ZOOM_DRAG_DIRECTIONAL_SCALE_MIN,
-				growMax: ZOOM_DRAG_DIRECTIONAL_SCALE_MAX,
-				exponent: 2,
+				shrinkMin: verticalDragScale.shrinkMin,
+				growMax: verticalDragScale.growMax,
+				exponent: verticalDragScale.exponent,
 			})
 		: IDENTITY_DRAG_SCALE_OUTPUT[1];
 	const dragScale = combineScales(dragXScale, dragYScale);
@@ -216,32 +431,30 @@ export function buildZoomStyles({
 			resolvedPair,
 		});
 
-		const contentRaw = computeBoundStyles(
-			zoomComputeParams,
-			{
-				...baseRawOptions,
-				anchor: resolvedZoomAnchor,
-				method: "content",
-				target: focusedContentTarget,
-			},
-			resolvedPair,
-		) as Record<string, unknown>;
-
-		const maskRaw = computeBoundStyles(
-			zoomComputeParams,
-			{
-				...baseRawOptions,
-				anchor: ZOOM_SHARED_OPTIONS.anchor,
-				method: "size",
-				space: "absolute",
-				target: "fullscreen",
-			},
-			resolvedPair,
-		) as Record<string, unknown>;
+		const contentRaw = bounds({
+			...baseRawOptions,
+			anchor: resolvedZoomAnchor,
+			method: "content",
+			target: focusedContentTarget,
+		} as const);
+
+		const maskRaw = bounds({
+			...baseRawOptions,
+			anchor: ZOOM_SHARED_OPTIONS.anchor,
+			method: "size",
+			space: "absolute",
+			target: "fullscreen",
+		} as const);
 
 		const focusedFade = props.active?.closing
-			? interpolate(progress, [0.6, 1], [0, debug ? 0.5 : 1], "clamp")
-			: interpolate(progress, [0, 0.5], [0, debug ? 0.5 : 1], "clamp");
+			? interpolateOpacityRange({
+					progress,
+					range: focusedElementOpacity.close,
+				})
+			: interpolateOpacityRange({
+					progress,
+					range: focusedElementOpacity.open,
+				});
 
 		/**
 		 * This is also how swiftui handles their navigation zoom.
@@ -265,7 +478,7 @@ export function buildZoomStyles({
 		const maskTranslateY = toNumber(maskRaw.translateY) + dragY - top;
 
 		const focusedContentStyle = {
-			opacity: focusedFade,
+			opacity: zoomOptions?.debug ? 0.5 : focusedFade,
 			transform: [
 				{ translateX: contentTranslateX },
 				{ translateY: contentTranslateY },
@@ -303,35 +516,43 @@ export function buildZoomStyles({
 	/* ---------------------------- Unfocused Screen ---------------------------- */
 
 	const unfocusedFade = props.active?.closing
-		? interpolate(progress, [1.6, 2], [1, debug ? 1 : 0], "clamp")
-		: interpolate(progress, [1, 1.5], [1, debug ? 1 : 0], "clamp");
-	const unfocusedScale = interpolate(progress, [1, 2], [1, 0.95], "clamp");
+		? interpolateOpacityRange({
+				progress,
+				range: unfocusedElementOpacity.close,
+			})
+		: interpolateOpacityRange({
+				progress,
+				range: unfocusedElementOpacity.open,
+			});
+	const unfocusedScale = interpolate(
+		progress,
+		[1, 2],
+		[1, backgroundScale],
+		"clamp",
+	);
 	const isUnfocusedIdle = props.active.settled === 1;
-	const shouldHideUnfocusedIdle = isUnfocusedIdle && !debug;
-	const shouldFreezeUnfocusedElement =
-		props.active.logicallySettled && !props.active.closing;
-
-	const unfocusedElementTarget =
-		explicitTarget !== undefined || resolvedPair.destinationBounds
-			? getZoomContentTarget({
-					explicitTarget,
-					screenLayout,
-					anchor: ZOOM_SHARED_OPTIONS.anchor,
-					resolvedPair,
-				})
-			: ("fullscreen" as const);
-
-	const elementRaw = computeBoundStyles(
-		zoomComputeParams,
-		{
-			...baseRawOptions,
-			anchor: resolvedZoomAnchor,
-			method: "transform",
-			space: "relative",
-			target: unfocusedElementTarget,
-		},
+	const shouldHideUnfocusedIdle = isUnfocusedIdle;
+	const didSourceComponentVisiblyHide =
+		!props.active.closing && unfocusedFade <= EPSILON;
+
+	const shouldResetUnfocusedElement =
+		!props.active.closing &&
+		(!!props.active.logicallySettled || didSourceComponentVisiblyHide);
+
+	const unfocusedElementTarget = getZoomContentTarget({
+		explicitTarget,
+		screenLayout,
+		anchor: ZOOM_SHARED_OPTIONS.anchor,
 		resolvedPair,
-	) as Record<string, unknown>;
+	});
+
+	const elementRaw = bounds({
+		...baseRawOptions,
+		anchor: resolvedZoomAnchor,
+		method: "transform",
+		space: "relative",
+		target: unfocusedElementTarget,
+	} as const);
 
 	const boundTargetCenterX =
 		explicitTarget === "bound" && resolvedPair.destinationBounds
@@ -394,26 +615,26 @@ export function buildZoomStyles({
 					{ scaleX: 1 },
 					{ scaleY: 1 },
 				],
-				opacity: 0,
+				opacity: zoomOptions?.debug ? 1 : 0,
 				zIndex: 0,
 				elevation: 0,
 			}
 		: {
 				transform: [
 					{
-						translateX: shouldFreezeUnfocusedElement ? 0 : elementTranslateX,
+						translateX: shouldResetUnfocusedElement ? 0 : elementTranslateX,
 					},
 					{
-						translateY: shouldFreezeUnfocusedElement ? 0 : elementTranslateY,
+						translateY: shouldResetUnfocusedElement ? 0 : elementTranslateY,
 					},
 					{
-						scaleX: shouldFreezeUnfocusedElement ? 1 : elementScaleX,
+						scaleX: shouldResetUnfocusedElement ? 1 : elementScaleX,
 					},
 					{
-						scaleY: shouldFreezeUnfocusedElement ? 1 : elementScaleY,
+						scaleY: shouldResetUnfocusedElement ? 1 : elementScaleY,
 					},
 				],
-				opacity: debug ? 0.5 : unfocusedFade,
+				opacity: zoomOptions?.debug ? 1 : unfocusedFade,
 				zIndex: 9999,
 				elevation: 9999,
 			};
@@ -424,7 +645,7 @@ export function buildZoomStyles({
 				transform: [{ scale: unfocusedScale }],
 			},
 		},
-		[resolvedTag]: {
+		[effectiveTag]: {
 			style: resolvedElementStyle,
 		},
 	};

package/src/shared/utils/bounds/zoom/config.ts

@@ -8,6 +8,17 @@ export const ZOOM_SHARED_OPTIONS = Object.freeze({
 export const ZOOM_DRAG_RESISTANCE = 0.4;
 export const ZOOM_DRAG_DIRECTIONAL_SCALE_MIN = 0.25;
 export const ZOOM_DRAG_DIRECTIONAL_SCALE_MAX = 1.06;
+export const ZOOM_DRAG_DIRECTIONAL_SCALE_EXPONENT = 2;
+export const ZOOM_DRAG_TRANSLATION_NEGATIVE_MAX = 1;
+export const ZOOM_DRAG_TRANSLATION_POSITIVE_MAX = 1;
+export const ZOOM_DRAG_TRANSLATION_EXPONENT = 1;
+export const ZOOM_BACKGROUND_SCALE = 0.9375;
+export const ZOOM_FOCUSED_ELEMENT_OPEN_OPACITY_RANGE = [0, 0.5, 0, 1] as const;
+export const ZOOM_FOCUSED_ELEMENT_CLOSE_OPACITY_RANGE = [0.6, 1, 0, 1] as const;
+export const ZOOM_UNFOCUSED_ELEMENT_OPEN_OPACITY_RANGE = [1, 2, 1, 0] as const;
+export const ZOOM_UNFOCUSED_ELEMENT_CLOSE_OPACITY_RANGE = [
+	1.9, 2, 1, 0,
+] as const;
 
 export const ZOOM_MASK_OUTSET = Object.freeze({
 	top: 0,

package/src/shared/utils/bounds/zoom/math.ts

@@ -191,3 +191,60 @@ export const resolveDirectionalDragScale = ({
 	const oppositeDrag = Math.min(1, Math.abs(dismissalRelative));
 	return interpolate(oppositeDrag, [0, 1], [1, growMax], "clamp");
 };
+
+export const resolveDirectionalDragTranslation = ({
+	normalized,
+	dimension,
+	resistance,
+	negativeMax,
+	positiveMax,
+	exponent = 1,
+}: {
+	normalized: number;
+	dimension: number;
+	resistance: number;
+	negativeMax: number;
+	positiveMax: number;
+	exponent?: number;
+}) => {
+	"worklet";
+
+	const clampedMagnitude = Math.min(1, Math.abs(normalized));
+	const curvedMagnitude = clampedMagnitude ** Math.max(1, exponent);
+	const baseDistance = Math.max(0, dimension) * resistance;
+
+	if (normalized < 0) {
+		return -baseDistance * negativeMax * curvedMagnitude;
+	}
+
+	return baseDistance * positiveMax * curvedMagnitude;
+};
+
+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/lib/commonjs/shared/components/create-boundary-component/hooks/use-deferred-measurement-trigger.js

@@ -1,54 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useDeferredMeasurementTrigger = void 0;
-var _react = require("react");
-var _reactNativeReanimated = require("react-native-reanimated");
-const useDeferredMeasurementTrigger = params => {
-  const {
-    enabled,
-    isAnimating,
-    canFlush,
-    onFlush
-  } = params;
-  const hasPendingMeasurement = (0, _reactNativeReanimated.useSharedValue)(false);
-  const clearPendingMeasurement = (0, _react.useCallback)(() => {
-    "worklet";
-
-    hasPendingMeasurement.value = false;
-  }, [hasPendingMeasurement]);
-  const queueOrFlushMeasurement = (0, _react.useCallback)(() => {
-    "worklet";
-
-    if (!enabled) return;
-    if (isAnimating.value) {
-      hasPendingMeasurement.value = true;
-      return;
-    }
-    hasPendingMeasurement.value = false;
-    onFlush();
-  }, [enabled, isAnimating, hasPendingMeasurement, onFlush]);
-  (0, _reactNativeReanimated.useAnimatedReaction)(() => {
-    "worklet";
-
-    if (!enabled) return false;
-    if (!hasPendingMeasurement.value) return false;
-    if (isAnimating.value) return false;
-    return canFlush ? canFlush() : true;
-  }, (shouldFlush, previousShouldFlush) => {
-    "worklet";
-
-    if (!enabled) return;
-    if (!shouldFlush || shouldFlush === previousShouldFlush) return;
-    hasPendingMeasurement.value = false;
-    onFlush();
-  }, [enabled, isAnimating, hasPendingMeasurement, canFlush, onFlush]);
-  return {
-    clearPendingMeasurement,
-    queueOrFlushMeasurement
-  };
-};
-exports.useDeferredMeasurementTrigger = useDeferredMeasurementTrigger;
-//# sourceMappingURL=use-deferred-measurement-trigger.js.map