react-native-screen-transitions 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -197,82 +197,11 @@ var ElasticCard = (config = { elasticFactor: 0.5 }) => {
 
 // src/hooks/use-screen-animation.tsx
 import { useNavigation } from "@react-navigation/native";
-import { useMemo } from "react";
+import { useCallback, useMemo } from "react";
 import { useWindowDimensions } from "react-native";
 import { useSharedValue } from "react-native-reanimated";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 
-// src/store/utils/use-shallow.tsx
-import React from "react";
-
-// src/store/utils/shallow.ts
-var isIterable = (obj) => Symbol.iterator in obj;
-var hasIterableEntries = (value) => (
-  // HACK: avoid checking entries type
-  "entries" in value
-);
-var compareEntries = (valueA, valueB) => {
-  const mapA = valueA instanceof Map ? valueA : new Map(valueA.entries());
-  const mapB = valueB instanceof Map ? valueB : new Map(valueB.entries());
-  if (mapA.size !== mapB.size) {
-    return false;
-  }
-  for (const [key, value] of mapA) {
-    if (!Object.is(value, mapB.get(key))) {
-      return false;
-    }
-  }
-  return true;
-};
-var compareIterables = (valueA, valueB) => {
-  const iteratorA = valueA[Symbol.iterator]();
-  const iteratorB = valueB[Symbol.iterator]();
-  let nextA = iteratorA.next();
-  let nextB = iteratorB.next();
-  while (!nextA.done && !nextB.done) {
-    if (!Object.is(nextA.value, nextB.value)) {
-      return false;
-    }
-    nextA = iteratorA.next();
-    nextB = iteratorB.next();
-  }
-  return !!nextA.done && !!nextB.done;
-};
-function shallow(valueA, valueB) {
-  if (Object.is(valueA, valueB)) {
-    return true;
-  }
-  if (typeof valueA !== "object" || valueA === null || typeof valueB !== "object" || valueB === null) {
-    return false;
-  }
-  if (Object.getPrototypeOf(valueA) !== Object.getPrototypeOf(valueB)) {
-    return false;
-  }
-  if (isIterable(valueA) && isIterable(valueB)) {
-    if (hasIterableEntries(valueA) && hasIterableEntries(valueB)) {
-      return compareEntries(valueA, valueB);
-    }
-    return compareIterables(valueA, valueB);
-  }
-  return compareEntries(
-    { entries: () => Object.entries(valueA) },
-    { entries: () => Object.entries(valueB) }
-  );
-}
-
-// src/store/utils/use-shallow.tsx
-function useShallow(selector) {
-  const prev = React.useRef(void 0);
-  return (state) => {
-    const next = selector(state);
-    if (shallow(prev.current, next)) {
-      return prev.current;
-    }
-    prev.current = next;
-    return next;
-  };
-}
-
 // src/animation-engine.ts
 import {
   cancelAnimation,
@@ -323,49 +252,93 @@ function createVanillaStore(initialState) {
   return useStore;
 }
 
-// src/store/index.ts
-var useRouteStore = createVanillaStore({
-  routes: {},
-  routeKeys: []
-});
-var RouteStore = {
-  use: useRouteStore,
-  updateRoute: (key, value) => {
-    if (!key) return;
-    useRouteStore.setState(({ routeKeys, routes }) => {
-      const currentRoute = routes[key];
-      if (currentRoute) {
-        routes[key] = {
-          ...currentRoute,
-          ...value
-        };
-      } else {
-        const { name = "", status = 0, closing = false, ...rest } = value;
-        const newIndex = routeKeys.length;
-        routes[key] = {
-          id: key,
-          index: newIndex,
-          name,
-          status,
-          closing,
-          ...rest
-        };
-        routeKeys.push(key);
-      }
-    });
-  },
-  removeRoute: (key) => {
-    if (!key) return;
-    useRouteStore.setState(({ routes, routeKeys }) => {
-      delete routes[key];
-      const indexToRemove = routeKeys.indexOf(key);
-      if (indexToRemove > -1) {
-        routeKeys.splice(indexToRemove, 1);
-      }
+// src/store/utils/handle-screen-dismiss.tsx
+import { StackActions } from "@react-navigation/native";
+var handleScreenDismiss = (screenBeingDismissed, navigation) => {
+  const { screens } = ScreenStore.use.getState();
+  const dismissedScreen = screens[screenBeingDismissed];
+  if (!dismissedScreen) {
+    navigation.goBack();
+    return;
+  }
+  const childScreens = Object.values(screens).filter(
+    (screen) => screen.parentNavigatorKey === dismissedScreen.navigatorKey
+  );
+  if (childScreens.length > 0) {
+    ScreenStore.updateScreen(dismissedScreen.id, {
+      closing: true
     });
+    navigation.dispatch(StackActions.pop(childScreens.length));
+  } else {
+    navigation.goBack();
   }
 };
 
+// src/store/utils/remove-screen.tsx
+var removeScreen = (key) => {
+  if (!key) return;
+  ScreenStore.use.setState(({ screens, screenKeys }) => {
+    delete screens[key];
+    const indexToRemove = screenKeys.indexOf(key);
+    if (indexToRemove > -1) {
+      screenKeys.splice(indexToRemove, 1);
+    }
+  });
+};
+
+// src/store/utils/should-skip-prevent-default.tsx
+var shouldSkipPreventDefault = (key, navigatorState) => {
+  if (!key) return false;
+  const { screens } = ScreenStore.use.getState();
+  const currentScreen = screens[key];
+  const isLastScreenInStack = navigatorState.routes.length === 1 && navigatorState.routes[0].key === key;
+  const isParentNavigatorExiting = Boolean(
+    currentScreen?.parentNavigatorKey && Object.values(screens).some(
+      (screen) => screen.navigatorKey === currentScreen.parentNavigatorKey && screen.closing
+    )
+  );
+  return isLastScreenInStack || isParentNavigatorExiting;
+};
+
+// src/store/utils/update-screen.tsx
+var updateScreen = (key, value) => {
+  if (!key) return;
+  ScreenStore.use.setState(({ screenKeys, screens }) => {
+    const currentScreen = screens[key];
+    if (currentScreen) {
+      screens[key] = {
+        ...currentScreen,
+        ...value
+      };
+    } else {
+      const { name = "", status = 0, closing = false, ...rest } = value;
+      const newIndex = screenKeys.length;
+      screens[key] = {
+        id: key,
+        index: newIndex,
+        name,
+        status,
+        closing,
+        ...rest
+      };
+      screenKeys.push(key);
+    }
+  });
+};
+
+// src/store/index.ts
+var useScreenStore = createVanillaStore({
+  screens: {},
+  screenKeys: []
+});
+var ScreenStore = {
+  use: useScreenStore,
+  updateScreen,
+  removeScreen,
+  handleScreenDismiss,
+  shouldSkipPreventDefault
+};
+
 // src/utils/animate.ts
 import {
   withSpring,
@@ -389,12 +362,12 @@ var animationValues = {
   normalizedGestureY: {},
   gestureDragging: {}
 };
-var triggerAnimation = (route) => {
+var triggerAnimation = (screen) => {
   "worklet";
-  const { id, closing, status, transitionSpec, onAnimationFinish } = route;
+  const { id, closing, status, transitionSpec, onAnimationFinish } = screen;
   const progressValue = animationValues.screenProgress[id];
   if (!progressValue && __DEV__) {
-    console.warn(`Animation values not found for route: ${id}`);
+    console.warn(`Animation values not found for screen: ${id}`);
     return;
   }
   const animationConfig = closing ? transitionSpec?.close : transitionSpec?.open;
@@ -406,14 +379,16 @@ var triggerAnimation = (route) => {
     }
   });
 };
-RouteStore.use.subscribeWithSelector(
-  (state) => state.routes,
-  (currRoutes, prevRoutes) => {
-    const currKeys = Object.keys(currRoutes);
-    const prevKeys = Object.keys(prevRoutes);
+ScreenStore.use.subscribeWithSelector(
+  (state) => state.screens,
+  (currScreens, prevScreens) => {
+    const currKeys = Object.keys(currScreens);
+    const prevKeys = Object.keys(prevScreens);
     const incomingKeys = currKeys.filter((k) => !prevKeys.includes(k));
     const removedKeys = prevKeys.filter((k) => !currKeys.includes(k));
-    const changedKeys = currKeys.filter((k) => currRoutes[k] !== prevRoutes[k]);
+    const changedKeys = currKeys.filter(
+      (k) => currScreens[k] !== prevScreens[k]
+    );
     const animatableValues = Object.values(animationValues);
     for (const incomingKey of incomingKeys) {
       for (const value of animatableValues) {
@@ -427,9 +402,9 @@ RouteStore.use.subscribeWithSelector(
       }
     }
     for (const changedKey of changedKeys) {
-      const currentRoute = currRoutes[changedKey];
-      if (currentRoute) {
-        triggerAnimation(currentRoute);
+      const currentScreen = currScreens[changedKey];
+      if (currentScreen) {
+        triggerAnimation(currentScreen);
       }
     }
   }
@@ -442,10 +417,11 @@ import {
   runOnJS as runOnJS2
 } from "react-native-reanimated";
 
-// src/utils/gesture/create-gesture-activation-criteria.ts
-var createGestureActivationCriteria = ({
+// src/utils/gesture/apply-gesture-activation-criteria.ts
+var applyGestureActivationCriteria = ({
   gestureDirection,
-  gestureResponseDistance
+  gestureResponseDistance,
+  panGesture
 }) => {
   const directions = Array.isArray(gestureDirection) ? gestureDirection : [gestureDirection];
   if (directions.includes("bidirectional")) {
@@ -502,7 +478,20 @@ var createGestureActivationCriteria = ({
   } else {
     result.failOffsetY = [-toleranceY, toleranceY];
   }
-  return result;
+  if (result?.activeOffsetX) {
+    panGesture.activeOffsetX(result.activeOffsetX);
+  }
+  if (result?.activeOffsetY) {
+    panGesture.activeOffsetY(result.activeOffsetY);
+  }
+  if (result?.failOffsetX) {
+    panGesture.failOffsetX(result.failOffsetX);
+  }
+  if (result?.failOffsetY) {
+    panGesture.failOffsetY(result.failOffsetY);
+  }
+  panGesture.enableTrackpadTwoFingerGesture(true);
+  return panGesture;
 };
 
 // src/utils/gesture/map-gesture-to-progress.ts
@@ -518,10 +507,10 @@ var DEFAULT_GESTURE_RESPONSE_DISTANCE = 50;
 var buildGestureDetector = ({
   key,
   progress,
-  config,
+  screenState,
   width,
   height,
-  goBack
+  handleDismiss
 }) => {
   const _translateX = animationValues.gestureX[key];
   const _translateY = animationValues.gestureY[key];
@@ -534,7 +523,7 @@ var buildGestureDetector = ({
     transitionSpec,
     gestureVelocityImpact = GESTURE_VELOCITY_IMPACT,
     gestureResponseDistance = DEFAULT_GESTURE_RESPONSE_DISTANCE
-  } = config;
+  } = screenState;
   const directions = Array.isArray(gestureDirection) ? gestureDirection : [gestureDirection];
   const panGesture = Gesture.Pan().enabled(gestureEnabled).onStart(() => {
     "worklet";
@@ -613,7 +602,7 @@ var buildGestureDetector = ({
     const spec = shouldDismiss ? transitionSpec?.close : transitionSpec?.open;
     const onFinish = shouldDismiss ? (isFinished) => {
       "worklet";
-      if (isFinished) runOnJS2(goBack)();
+      if (isFinished) runOnJS2(handleDismiss)(screenState.id);
     } : void 0;
     progress.value = animate(finalProgress, spec, onFinish);
     _translateX.value = animate(0, spec);
@@ -621,25 +610,12 @@ var buildGestureDetector = ({
     _normalizedGestureX.value = animate(0, spec);
     _normalizedGestureY.value = animate(0, spec);
   });
-  const criteria = createGestureActivationCriteria({
+  applyGestureActivationCriteria({
     gestureDirection,
-    gestureResponseDistance
+    gestureResponseDistance,
+    panGesture
   });
-  if (criteria?.activeOffsetX) {
-    panGesture.activeOffsetX(criteria.activeOffsetX);
-  }
-  if (criteria?.activeOffsetY) {
-    panGesture.activeOffsetY(criteria.activeOffsetY);
-  }
-  if (criteria?.failOffsetX) {
-    panGesture.failOffsetX(criteria.failOffsetX);
-  }
-  if (criteria?.failOffsetY) {
-    panGesture.failOffsetY(criteria.failOffsetY);
-  }
-  panGesture.enableTrackpadTwoFingerGesture(true);
-  const nativeGesture = Gesture.Native().shouldCancelWhenOutside(false);
-  return Gesture.Race(panGesture, nativeGesture);
+  return panGesture;
 };
 
 // src/utils/noop-interpolator.ts
@@ -661,25 +637,33 @@ var useAnimationBuilder = () => {
   const dimensions = useWindowDimensions();
   const insets = useSafeAreaInsets();
   const navigation = useNavigation();
-  const { currentRoute, nextRoute } = RouteStore.use(
-    useShallow(({ routes, routeKeys }) => {
-      const current = routes[key];
-      if (!current) {
-        return { currentRoute: void 0, nextRoute: void 0 };
-      }
-      const currentScreenIndex = current.index;
-      const nextKey = routeKeys[currentScreenIndex + 1];
-      return {
-        currentRoute: current,
-        nextRoute: nextKey ? routes[nextKey] : void 0
-      };
-    })
+  const progressFallback = useSharedValue(0);
+  const gestureDraggingFallback = useSharedValue(0);
+  const gestureXFallback = useSharedValue(0);
+  const gestureYFallback = useSharedValue(0);
+  const normalizedGestureXFallback = useSharedValue(0);
+  const normalizedGestureYFallback = useSharedValue(0);
+  const currentScreen = ScreenStore.use(
+    useCallback((state) => state.screens[key], [key])
+  );
+  const actualNextScreen = ScreenStore.use(
+    useCallback(
+      (state) => {
+        const current = state.screens[key];
+        if (!current) return void 0;
+        const nextKey = state.screenKeys[current.index + 1];
+        const nextScreen = nextKey ? state.screens[nextKey] : void 0;
+        const shouldUseNext = nextScreen?.navigatorKey === current?.navigatorKey;
+        return shouldUseNext ? nextScreen : void 0;
+      },
+      [key]
+    )
   );
   const panGesture = useMemo(
     () => buildGestureDetector({
       key,
       progress: animationValues.screenProgress[key],
-      config: currentRoute || {
+      screenState: currentScreen || {
         id: key,
         name: key,
         index: 0,
@@ -688,57 +672,50 @@ var useAnimationBuilder = () => {
       },
       width: dimensions.width,
       height: dimensions.height,
-      goBack: navigation.goBack
+      handleDismiss: (screenBeingDismissed) => {
+        ScreenStore.handleScreenDismiss(screenBeingDismissed, navigation);
+      }
     }),
-    [key, currentRoute, dimensions.width, dimensions.height, navigation.goBack]
+    [key, currentScreen, dimensions, navigation]
+  );
+  const getAnimationValuesForScreen = useCallback(
+    (screenId) => ({
+      progress: animationValues.screenProgress[screenId] || progressFallback,
+      gesture: {
+        isDragging: animationValues.gestureDragging[screenId] || gestureDraggingFallback,
+        x: animationValues.gestureX[screenId] || gestureXFallback,
+        y: animationValues.gestureY[screenId] || gestureYFallback,
+        normalizedX: animationValues.normalizedGestureX[screenId] || normalizedGestureXFallback,
+        normalizedY: animationValues.normalizedGestureY[screenId] || normalizedGestureYFallback
+      }
+    }),
+    [
+      progressFallback,
+      gestureDraggingFallback,
+      gestureXFallback,
+      gestureYFallback,
+      normalizedGestureXFallback,
+      normalizedGestureYFallback
+    ]
   );
-  const progressFallback = useSharedValue(0);
-  const gestureDraggingFallback = useSharedValue(0);
-  const gestureXFallback = useSharedValue(0);
-  const gestureYFallback = useSharedValue(0);
-  const normalizedGestureXFallback = useSharedValue(0);
-  const normalizedGestureYFallback = useSharedValue(0);
   return useMemo(() => {
     return {
-      current: {
-        progress: animationValues.screenProgress[key] || progressFallback,
-        gesture: {
-          isDragging: animationValues.gestureDragging[key] || gestureDraggingFallback,
-          x: animationValues.gestureX[key] || gestureXFallback,
-          y: animationValues.gestureY[key] || gestureYFallback,
-          normalizedX: animationValues.normalizedGestureX[key] || normalizedGestureXFallback,
-          normalizedY: animationValues.normalizedGestureY[key] || normalizedGestureYFallback
-        }
-      },
-      next: nextRoute && animationValues.screenProgress[nextRoute.id] ? {
-        progress: animationValues.screenProgress[nextRoute.id],
-        gesture: {
-          isDragging: animationValues.gestureDragging[nextRoute.id] || gestureDraggingFallback,
-          x: animationValues.gestureX[nextRoute.id] || gestureXFallback,
-          y: animationValues.gestureY[nextRoute.id] || gestureYFallback,
-          normalizedX: animationValues.normalizedGestureX[nextRoute.id] || normalizedGestureXFallback,
-          normalizedY: animationValues.normalizedGestureY[nextRoute.id] || normalizedGestureYFallback
-        }
-      } : void 0,
+      current: getAnimationValuesForScreen(key),
+      next: actualNextScreen ? getAnimationValuesForScreen(actualNextScreen.id) : void 0,
       layouts: { screen: dimensions },
       insets,
-      closing: currentRoute?.closing || false,
-      screenStyleInterpolator: nextRoute?.screenStyleInterpolator || currentRoute?.screenStyleInterpolator || noopinterpolator,
+      closing: currentScreen?.closing || false,
+      screenStyleInterpolator: actualNextScreen?.screenStyleInterpolator || currentScreen?.screenStyleInterpolator || noopinterpolator,
       gestureDetector: panGesture
     };
   }, [
     key,
-    currentRoute,
-    nextRoute,
+    currentScreen,
+    actualNextScreen,
     dimensions,
     insets,
     panGesture,
-    progressFallback,
-    gestureDraggingFallback,
-    gestureXFallback,
-    gestureYFallback,
-    normalizedGestureXFallback,
-    normalizedGestureYFallback
+    getAnimationValuesForScreen
   ]);
 };
 var _useScreenAnimation = () => {
@@ -761,24 +738,36 @@ var createConfig = ({
 }) => {
   return {
     focus: (e) => {
-      RouteStore.updateRoute(e.target, {
+      const parentNavigatorKey = reactNavigation.getParent()?.getState?.()?.key;
+      const navigatorKey = reactNavigation.getState().key;
+      ScreenStore.updateScreen(e.target, {
         id: e.target,
         name: route.name,
         status: 1,
         closing: false,
+        navigatorKey,
+        parentNavigatorKey,
         ...config
       });
     },
     beforeRemove: (e) => {
+      const shouldSkipPreventDefault2 = ScreenStore.shouldSkipPreventDefault(
+        e.target,
+        reactNavigation.getState()
+      );
+      if (shouldSkipPreventDefault2) {
+        ScreenStore.removeScreen(e.target);
+        return;
+      }
       e.preventDefault();
       const handleFinish = (finished) => {
         if (!finished) return;
         if (reactNavigation.canGoBack()) {
           reactNavigation.dispatch(e.data?.action);
-          RouteStore.removeRoute(e.target);
+          ScreenStore.removeScreen(e.target);
         }
       };
-      RouteStore.updateRoute(e.target, {
+      ScreenStore.updateScreen(e.target, {
         status: 0,
         closing: true,
         onAnimationFinish: handleFinish