react-native-screen-transitions 3.9.0-alpha.0 → 3.9.0-alpha.2

package/src/shared/providers/screen/styles/helpers/visibility-gate.ts

@@ -34,12 +34,7 @@ export const resolveScreenVisibilityGate = ({
 	const isPendingOpen =
 		pendingLifecycleRequestKind === LifecycleTransitionRequestKind.Open;
 	const isOpening = isPendingOpen || !!entering;
-
-	// Keep the screen hidden until the first transformed opening frame exists.
-	// The lifecycle request is cleared before the RAF-scheduled progress
-	// animation starts, so `entering` carries the gate through that one-frame gap.
 	const isWaitingForOpenToStart = progress <= 0;
-
 	const shouldBlock =
 		(hasPendingLifecycleBlock || isWaitingForOpenToStart) && isOpening;
 
@@ -48,10 +43,3 @@ export const resolveScreenVisibilityGate = ({
 		shouldOpenGate: !shouldBlock && progress > 0,
 	};
 };
-
-export const shouldBlockScreenVisibility = (
-	state: ScreenVisibilityGateState,
-) => {
-	"worklet";
-	return resolveScreenVisibilityGate(state).shouldBlock;
-};

package/src/shared/providers/screen/styles/hooks/use-interpolated-style-maps.tsx

@@ -1,6 +1,6 @@
 import { useDerivedValue, useSharedValue } from "react-native-reanimated";
 import { NO_STYLES } from "../../../../constants";
-import { SystemStore } from "../../../../stores/system.store";
+import { AnimationStore } from "../../../../stores/animation.store";
 import type {
 	NormalizedTransitionInterpolatedStyle,
 	ScreenStyleInterpolator,
@@ -13,13 +13,13 @@ import { useBuildTransitionAccessor } from "../../animation/helpers/accessors/us
 import type { ScreenInterpolatorFrame } from "../../animation/helpers/pipeline";
 import { readScreenAnimationRevisions } from "../../animation/helpers/read-screen-animation-revisions";
 import { syncSelectedInterpolatorOptions } from "../../animation/helpers/selected-interpolator-options";
-import { useDescriptorDerivations } from "../../descriptors";
+import { useDescriptorsStore } from "../../descriptors";
 import {
 	syncScreenOptionsOverrides,
 	useScreenOptionsContext,
 } from "../../options";
 import { normalizeSlots } from "../helpers/normalize-slots";
-import { preserveAnimatedPropsOnly } from "../helpers/preserve-animated-props-only";
+import { isOpeningBeforeStart } from "../helpers/opening-phase";
 import type { LocalStyleLayers } from "../helpers/resolve-slot-styles";
 import { stripInterpolatorOptions } from "../helpers/strip-interpolator-options";
 
@@ -37,12 +37,10 @@ type RunInterpolatorParams = {
 	next: ScreenInterpolatorFrame["next"];
 	bounds: Parameters<ScreenStyleInterpolator>[0]["bounds"];
 	transition: Parameters<ScreenStyleInterpolator>[0]["transition"];
-	shouldDeferStyleBuckets: boolean;
 };
 
 const normalizeRawStyleMap = (
 	rawStyleMap: TransitionInterpolatedStyle | undefined,
-	shouldDeferStyleBuckets: boolean,
 ) => {
 	"worklet";
 
@@ -52,9 +50,7 @@ const normalizeRawStyleMap = (
 
 	const stylesMap = normalizeSlots(stripInterpolatorOptions(rawStyleMap));
 
-	return shouldDeferStyleBuckets
-		? preserveAnimatedPropsOnly(stylesMap)
-		: stylesMap;
+	return stylesMap;
 };
 
 const runInterpolator = ({
@@ -64,7 +60,6 @@ const runInterpolator = ({
 	next,
 	bounds,
 	transition,
-	shouldDeferStyleBuckets,
 }: RunInterpolatorParams): InterpolatorResult | undefined => {
 	"worklet";
 
@@ -86,7 +81,7 @@ const runInterpolator = ({
 
 		return {
 			rawStyleMap,
-			stylesMap: normalizeRawStyleMap(rawStyleMap, shouldDeferStyleBuckets),
+			stylesMap: normalizeRawStyleMap(rawStyleMap),
 		};
 	} catch (_) {
 		if (__DEV__) {
@@ -124,17 +119,15 @@ const appendLayer = (
  * normal interpolator selection once the gesture-driven close is no longer in
  * play.
  *
- * Visibility gating happens downstream while lifecycle start is blocked for
- * pending destination measurement. We still run the interpolator during that
- * hidden window so animated props and runtime options stay warm, but defer style
- * buckets so measurement sees the final untransformed layout.
- *
  * The result is ordered from lowest to highest priority. Resolution happens
  * downstream, where slot ids determine whether slots inherit from ancestors and
  * where higher owner layers override lower owner layers per key.
  */
 export const useInterpolatedStylesMap = () => {
-	const { currentScreenKey } = useDescriptorDerivations();
+	const currentScreenKey = useDescriptorsStore(
+		(s) => s.derivations.currentScreenKey,
+	);
+	const nextScreenKey = useDescriptorsStore((s) => s.derivations.nextScreenKey);
 	const screenOptions = useScreenOptionsContext();
 	const {
 		screenInterpolatorProps,
@@ -147,10 +140,11 @@ export const useInterpolatedStylesMap = () => {
 	} = useScreenAnimationContext();
 	const boundsAccessor = useBuildBoundsAccessor();
 	const transition = useBuildTransitionAccessor();
-	const pendingLifecycleStartBlockCount = SystemStore.getValue(
-		currentScreenKey,
-		"pendingLifecycleStartBlockCount",
-	);
+
+	const {
+		entering: activeEntering,
+		transitionProgress: activeTransitionProgress,
+	} = AnimationStore.getBag(nextScreenKey ?? currentScreenKey);
 
 	const isGesturingDuringCloseAnimation = useSharedValue(false);
 
@@ -163,19 +157,6 @@ export const useInterpolatedStylesMap = () => {
 		);
 		const props = screenInterpolatorProps.get();
 
-		/**
-		 * There is a niche case where bounds can be attached to a view that's styles are out of viewport.
-		 * Due to our blocking mechanism and ensuring accurate measurement, this boundary measurement
-		 * will be blocked and the screen will never be visible. To mitigate this, we:
-		 *
-		 * - Defer the style buckets (props are fine), to ensure we get the correct position of the boundary
-		 *
-		 * Again this is very niche, and since we're not marketing ourselves as a proper shared element transition
-		 * package, we won't spend time finding a better solution for this.
-		 *
-		 */
-		const shouldDeferStyleBuckets = pendingLifecycleStartBlockCount.get() > 0;
-
 		const { current, next, progress } = props;
 		const isDragging = current.gesture.dragging;
 		const isNextClosing = !!next?.closing;
@@ -194,8 +175,21 @@ export const useInterpolatedStylesMap = () => {
 		const isInGestureMode =
 			!!isDragging || isGesturingDuringCloseAnimation.get();
 
-		const interpolatorOptionsOwner =
-			isInGestureMode || !nextInterpolator ? "current" : "next";
+		// The current screen keeps interpolator ownership until the next screen is
+		// genuinely live: never during a gesture-driven close, never before a next
+		// interpolator exists, and never in the next screen's pre-start window
+		// (entering, but no transformed frame yet). Only then does "next" take over.
+		const currentOwnsInterpolator =
+			isInGestureMode ||
+			!nextInterpolator ||
+			isOpeningBeforeStart(
+				activeEntering.get(),
+				activeTransitionProgress.get(),
+			);
+
+		const interpolatorOptionsOwner = currentOwnsInterpolator
+			? "current"
+			: "next";
 
 		let selectedProgress = progress;
 		let selectedNext = next;
@@ -212,7 +206,6 @@ export const useInterpolatedStylesMap = () => {
 			next: selectedNext,
 			bounds: boundsAccessor,
 			transition,
-			shouldDeferStyleBuckets,
 		});
 
 		if (interpolatorOptionsOwner === "current") {
@@ -237,7 +230,6 @@ export const useInterpolatedStylesMap = () => {
 			next: selectedNext,
 			bounds: boundsAccessor,
 			transition,
-			shouldDeferStyleBuckets,
 		});
 
 		syncSelectedInterpolatorOptions(

package/src/shared/providers/screen/styles/hooks/use-maybe-block-visibility.tsx

@@ -16,22 +16,12 @@ export const useMaybeBlockVisibility = (isFloatingOverlay?: boolean) => {
 	const { currentScreenKey } = useDescriptorDerivations();
 	const { entering, transitionProgress } =
 		AnimationStore.getBag(currentScreenKey);
-
 	const { pendingLifecycleStartBlockCount, pendingLifecycleRequestKind } =
 		SystemStore.getBag(currentScreenKey);
 
 	const hasVisibilityGateOpened = useSharedValue(false);
 	const shouldBlockVisibility = useSharedValue(!isFloatingOverlay);
 
-	/**
-	 * Visibility has to start blocked before the first animated style pass.
-	 *
-	 * `useDerivedValue` can publish its computed value after `useAnimatedStyle`
-	 * has already read the initial one, which briefly exposes an unhydrated
-	 * screen. Keep the visible state in an eagerly initialized shared value, then
-	 * let the reaction open it once the visibility gate allows the first
-	 * transformed frame to render.
-	 */
 	useAnimatedReaction(
 		() => {
 			"worklet";
@@ -58,13 +48,6 @@ export const useMaybeBlockVisibility = (isFloatingOverlay?: boolean) => {
 
 	const animatedStyle = useAnimatedStyle(() => {
 		"worklet";
-		/**
-		 * Keep blocked screens physically offscreen. On physical devices,
-		 * opacity: 0 can break Liquid Glass sampling.
-		 *
-		 * See: https://github.com/expo/expo/issues/41024
-		 *
-		 */
 		const offset = getVisibilityBlockOffset(height);
 
 		return {
@@ -88,6 +71,5 @@ export const useMaybeBlockVisibility = (isFloatingOverlay?: boolean) => {
 	return {
 		animatedStyle,
 		animatedProps,
-		shouldBlockVisibility,
 	};
 };

package/src/shared/providers/screen/styles/hooks/use-resolved-slot-style-map.tsx

@@ -6,6 +6,7 @@ import {
 import { NO_PROPS, NO_STYLES } from "../../../../constants";
 import type { NormalizedTransitionInterpolatedStyle } from "../../../../types/animation.types";
 import {
+	areResettableStatesBySlotEqual,
 	type LocalStyleLayers,
 	type ResettableStyleStatesBySlot,
 	resolveSlotStyles,
@@ -26,7 +27,7 @@ export const useResolvedStylesMap = ({
 	const previousResolvedStylesMap =
 		useSharedValue<NormalizedTransitionInterpolatedStyle>(NO_STYLES);
 
-	return useDerivedValue(() => {
+	return useDerivedValue<NormalizedTransitionInterpolatedStyle>(() => {
 		"worklet";
 		const { resolvedStylesMap, nextPreviousStyleStatesBySlot } =
 			resolveSlotStyles({
@@ -35,12 +36,24 @@ export const useResolvedStylesMap = ({
 				previousStyleStatesBySlot: previousStyleStatesBySlot.get(),
 			});
 
-		previousStyleStatesBySlot.set(nextPreviousStyleStatesBySlot);
+		if (
+			!areResettableStatesBySlotEqual(
+				previousStyleStatesBySlot.get(),
+				nextPreviousStyleStatesBySlot,
+			)
+		) {
+			previousStyleStatesBySlot.set(nextPreviousStyleStatesBySlot);
+		}
+
+		const previousResolvedStyles = previousResolvedStylesMap.get();
 		const stableResolvedStylesMap = reuseEqualResolvedSlots({
 			resolvedStylesMap,
-			previousResolvedStylesMap: previousResolvedStylesMap.get(),
+			previousResolvedStylesMap: previousResolvedStyles,
 		});
-		previousResolvedStylesMap.set(stableResolvedStylesMap);
+
+		if (stableResolvedStylesMap !== previousResolvedStyles) {
+			previousResolvedStylesMap.set(stableResolvedStylesMap);
+		}
 
 		return stableResolvedStylesMap;
 	});

package/src/shared/providers/screen/styles/index.tsx

@@ -1,5 +1,9 @@
 export {
-	ScreenStylesContext,
-	ScreenStylesProvider,
-	useScreenStyles,
-} from "./styles.provider";
+	ScreenSlotContext,
+	type ScreenSlotName,
+	ScreenSlotProvider,
+	useScreenSlots,
+	useSlotProps,
+	useSlotStackingStyles,
+	useSlotStyles,
+} from "./slot.provider";

package/src/shared/providers/screen/styles/slot.provider.tsx

@@ -0,0 +1,111 @@
+import { type ReactNode, useContext } from "react";
+import { StyleSheet } from "react-native";
+import Animated, {
+	type SharedValue,
+	useAnimatedProps,
+	useAnimatedStyle,
+} from "react-native-reanimated";
+import {
+	type NAVIGATION_MASK_CONTAINER_STYLE_ID,
+	type NAVIGATION_MASK_ELEMENT_STYLE_ID,
+	NO_PROPS,
+	NO_STYLES,
+} from "../../../constants";
+import type { NormalizedTransitionInterpolatedStyle } from "../../../types/animation.types";
+import createProvider from "../../../utils/create-provider";
+import { FloatingOverlayLayer } from "./components/floating-overlay-layer";
+import { useInterpolatedStylesMap } from "./hooks/use-interpolated-style-maps";
+import { useMaybeBlockVisibility } from "./hooks/use-maybe-block-visibility";
+import { useResolvedStylesMap } from "./hooks/use-resolved-slot-style-map";
+
+type Props = {
+	children: ReactNode;
+	isFloatingOverlay?: boolean;
+};
+
+export type ScreenSlotName =
+	| "content"
+	| "backdrop"
+	| "surface"
+	| typeof NAVIGATION_MASK_CONTAINER_STYLE_ID
+	| typeof NAVIGATION_MASK_ELEMENT_STYLE_ID;
+
+type ScreenSlotContextValue = {
+	slotsMap: SharedValue<NormalizedTransitionInterpolatedStyle>;
+};
+
+export const {
+	ScreenSlotProvider,
+	ScreenSlotContext,
+	useScreenSlotContext: useScreenSlots,
+} = createProvider("ScreenSlot", {
+	guarded: true,
+})<Props, ScreenSlotContextValue>(({ children, isFloatingOverlay }) => {
+	const parentContext = useContext(ScreenSlotContext);
+
+	const rawStylesMaps = useInterpolatedStylesMap();
+
+	const slotsMap = useResolvedStylesMap({
+		localStylesMaps: rawStylesMaps,
+		ancestorStylesMap: parentContext?.slotsMap,
+	});
+	const { animatedStyle, animatedProps } =
+		useMaybeBlockVisibility(isFloatingOverlay);
+
+	return {
+		value: {
+			slotsMap,
+		},
+		children: (
+			<FloatingOverlayLayer enabled={isFloatingOverlay}>
+				<Animated.View
+					style={[styles.container, animatedStyle]}
+					animatedProps={animatedProps}
+				>
+					{children}
+				</Animated.View>
+			</FloatingOverlayLayer>
+		),
+	};
+});
+
+const styles = StyleSheet.create({
+	container: { flex: 1 },
+});
+
+export const useSlotStyles = (slotId: string | undefined) => {
+	const { slotsMap } = useScreenSlots();
+
+	return useAnimatedStyle(() => {
+		return (slotId ? slotsMap.get()[slotId]?.style : undefined) ?? NO_STYLES;
+	});
+};
+
+/**
+ * Stacking-only slice (`zIndex`/`elevation`) of a slot's style. Returned
+ * separately so an owner can keep just its stacking context while a nested
+ * target takes the full associated style. Yields `NO_STYLES` when neither is set.
+ */
+export const useSlotStackingStyles = (slotId: string | undefined) => {
+	const { slotsMap } = useScreenSlots();
+
+	return useAnimatedStyle(() => {
+		const baseStyle = slotId ? slotsMap.get()[slotId]?.style : undefined;
+		const zIndex = baseStyle?.zIndex ?? 0;
+		const elevation = baseStyle?.elevation ?? 0;
+
+		if (zIndex === 0 && elevation === 0) {
+			return NO_STYLES;
+		}
+
+		return { zIndex, elevation };
+	});
+};
+
+export const useSlotProps = (slotId: string | undefined) => {
+	const { slotsMap } = useScreenSlots();
+
+	return useAnimatedProps(() => {
+		return (slotId ? slotsMap.get()[slotId]?.props : undefined) ?? NO_PROPS;
+	});
+};

package/src/shared/stores/animation.store.ts

@@ -8,6 +8,7 @@ import { createStore } from "../utils/create-store";
 export type AnimationStoreMap = {
 	transitionProgress: SharedValue<number>;
 	visualProgress: SharedValue<number>;
+	stackProgress: SharedValue<number>;
 	willAnimate: SharedValue<number>;
 	progressAnimating: SharedValue<number>;
 	progressSettled: SharedValue<number>;
@@ -19,6 +20,7 @@ function createAnimationBag(): AnimationStoreMap {
 	return {
 		transitionProgress: makeMutable(0),
 		visualProgress: makeMutable(0),
+		stackProgress: makeMutable(0),
 		willAnimate: makeMutable(0),
 		closing: makeMutable(0),
 		progressAnimating: makeMutable(0),
@@ -37,6 +39,7 @@ export const AnimationStore = createStore<AnimationStoreMap>({
 	disposeBag: (bag) => {
 		cancelAnimation(bag.transitionProgress);
 		cancelAnimation(bag.visualProgress);
+		cancelAnimation(bag.stackProgress);
 		cancelAnimation(bag.willAnimate);
 		cancelAnimation(bag.progressAnimating);
 		cancelAnimation(bag.progressSettled);

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

@@ -1,4 +1,5 @@
 import type {
+	BoundTag,
 	GroupKey,
 	LinkGroupState,
 	LinkKey,
@@ -66,6 +67,22 @@ export const createGroupTag = (group: GroupKey, linkKey: LinkKey): string => {
 	return `${group}:${linkKey}`;
 };
 
+/**
+ * Builds the {@link BoundTag} identity for a boundary. The combined `tag` is
+ * group-prefixed only when a group is present, matching how links are keyed.
+ */
+export const createBoundTag = (
+	linkKey: LinkKey,
+	group?: GroupKey,
+): BoundTag => {
+	"worklet";
+	return {
+		tag: group ? createGroupTag(group, linkKey) : linkKey,
+		linkKey,
+		group,
+	};
+};
+
 const ensurePairState = (
 	state: LinkPairsState,
 	pairKey: ScreenPairKey,

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

@@ -10,6 +10,20 @@ export type TagID = string;
 export type LinkKey = string;
 export type GroupKey = string;
 export type ScreenPairKey = string;
+
+/**
+ * A boundary's identity, carried as one value instead of the
+ * `{ tag, linkKey, group }` clump that used to thread through every hook.
+ *
+ * - `tag`: the combined entry tag (`group:linkKey` when grouped, else `linkKey`).
+ * - `linkKey`: the bare member key used to address links within a screen pair.
+ * - `group`: the optional collection name.
+ */
+export interface BoundTag {
+	tag: string;
+	linkKey: LinkKey;
+	group?: GroupKey;
+}
 export type BoundsPortalAttachTarget = "current-screen" | "matched-screen";
 export type { ScreenKey } from "../../types/screen.types";
 

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

@@ -33,6 +33,7 @@ import {
 	resolveBackgroundScale,
 	resolveDragScaleTuple,
 	resolveDragTranslationTuple,
+	resolveZoomPanGestureDirection,
 } from "./helpers";
 import { resolveDirectionalDragTranslation } from "./math";
 import type { BuildZoomStylesParams, ZoomInterpolatedStyle } from "./types";
@@ -139,7 +140,14 @@ export function buildZoomStyles({
 	const gestureHandoff = liveGesture.handoff;
 	const normX = gestureHandoff.normX;
 	const normY = gestureHandoff.normY;
-	const initialGesture = gestureHandoff.active ?? gestureHandoff.direction;
+	const initialGesture = resolveZoomPanGestureDirection({
+		active: gestureHandoff.active,
+		direction: gestureHandoff.direction,
+		normX,
+		normY,
+		rawNormX: gestureHandoff.raw.normX,
+		rawNormY: gestureHandoff.raw.normY,
+	});
 	const isHorizontalDismiss =
 		initialGesture === "horizontal" || initialGesture === "horizontal-inverted";
 	const isVerticalDismiss =

package/src/shared/utils/bounds/navigation/zoom/helpers.ts

@@ -1,5 +1,10 @@
 import { interpolate } from "react-native-reanimated";
+import { EPSILON } from "../../../../constants";
 import type { BoundsLink } from "../../../../types/bounds.types";
+import type {
+	ActiveGesture,
+	ResolvedPanGestureDirection,
+} from "../../../../types/gesture.types";
 import type { Layout } from "../../../../types/screen.types";
 import type { BoundsOptions } from "../../types/options";
 import {
@@ -94,6 +99,97 @@ export function resolveBackgroundScale(value: number | undefined) {
 	return value ?? ZOOM_BACKGROUND_SCALE;
 }
 
+const isResolvedPanDirection = (
+	direction: ActiveGesture | null | undefined,
+): direction is ResolvedPanGestureDirection => {
+	"worklet";
+	return (
+		direction === "horizontal" ||
+		direction === "horizontal-inverted" ||
+		direction === "vertical" ||
+		direction === "vertical-inverted"
+	);
+};
+
+const resolveMotionDirection = ({
+	normX,
+	normY,
+	rawNormX,
+	rawNormY,
+}: {
+	normX: number;
+	normY: number;
+	rawNormX: number;
+	rawNormY: number;
+}): ResolvedPanGestureDirection | null => {
+	"worklet";
+	const motionX = Math.max(Math.abs(normX), Math.abs(rawNormX));
+	const motionY = Math.max(Math.abs(normY), Math.abs(rawNormY));
+
+	if (motionX <= EPSILON && motionY <= EPSILON) {
+		return null;
+	}
+
+	if (motionY > motionX + EPSILON) {
+		return normY < 0 || rawNormY < 0 ? "vertical-inverted" : "vertical";
+	}
+
+	if (motionX > motionY + EPSILON) {
+		return normX < 0 || rawNormX < 0 ? "horizontal-inverted" : "horizontal";
+	}
+
+	return null;
+};
+
+export function resolveZoomPanGestureDirection({
+	active,
+	direction,
+	normX,
+	normY,
+	rawNormX,
+	rawNormY,
+}: {
+	active: ActiveGesture | null | undefined;
+	direction: ActiveGesture | null | undefined;
+	normX: number;
+	normY: number;
+	rawNormX: number;
+	rawNormY: number;
+}): ResolvedPanGestureDirection | null {
+	"worklet";
+	const storedDirection = active ?? direction;
+	const motionDirection = resolveMotionDirection({
+		normX,
+		normY,
+		rawNormX,
+		rawNormY,
+	});
+
+	if (!isResolvedPanDirection(storedDirection)) {
+		return motionDirection;
+	}
+
+	if (!motionDirection) {
+		return storedDirection;
+	}
+
+	const storedIsHorizontal =
+		storedDirection === "horizontal" ||
+		storedDirection === "horizontal-inverted";
+	const storedMotion = storedIsHorizontal
+		? Math.max(Math.abs(normX), Math.abs(rawNormX))
+		: Math.max(Math.abs(normY), Math.abs(rawNormY));
+	const oppositeMotion = storedIsHorizontal
+		? Math.max(Math.abs(normY), Math.abs(rawNormY))
+		: Math.max(Math.abs(normX), Math.abs(rawNormX));
+
+	if (oppositeMotion > storedMotion + EPSILON) {
+		return motionDirection;
+	}
+
+	return storedDirection;
+}
+
 export function interpolateOpacityRange(params: {
 	progress: number;
 	range: {

package/src/shared/utils/logger.ts

@@ -1,5 +1,7 @@
 const LIBRARY_NAME = "react-native-screen-transitions";
 
+const warnedKeys = new Set<string>();
+
 export const logger = {
 	error(message: string) {
 		"worklet";
@@ -9,4 +11,14 @@ export const logger = {
 		"worklet";
 		console.warn(`[${LIBRARY_NAME}] ${message}`);
 	},
+	/**
+	 * Warns at most once per `key` for the lifetime of the JS context. Use for
+	 * install/config-level conditions that would otherwise spam every render or
+	 * every mounted instance. JS-thread only (not a worklet).
+	 */
+	warnOnce(key: string, message: string) {
+		if (warnedKeys.has(key)) return;
+		warnedKeys.add(key);
+		console.warn(`[${LIBRARY_NAME}] ${message}`);
+	},
 };

package/lib/commonjs/shared/components/boundary/providers/boundary-owner.provider.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_react","require","_createProvider","_interopRequireDefault","_logger","e","__esModule","default","MULTIPLE_TARGETS_WARNING","TARGET_OUTSIDE_OWNER_WARNING","exports","BoundaryOwnerProvider","useBoundaryOwnerContext","createProvider","guarded","props","useBoundaryOwner","params","ownerRef","associatedTargetStyles","entryTag","portal","warnedAboutMultipleTargetsRef","useRef","targetEntry","setTargetEntry","useState","registerTargetRef","useCallback","targetRef","preparedStyles","measurementRef","prev","ref","__DEV__","current","logger","warn","unregisterTargetRef","contextValue","useMemo","activeTargetRef","hasActiveTarget","measuredRef","targetPreparedStyles"],"sourceRoot":"../../../../../../src","sources":["shared/components/boundary/providers/boundary-owner.provider.tsx"],"mappings":";;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AAIA,IAAAC,eAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,OAAA,GAAAH,OAAA;AAA+C,SAAAE,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AA4B/C;AACA,MAAMG,wBAAwB,GAC7B,8HAA8H;AAExH,MAAMC,4BAA4B,GAAAC,OAAA,CAAAD,4BAAA,GACxC,gJAAgJ;AAO1I,MAAM;EAAEE,qBAAqB;EAAEC;AAAwB,CAAC,GAC9D,IAAAC,uBAAc,EAAC,eAAe,EAAE;EAAEC,OAAO,EAAE;AAAM,CAAC,CAAC,CAGhDC,KAAK,IAAKA,KAAK,CAAC;AAACL,OAAA,CAAAE,uBAAA,GAAAA,uBAAA;AAAAF,OAAA,CAAAC,qBAAA,GAAAA,qBAAA;AAEd,MAAMK,gBAAgB,GAAIC,MAKhC,IAAK;EACL,MAAM;IAAEC,QAAQ;IAAEC,sBAAsB;IAAEC,QAAQ;IAAEC;EAAO,CAAC,GAAGJ,MAAM;EACrE,MAAMK,6BAA6B,GAAG,IAAAC,aAAM,EAAC,KAAK,CAAC;EACnD,MAAM,CAACC,WAAW,EAAEC,cAAc,CAAC,GAAG,IAAAC,eAAQ,EAC7C,IACD,CAAC;EAED,MAAMC,iBAAiB,GAAG,IAAAC,kBAAW,EACpC,CACCC,SAA4B,EAC5BC,cAA0B,EAC1BC,cAAkC,KAC9B;IACJN,cAAc,CAAEO,IAAI,IAAK;MACxB,IAAIA,IAAI,EAAEC,GAAG,KAAKJ,SAAS,EAAE;QAC5B,OAAOG,IAAI;MACZ;MAEA,IACCE,OAAO,IACPF,IAAI,KAAK,IAAI,IACb,CAACV,6BAA6B,CAACa,OAAO,EACrC;QACDb,6BAA6B,CAACa,OAAO,GAAG,IAAI;QAC5CC,cAAM,CAACC,IAAI,CAAC7B,wBAAwB,CAAC;MACtC;MAEA,OACCwB,IAAI,IAAI;QACPC,GAAG,EAAEJ,SAAS;QACdE,cAAc,EAAEA,cAAc,IAAIF,SAAS;QAC3CC;MACD,CAAC;IAEH,CAAC,CAAC;EACH,CAAC,EACD,EACD,CAAC;EAED,MAAMQ,mBAAmB,GAAG,IAAAV,kBAAW,EAAEC,SAA4B,IAAK;IACzEJ,cAAc,CAAEO,IAAI,IAAMA,IAAI,EAAEC,GAAG,KAAKJ,SAAS,GAAG,IAAI,GAAGG,IAAK,CAAC;EAClE,CAAC,EAAE,EAAE,CAAC;EAEN,MAAMO,YAAY,GAAG,IAAAC,cAAO,EAC3B,OAAO;IACNtB,QAAQ;IACRS,iBAAiB;IACjBW,mBAAmB;IACnBG,eAAe,EAAEjB,WAAW,EAAES,GAAG,IAAI,IAAI;IACzCd,sBAAsB;IACtBC,QAAQ;IACRC;EACD,CAAC,CAAC,EACF,CACCH,QAAQ,EACRS,iBAAiB,EACjBW,mBAAmB,EACnBd,WAAW,EACXL,sBAAsB,EACtBC,QAAQ,EACRC,MAAM,CAER,CAAC;EAED,OAAO;IACNkB,YAAY;IACZG,eAAe,EAAElB,WAAW,KAAK,IAAI;IACrCmB,WAAW,EAAEnB,WAAW,EAAEO,cAAc,IAAIb,QAAQ;IACpD0B,oBAAoB,EAAEpB,WAAW,EAAEM,cAAc;IACjDT;EACD,CAAC;AACF,CAAC;AAACX,OAAA,CAAAM,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/lib/commonjs/shared/providers/screen/styles/helpers/preserve-animated-props-only.js

@@ -1,26 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.preserveAnimatedPropsOnly = void 0;
-var _constants = require("../../../../constants");
-const preserveAnimatedPropsOnly = stylesMap => {
-  "worklet";
-
-  let hasProps = false;
-  const propsOnly = {};
-  for (const slotId in stylesMap) {
-    const slot = stylesMap[slotId];
-    if (!slot || slot.props === undefined) {
-      continue;
-    }
-    propsOnly[slotId] = {
-      props: slot.props
-    };
-    hasProps = true;
-  }
-  return hasProps ? propsOnly : _constants.NO_STYLES;
-};
-exports.preserveAnimatedPropsOnly = preserveAnimatedPropsOnly;
-//# sourceMappingURL=preserve-animated-props-only.js.map

package/lib/commonjs/shared/providers/screen/styles/helpers/preserve-animated-props-only.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_constants","require","preserveAnimatedPropsOnly","stylesMap","hasProps","propsOnly","slotId","slot","props","undefined","NO_STYLES","exports"],"sourceRoot":"../../../../../../../src","sources":["shared/providers/screen/styles/helpers/preserve-animated-props-only.ts"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAGO,MAAMC,yBAAyB,GACrCC,SAAgD,IACL;EAC3C,SAAS;;EACT,IAAIC,QAAQ,GAAG,KAAK;EACpB,MAAMC,SAAgD,GAAG,CAAC,CAAC;EAE3D,KAAK,MAAMC,MAAM,IAAIH,SAAS,EAAE;IAC/B,MAAMI,IAAI,GAAGJ,SAAS,CAACG,MAAM,CAAC;IAC9B,IAAI,CAACC,IAAI,IAAIA,IAAI,CAACC,KAAK,KAAKC,SAAS,EAAE;MACtC;IACD;IAEAJ,SAAS,CAACC,MAAM,CAAC,GAAG;MAAEE,KAAK,EAAED,IAAI,CAACC;IAAM,CAAC;IACzCJ,QAAQ,GAAG,IAAI;EAChB;EAEA,OAAOA,QAAQ,GAAGC,SAAS,GAAGK,oBAAS;AACxC,CAAC;AAACC,OAAA,CAAAT,yBAAA,GAAAA,yBAAA","ignoreList":[]}