react-native-screen-transitions 2.1.0 → 2.2.1

package/lib/typescript/hooks/animation/use-associated-style.d.ts

@@ -1,12 +1,12 @@
+import { type StyleProps } from "react-native-reanimated";
 type Props = {
     id?: string;
+    style?: StyleProps;
 };
 /**
- * This hook is used to get the associated styles for a given styleId.
- * It is used to get the associated styles for a given styleId.
- * It is used to get the associated styles for a given styleId.
+ * This hook is used to get the associated styles for a given styleId / boundTag.
  */
-export declare const useAssociatedStyles: ({ id }?: Props) => {
+export declare const useAssociatedStyles: ({ id, style }?: Props) => {
     associatedStyles: Readonly<{}>;
 };
 export {};

package/lib/typescript/hooks/animation/use-associated-style.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-associated-style.d.ts","sourceRoot":"","sources":["../../../../src/hooks/animation/use-associated-style.tsx"],"names":[],"mappings":"AAGA,KAAK,KAAK,GAAG;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AAIF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAQ,KAAU;;CAcrD,CAAC"}
+{"version":3,"file":"use-associated-style.d.ts","sourceRoot":"","sources":["../../../../src/hooks/animation/use-associated-style.tsx"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,UAAU,EAIf,MAAM,yBAAyB,CAAC;AAGjC,KAAK,KAAK,GAAG;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,UAAU,CAAC;CACnB,CAAC;AAIF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,gBAAe,KAAU;;CA6C5D,CAAC"}

package/lib/typescript/hooks/bounds/use-bound-registry.d.ts

@@ -13,7 +13,6 @@ interface BoundMeasurerHookProps {
 export declare const useBoundsRegistry: ({ sharedBoundTag, animatedRef, current, style, }: BoundMeasurerHookProps) => {
     measureBounds: () => void;
     handleLayout: () => void;
-    measureOnTouchStart: () => void;
 };
 export {};
 //# sourceMappingURL=use-bound-registry.d.ts.map

package/lib/typescript/hooks/bounds/use-bound-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-bound-registry.d.ts","sourceRoot":"","sources":["../../../../src/hooks/bounds/use-bound-registry.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EACN,KAAK,WAAW,EAEhB,KAAK,UAAU,EAEf,MAAM,yBAAyB,CAAC;AAOjC,UAAU,sBAAsB;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,EAAE;QAAE,KAAK,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACpC,KAAK,EAAE,UAAU,CAAC;CAClB;AAED,eAAO,MAAM,iBAAiB,GAAI,kDAK/B,sBAAsB;;;;CAwDxB,CAAC"}
+{"version":3,"file":"use-bound-registry.d.ts","sourceRoot":"","sources":["../../../../src/hooks/bounds/use-bound-registry.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EACN,KAAK,WAAW,EAEhB,KAAK,UAAU,EAEf,MAAM,yBAAyB,CAAC;AAMjC,UAAU,sBAAsB;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,EAAE;QAAE,KAAK,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACpC,KAAK,EAAE,UAAU,CAAC;CAClB;AAED,eAAO,MAAM,iBAAiB,GAAI,kDAK/B,sBAAsB;;;CA8CxB,CAAC"}

package/lib/typescript/index.d.ts

@@ -209,6 +209,7 @@ declare const _default: {
     } & {
         styleId?: string;
         sharedBoundTag?: string;
+        measureOnLayout?: boolean;
     } & import("react").RefAttributes<never>>>;
     Pressable: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<{
         id?: string | import("react-native-reanimated").SharedValue<string | undefined> | undefined;
@@ -457,6 +458,7 @@ declare const _default: {
     } & {
         styleId?: string;
         sharedBoundTag?: string;
+        measureOnLayout?: boolean;
     } & import("react").RefAttributes<View | import("react").Component<import("react-native").PressableProps & import("react").RefAttributes<View>, any, any>>>>;
     ScrollView: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<{
         id?: string | import("react-native-reanimated").SharedValue<string | undefined> | undefined;
@@ -793,6 +795,7 @@ declare const _default: {
     } & {
         styleId?: string;
         sharedBoundTag?: string;
+        measureOnLayout?: boolean;
     } & import("react").RefAttributes<never>>>;
     FlatList: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<{
         id?: string | import("react-native-reanimated").SharedValue<string | undefined> | undefined;
@@ -1263,6 +1266,7 @@ declare const _default: {
     } & {
         styleId?: string;
         sharedBoundTag?: string;
+        measureOnLayout?: boolean;
     } & import("react").RefAttributes<never>>>;
     MaskedView: typeof MaskedView;
     presets: {

package/lib/typescript/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,IAAI,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,8BAA8B,EAAE,MAAM,gDAAgD,CAAC;AAChG,OAAO,UAAU,MAAM,uCAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAgC4iE,CAAC;;;;;;;;;;;AA7B5mE,wBAaE;AAEF,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,0BAA0B,EAAE,MAAM,mEAAmE,CAAC;AAE/G,YAAY,EACX,0BAA0B,EAC1B,sBAAsB,EACtB,2BAA2B,EAC3B,6BAA6B,EAC7B,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,GACtB,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,IAAI,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,8BAA8B,EAAE,MAAM,gDAAgD,CAAC;AAChG,OAAO,UAAU,MAAM,uCAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAgC4iE,CAAC;;;;;;;;;;;AA7B5mE,wBAaE;AAEF,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,0BAA0B,EAAE,MAAM,mEAAmE,CAAC;AAE/G,YAAY,EACX,0BAA0B,EAC1B,sBAAsB,EACtB,2BAA2B,EAC3B,6BAA6B,EAC7B,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,GACtB,MAAM,mBAAmB,CAAC"}

package/lib/typescript/providers/transition-styles.d.ts

@@ -1,8 +1,11 @@
+import { useDerivedValue } from "react-native-reanimated";
 import type { TransitionInterpolatedStyle } from "../types/animation";
 type Props = {
     children: React.ReactNode;
 };
 export declare function TransitionStylesProvider({ children }: Props): import("react/jsx-runtime").JSX.Element;
-export declare function useTransitionStyles(): import("react-native-reanimated").DerivedValue<TransitionInterpolatedStyle>;
+export declare function useTransitionStyles(): {
+    stylesMap: ReturnType<typeof useDerivedValue<TransitionInterpolatedStyle>>;
+};
 export {};
 //# sourceMappingURL=transition-styles.d.ts.map

package/lib/typescript/providers/transition-styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transition-styles.d.ts","sourceRoot":"","sources":["../../../src/providers/transition-styles.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,KAAK,KAAK,GAAG;IACZ,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC1B,CAAC;AAQF,wBAAgB,wBAAwB,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,2CA0B3D;AAED,wBAAgB,mBAAmB,gFAQlC"}
+{"version":3,"file":"transition-styles.d.ts","sourceRoot":"","sources":["../../../src/providers/transition-styles.tsx"],"names":[],"mappings":"AACA,OAAO,EAAqB,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE7E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,KAAK,KAAK,GAAG;IACZ,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC1B,CAAC;AAUF,wBAAgB,wBAAwB,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,2CA8B3D;AAED,wBAAgB,mBAAmB;eApCtB,UAAU,CAAC,OAAO,eAAe,CAAC,2BAA2B,CAAC,CAAC;EA4C3E"}

package/lib/typescript/stores/bounds/_utils.d.ts

@@ -0,0 +1,24 @@
+import type { ScreenTransitionState } from "../../types/animation";
+type GetCache = (fromKey: string, toKey: string) => string | null;
+type SetCache = (fromKey: string, toKey: string, id: string) => void;
+type GetRouteActive = (routeKey: string) => string | null;
+interface ResolveActiveBoundParams {
+    current: ScreenTransitionState;
+    next?: ScreenTransitionState;
+    previous?: ScreenTransitionState;
+    getPairCache: GetCache;
+    setPairCache: SetCache;
+    getRouteActive: GetRouteActive;
+}
+export declare function pairKey(fromKey?: string, toKey?: string): string;
+/**
+ * Util function to get the active bound id for a given transition state.
+ *
+ * It will check by ( priority from highest to lowest ):
+ * 1. Requested id
+ * 2. Cache
+ * 3. Intersection
+ */
+export declare function resolveActiveBound({ current, next, previous, getPairCache, setPairCache, getRouteActive, }: ResolveActiveBoundParams): string;
+export {};
+//# sourceMappingURL=_utils.d.ts.map

package/lib/typescript/stores/bounds/_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_utils.d.ts","sourceRoot":"","sources":["../../../../src/stores/bounds/_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,KAAK,QAAQ,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;AAClE,KAAK,QAAQ,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;AACrE,KAAK,cAAc,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;AAE1D,UAAU,wBAAwB;IACjC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,IAAI,CAAC,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,YAAY,EAAE,QAAQ,CAAC;IACvB,YAAY,EAAE,QAAQ,CAAC;IACvB,cAAc,EAAE,cAAc,CAAC;CAC/B;AAED,wBAAgB,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,UAGvD;AA2ED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,EAClC,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,cAAc,GACd,EAAE,wBAAwB,UAoD1B"}

package/lib/typescript/stores/{bounds.d.ts → bounds/index.d.ts}

@@ -1,32 +1,22 @@
 import { type MeasuredDimensions, type StyleProps } from "react-native-reanimated";
-import type { ScreenTransitionState } from "../types/animation";
-import type { ScreenKey } from "../types/navigator";
+import type { ScreenTransitionState } from "../../types/animation";
+import type { ScreenKey } from "../../types/navigator";
 declare function setBounds(screenId: string, boundId: string, bounds?: MeasuredDimensions | null, styles?: StyleProps): void;
 declare function getBounds(screenId: string): Record<string, {
     bounds: MeasuredDimensions;
     styles: StyleProps;
 }>;
-declare function setActiveBoundId(boundId: string): void;
-declare function getActiveBoundId(): string | null;
 declare function setRouteActive(routeKey: string, boundId: string): void;
 declare function getRouteActive(routeKey: string): string;
-declare function setTransitionHint(fromKey: string, toKey: string, boundId: string): void;
-declare function getTransitionHint(fromKey: string, toKey: string): string | null;
 declare function clear(routeKey: ScreenKey): void;
-declare function clearActive(): void;
 declare function getActiveBound(current: ScreenTransitionState, next: ScreenTransitionState | undefined, previous: ScreenTransitionState | undefined): string;
 export declare const Bounds: {
     setBounds: typeof setBounds;
     getBounds: typeof getBounds;
-    setActiveBoundId: typeof setActiveBoundId;
-    getActiveBoundId: typeof getActiveBoundId;
     setRouteActive: typeof setRouteActive;
     getRouteActive: typeof getRouteActive;
-    setTransitionHint: typeof setTransitionHint;
-    getTransitionHint: typeof getTransitionHint;
     clear: typeof clear;
-    clearActive: typeof clearActive;
     getActiveBound: typeof getActiveBound;
 };
 export {};
-//# sourceMappingURL=bounds.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/stores/bounds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stores/bounds/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,kBAAkB,EAEvB,KAAK,UAAU,EACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAavD,iBAAS,SAAS,CACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,kBAAkB,GAAG,IAAW,EACxC,MAAM,GAAE,UAAe,QAYvB;AAED,iBAAS,SAAS,CAAC,QAAQ,EAAE,MAAM;YAzBT,kBAAkB;YAAU,UAAU;GA4B/D;AAED,iBAAS,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,QAOxD;AAED,iBAAS,cAAc,CAAC,QAAQ,EAAE,MAAM,UAGvC;AAoBD,iBAAS,KAAK,CAAC,QAAQ,EAAE,SAAS,QAyBjC;AAED,iBAAS,cAAc,CACtB,OAAO,EAAE,qBAAqB,EAC9B,IAAI,EAAE,qBAAqB,GAAG,SAAS,EACvC,QAAQ,EAAE,qBAAqB,GAAG,SAAS,UAW3C;AAED,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAC"}

package/lib/typescript/stores/utils/reset-stores-for-screen.d.ts

@@ -2,7 +2,5 @@ import type { NativeStackDescriptor } from "../../types/navigator";
 /**
  * Reset all stores for a given screen
  */
-export declare const resetStoresForScreen: (current: NativeStackDescriptor, options?: {
-    clearActive?: boolean;
-}) => void;
+export declare const resetStoresForScreen: (current: NativeStackDescriptor) => void;
 //# sourceMappingURL=reset-stores-for-screen.d.ts.map

package/lib/typescript/stores/utils/reset-stores-for-screen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reset-stores-for-screen.d.ts","sourceRoot":"","sources":["../../../../src/stores/utils/reset-stores-for-screen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAKnE;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAChC,SAAS,qBAAqB,EAC9B,UAAS;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,SAQvC,CAAC"}
+{"version":3,"file":"reset-stores-for-screen.d.ts","sourceRoot":"","sources":["../../../../src/stores/utils/reset-stores-for-screen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAKnE;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,qBAAqB,SAIlE,CAAC"}

package/lib/typescript/types/core.d.ts

@@ -39,6 +39,14 @@ export type TransitionAwareProps<T extends object> = AnimatedProps<T> & {
      * </Transition.View>
      */
     sharedBoundTag?: string;
+    /**
+     * Eagerly measure this component on layout and store the result in the
+     * Bounds registry. Useful for nested shared elements that may not receive
+     * the press event but still need up-to-date measurements at navigation time.
+     *
+     * Only has an effect when used together with `sharedBoundTag`.
+     */
+    measureOnLayout?: boolean;
 };
 export type TransitionConfig = {
     open: TransitionSpec;

package/lib/typescript/types/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/types/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAE1D,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,IAAI,aAAa,CAAC,CAAC,CAAC,GAAG;IACvE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,cAAc,CAAC;CACtB,CAAC"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/types/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAE1D,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,IAAI,aAAa,CAAC,CAAC,CAAC,GAAG;IACvE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,cAAc,CAAC;CACtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "react-native-screen-transitions",
-	"version": "2.1.0",
+	"version": "2.2.1",
 	"description": "Easy screen transitions for React Native and Expo",
 	"author": "Ed",
 	"license": "MIT",
@@ -49,7 +49,7 @@
 		"@testing-library/react-native": "^13.2.0",
 		"@types/react": "~19.0.10",
 		"react-native-builder-bob": "0.39.0",
-		"typescript": "~5.8.3"
+		"typescript": "catalog:"
 	},
 	"react-native-builder-bob": {
 		"source": "src",
@@ -65,5 +65,5 @@
 			]
 		]
 	},
-	"gitHead": "92afaa07f6b9c279851d6aef805ecbfefdbcc4df"
+	"gitHead": "888d4df9936ec0e3b8221bea7cd81115e6301693"
 }

package/src/__tests__/bounds.store.test.ts

@@ -0,0 +1,185 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { resolveActiveBound } from "../stores/bounds/_utils";
+import type { ScreenTransitionState } from "../types/animation";
+
+type Dim = {
+	x: number;
+	y: number;
+	pageX: number;
+	pageY: number;
+	width: number;
+	height: number;
+};
+
+const getDimensions = (x = 0, y = 0, w = 100, h = 100): Dim => ({
+	x,
+	y,
+	pageX: x,
+	pageY: y,
+	width: w,
+	height: h,
+});
+
+const mockState = (
+	routeKey: string,
+	ids: string[] = [],
+): ScreenTransitionState => {
+	const bounds: Record<
+		string,
+		{ bounds: Dim; styles: Record<string, unknown> }
+	> = {};
+	ids.forEach((id, i) => {
+		bounds[id] = { bounds: getDimensions(i * 10, i * 10), styles: {} };
+	});
+	return {
+		progress: 1,
+		closing: 0,
+		animating: 1,
+		gesture: {
+			x: 0,
+			y: 0,
+			normalizedX: 0,
+			normalizedY: 0,
+			isDismissing: 0,
+			isDragging: 0,
+		},
+		bounds,
+		// @ts-expect-error partial route
+		route: { key: routeKey },
+	};
+};
+
+let cache: Record<string, string>;
+let lastActiveByRoute: Record<string, string>;
+beforeEach(() => {
+	cache = {};
+	lastActiveByRoute = {};
+});
+
+const getPairCache = (from: string, to: string) =>
+	cache[`${from}|${to}`] ?? null;
+const setPairCache = (from: string, to: string, id: string) => {
+	cache[`${from}|${to}`] = id;
+};
+const getRouteActive = (routeKey: string) =>
+	lastActiveByRoute[routeKey] ?? null;
+
+describe("Bounds.getActiveBound - requested id priority and acceptance", () => {
+	it("selects requested id when present only on current (opening)", () => {
+		const A = "A-1";
+		const B = "B-1";
+		const current = mockState(A, ["container"]);
+		const previous = mockState(B, ["icon"]);
+
+		// Opening: fromKey is previous.route.key (B)
+		lastActiveByRoute[B] = "container";
+		const active = resolveActiveBound({
+			current,
+			previous,
+			getPairCache,
+			setPairCache,
+			getRouteActive,
+		});
+
+		expect(active).toBe("container");
+		expect(getPairCache(B, A)).toBeNull();
+	});
+
+	it("selects requested id when present only on other (closing)", () => {
+		const A = "A-2";
+		const B = "B-2";
+		const current = mockState(A, ["icon"]);
+		const next = mockState(B, ["container"]);
+
+		// Closing: fromKey is current.route.key (A)
+		lastActiveByRoute[A] = "container";
+		const active = resolveActiveBound({
+			current,
+			next,
+			getPairCache,
+			setPairCache,
+			getRouteActive,
+		});
+		expect(active).toBe("container");
+		expect(getPairCache(A, B)).toBeNull();
+	});
+});
+
+describe("Bounds.getActiveBound - hint behavior (guarded writes)", () => {
+	it("writes cache only when both sides have the id", () => {
+		const A = "A-3";
+		const B = "B-3";
+		// Both have the same id measured
+		const current = mockState(A, ["container"]);
+		const previous = mockState(B, ["container"]);
+
+		// Opening: fromKey is previous.route.key (B)
+		lastActiveByRoute[B] = "container";
+		const active = resolveActiveBound({
+			current,
+			previous,
+			getPairCache,
+			setPairCache,
+			getRouteActive,
+		});
+		expect(active).toBe("container");
+		expect(getPairCache(B, A)).toBe("container");
+	});
+
+	it("requested id overrides existing cache and updates it when both sides measured", () => {
+		const A = "A-4";
+		const B = "B-4";
+		// Both sides have icon and container
+		// Pre-seed a conflicting cache
+		setPairCache(B, A, "icon");
+
+		const current = mockState(A, ["icon", "container"]);
+		const previous = mockState(B, ["icon", "container"]);
+
+		// Opening: fromKey is previous.route.key (B)
+		lastActiveByRoute[B] = "container";
+		const active = resolveActiveBound({
+			current,
+			previous,
+			getPairCache,
+			setPairCache,
+			getRouteActive,
+		});
+		expect(active).toBe("container");
+		expect(getPairCache(B, A)).toBe("container");
+	});
+});
+
+describe("Bounds.getActiveBound - set intersection and fallbacks", () => {
+	it("falls back to intersection when no request or cache", () => {
+		const A = "A-5";
+		const B = "B-5";
+		const current = mockState(A, ["alpha", "beta"]);
+		const previous = mockState(B, ["beta", "gamma"]);
+
+		const active = resolveActiveBound({
+			current,
+			previous,
+			getPairCache,
+			setPairCache,
+			getRouteActive,
+		});
+		expect(active).toBe("beta");
+	});
+
+	it("when other has a single bound, selects it (no request/cache)", () => {
+		const A = "A-6";
+		const B = "B-6";
+		const current = mockState(A, ["alpha"]);
+		const previous = mockState(B, ["only"]);
+
+		const active = resolveActiveBound({
+			current,
+			previous,
+			getPairCache,
+			setPairCache,
+			getRouteActive,
+		});
+		expect(active).toBe("only");
+	});
+});

package/src/components/bound-capture.tsx

@@ -1,5 +1,6 @@
 import { useMemo } from "react";
 import { Gesture, GestureDetector } from "react-native-gesture-handler";
+import { useKeys } from "../providers/keys";
 import { Bounds } from "../stores/bounds";
 
 interface BoundActivatorProps {
@@ -13,15 +14,17 @@ export const BoundCapture = ({
 	children,
 	measure,
 }: BoundActivatorProps) => {
+	const { current } = useKeys();
+	const routeKey = current.route.key;
 	const tapGesture = useMemo(() => {
 		return Gesture.Tap().onStart(() => {
 			"worklet";
 			if (sharedBoundTag) {
-				Bounds.setActiveBoundId(sharedBoundTag);
+				Bounds.setRouteActive(routeKey, sharedBoundTag);
 				measure();
 			}
 		});
-	}, [sharedBoundTag, measure]);
+	}, [sharedBoundTag, measure, routeKey]);
 
 	if (!sharedBoundTag) return children;
 

package/src/components/controllers/screen-lifecycle.tsx

@@ -24,13 +24,13 @@ export const ScreenLifecycleController = ({
 
 		// Don't run e.preventDefault when the dismissal was on the local root
 		if (requestedDismissOnNavigator) {
-			resetStoresForScreen(current, { clearActive: true });
+			resetStoresForScreen(current);
 			return;
 		}
 
 		// Don't run e.preventDefault when this is the first screen of the stack
 		if (current.navigation.getState().index === 0) {
-			resetStoresForScreen(current, { clearActive: true });
+			resetStoresForScreen(current);
 			return;
 		}
 
@@ -41,7 +41,7 @@ export const ScreenLifecycleController = ({
 
 				// we'll ensure the dispatch is complete before resetting stores
 				requestAnimationFrame(() => {
-					resetStoresForScreen(current, { clearActive: false });
+					resetStoresForScreen(current);
 				});
 			}
 		};

package/src/components/create-transition-aware-component.tsx

@@ -53,14 +53,22 @@ export function createTransitionAwareComponent<P extends object>(
 		React.ComponentRef<typeof AnimatedComponent>,
 		TransitionAwareProps<P>
 	>((props, ref) => {
-		const { children, style, sharedBoundTag, styleId, onPress, ...rest } =
-			props as Any;
+		const {
+			children,
+			style,
+			sharedBoundTag,
+			styleId,
+			onPress,
+			measureOnLayout,
+			...rest
+		} = props as Any;
 
 		const animatedRef = useAnimatedRef<View>();
 		const { current } = useKeys();
 
 		const { associatedStyles } = useAssociatedStyles({
 			id: sharedBoundTag || styleId,
+			style,
 		});
 
 		const { measureBounds, handleLayout } = useBoundsRegistry({
@@ -81,6 +89,14 @@ export function createTransitionAwareComponent<P extends object>(
 			);
 		}
 
+		const onLayoutHandler = runOnUI(() => {
+			"worklet";
+			handleLayout();
+			if (measureOnLayout && sharedBoundTag) {
+				measureBounds();
+			}
+		});
+
 		return (
 			<BoundCapture sharedBoundTag={sharedBoundTag} measure={measureBounds}>
 				<AnimatedComponent
@@ -88,7 +104,7 @@ export function createTransitionAwareComponent<P extends object>(
 					ref={animatedRef}
 					style={[style, associatedStyles]}
 					onPress={onPress}
-					onLayout={runOnUI(handleLayout)}
+					onLayout={onLayoutHandler}
 				>
 					{children}
 				</AnimatedComponent>

package/src/components/root-transition-aware.tsx

@@ -13,7 +13,7 @@ type Props = {
 const EMPTY_STYLE = Object.freeze({} as StyleProps);
 
 export const RootTransitionAware = memo(({ children }: Props) => {
-	const stylesMap = useTransitionStyles();
+	const { stylesMap } = useTransitionStyles();
 
 	const animatedContentStyle = useAnimatedStyle(() => {
 		"worklet";

package/src/hooks/animation/use-associated-style.tsx

@@ -1,19 +1,37 @@
-import { useAnimatedStyle } from "react-native-reanimated";
+import {
+	type StyleProps,
+	useAnimatedStyle,
+	useDerivedValue,
+	useSharedValue,
+} from "react-native-reanimated";
 import { useTransitionStyles } from "../../providers/transition-styles";
 
 type Props = {
 	id?: string;
+	style?: StyleProps;
 };
 
 const EMPTY_STYLE = Object.freeze({});
 
 /**
- * This hook is used to get the associated styles for a given styleId.
- * It is used to get the associated styles for a given styleId.
- * It is used to get the associated styles for a given styleId.
+ * This hook is used to get the associated styles for a given styleId / boundTag.
  */
-export const useAssociatedStyles = ({ id }: Props = {}) => {
-	const stylesMap = useTransitionStyles();
+export const useAssociatedStyles = ({ id, style }: Props = {}) => {
+	const { stylesMap } = useTransitionStyles();
+	const showAfterFirstFrame = useSharedValue(false);
+
+	useDerivedValue(() => {
+		"worklet";
+		if (!id) {
+			showAfterFirstFrame.value = true;
+			return;
+		}
+		if (!showAfterFirstFrame.value) {
+			requestAnimationFrame(() => {
+				showAfterFirstFrame.value = true;
+			});
+		}
+	});
 
 	const associatedStyles = useAnimatedStyle(() => {
 		"worklet";
@@ -21,8 +39,25 @@ export const useAssociatedStyles = ({ id }: Props = {}) => {
 		if (!id || !stylesMap) {
 			return EMPTY_STYLE;
 		}
+		const base =
+			(stylesMap.value[id] as Record<string, unknown>) || EMPTY_STYLE;
+
+		let opacity = 1;
+
+		if ("opacity" in base) {
+			opacity = base.opacity as number;
+		}
+		if (style && "opacity" in style) {
+			opacity = style.opacity as number;
+		}
+
+		// Only force opacity to 0 during the initial frame; once ready,
+		// return base unchanged so we never override user-provided opacity.
+		if (!showAfterFirstFrame.value) {
+			return { ...base, opacity: 0 } as Record<string, unknown>;
+		}
 
-		return stylesMap.value[id] || EMPTY_STYLE;
+		return { ...base, opacity };
 	});
 
 	return { associatedStyles };