@react-navigation/stack 8.0.0-alpha.24 → 8.0.0-alpha.26

package/src/views/Stack/CardStack.tsx

@@ -258,6 +258,27 @@ export function getAnimationEnabled(animation: StackAnimationName | undefined) {
   return getDefaultAnimation(animation) !== 'none';
 }
 
+const getAllRoutes = (
+  routes: Route<string>[],
+  state: StackNavigationState<ParamListBase>
+) => {
+  const routeKeys = new Set(routes.map((route) => route.key));
+  const inactiveRoutes = state.routes.slice(state.index + 1);
+
+  // If a route is moved from active routes to inactive routes,
+  // It can still be in the local copy of `routes` until the animation ends
+  // So we need to deduplicate the routes to avoid rendering the same route twice
+  return [
+    ...routes,
+    ...inactiveRoutes.filter((route) => !routeKeys.has(route.key)),
+  ];
+};
+
+const isInactiveRoute = (route: Route<string>, routes: Route<string>[]) =>
+  // `routes` contains active routes and routes animating during transitions.
+  // Any route added by `getAllRoutes` that's missing from this list is inactive.
+  !routes.some((currentRoute) => currentRoute.key === route.key);
+
 export class CardStack extends React.Component<Props, State> {
   static getDerivedStateFromProps(
     props: Props,
@@ -270,10 +291,9 @@ export class CardStack extends React.Component<Props, State> {
       return null;
     }
 
-    const gestures = [
-      ...props.routes,
-      ...props.state.preloadedRoutes,
-    ].reduce<GestureValues>((acc, curr) => {
+    const allRoutes = getAllRoutes(props.routes, props.state);
+
+    const gestures = allRoutes.reduce<GestureValues>((acc, curr) => {
       const descriptor = props.descriptors[curr.key];
       const { animation } = descriptor?.options || {};
 
@@ -282,7 +302,7 @@ export class CardStack extends React.Component<Props, State> {
         new Animated.Value(
           (props.openingRouteKeys.includes(curr.key) &&
             getAnimationEnabled(animation)) ||
-            props.state.preloadedRoutes.includes(curr)
+            isInactiveRoute(curr, props.routes)
             ? getDistanceFromOptions(
                 state.layout,
                 descriptor?.options,
@@ -294,171 +314,164 @@ export class CardStack extends React.Component<Props, State> {
       return acc;
     }, {});
 
-    const modalRouteKeys = getModalRouteKeys(
-      [...props.routes, ...props.state.preloadedRoutes],
-      props.descriptors
-    );
-
-    const scenes = [...props.routes, ...props.state.preloadedRoutes].map(
-      (route, index, self) => {
-        // For preloaded screens, we don't care about the previous and the next screen
-        const isPreloaded = props.state.preloadedRoutes.includes(route);
-        const previousRoute = isPreloaded ? undefined : self[index - 1];
-        const nextRoute = isPreloaded ? undefined : self[index + 1];
-
-        const oldScene = state.scenes[index];
-
-        const currentGesture = gestures[route.key];
-        const previousGesture = previousRoute
-          ? gestures[previousRoute.key]
-          : undefined;
-        const nextGesture = nextRoute ? gestures[nextRoute.key] : undefined;
-
-        const descriptor =
-          props.descriptors[route.key] ||
-          state.descriptors[route.key] ||
-          (oldScene ? oldScene.descriptor : FALLBACK_DESCRIPTOR);
-
-        const nextOptions =
-          nextRoute &&
-          (
-            props.descriptors[nextRoute?.key] ||
-            state.descriptors[nextRoute?.key]
-          )?.options;
-
-        const previousOptions =
-          previousRoute &&
-          (
-            props.descriptors[previousRoute?.key] ||
-            state.descriptors[previousRoute?.key]
-          )?.options;
-
-        // When a screen is not the last, it should use next screen's transition config
-        // Many transitions also animate the previous screen, so using 2 different transitions doesn't look right
-        // For example combining a slide and a modal transition would look wrong otherwise
-        // With this approach, combining different transition styles in the same navigator mostly looks right
-        // This will still be broken when 2 transitions have different idle state (e.g. modal presentation),
-        // but the majority of the transitions look alright
-        const optionsForTransitionConfig =
-          index !== self.length - 1 &&
-          nextOptions &&
-          nextOptions?.presentation !== 'transparentModal'
-            ? nextOptions
-            : descriptor.options;
-
-        // Assume modal if there are already modal screens in the stack
-        // or current screen is a modal when no presentation is specified
-        const isModal = modalRouteKeys.includes(route.key);
-
-        const animation = getDefaultAnimation(
-          optionsForTransitionConfig.animation
-        );
+    const modalRouteKeys = getModalRouteKeys(allRoutes, props.descriptors);
+
+    const scenes = allRoutes.map((route, index, self) => {
+      // For preloaded or retained screens, we don't care about the previous and the next screen
+      const isInactive = isInactiveRoute(route, props.routes);
+      const previousRoute = isInactive ? undefined : self[index - 1];
+      const nextRoute = isInactive ? undefined : self[index + 1];
+
+      const oldScene = state.scenes[index];
+
+      const currentGesture = gestures[route.key];
+      const previousGesture = previousRoute
+        ? gestures[previousRoute.key]
+        : undefined;
+      const nextGesture = nextRoute ? gestures[nextRoute.key] : undefined;
+
+      const descriptor =
+        props.descriptors[route.key] ||
+        state.descriptors[route.key] ||
+        (oldScene ? oldScene.descriptor : FALLBACK_DESCRIPTOR);
+
+      const nextOptions =
+        nextRoute &&
+        (props.descriptors[nextRoute?.key] || state.descriptors[nextRoute?.key])
+          ?.options;
+
+      const previousOptions =
+        previousRoute &&
+        (
+          props.descriptors[previousRoute?.key] ||
+          state.descriptors[previousRoute?.key]
+        )?.options;
+
+      // When a screen is not the last, it should use next screen's transition config
+      // Many transitions also animate the previous screen, so using 2 different transitions doesn't look right
+      // For example combining a slide and a modal transition would look wrong otherwise
+      // With this approach, combining different transition styles in the same navigator mostly looks right
+      // This will still be broken when 2 transitions have different idle state (e.g. modal presentation),
+      // but the majority of the transitions look alright
+      const optionsForTransitionConfig =
+        index !== self.length - 1 &&
+        nextOptions &&
+        nextOptions?.presentation !== 'transparentModal'
+          ? nextOptions
+          : descriptor.options;
+
+      // Assume modal if there are already modal screens in the stack
+      // or current screen is a modal when no presentation is specified
+      const isModal = modalRouteKeys.includes(route.key);
+
+      const animation = getDefaultAnimation(
+        optionsForTransitionConfig.animation
+      );
 
-        const isAnimationEnabled = getAnimationEnabled(animation);
-
-        const transitionPreset =
-          animation !== 'default'
-            ? NAMED_TRANSITIONS_PRESETS[animation]
-            : optionsForTransitionConfig.presentation === 'transparentModal'
-              ? ModalFadeTransition
-              : optionsForTransitionConfig.presentation === 'modal' || isModal
-                ? ModalTransition
-                : DefaultTransition;
-
-        const {
-          gestureEnabled = Platform.OS === 'ios' && isAnimationEnabled,
-          gestureDirection = transitionPreset.gestureDirection,
-          transitionSpec = transitionPreset.transitionSpec,
-          cardStyleInterpolator = isAnimationEnabled
-            ? transitionPreset.cardStyleInterpolator
-            : forNoAnimationCard,
-          headerStyleInterpolator = transitionPreset.headerStyleInterpolator,
-          cardOverlayEnabled = (Platform.OS !== 'ios' &&
-            optionsForTransitionConfig.presentation !== 'transparentModal') ||
-            getIsModalPresentation(cardStyleInterpolator),
-        } = optionsForTransitionConfig;
-
-        const headerMode: StackHeaderMode =
-          descriptor.options.headerMode ??
-          (!(
-            optionsForTransitionConfig.presentation === 'modal' ||
-            optionsForTransitionConfig.presentation === 'transparentModal' ||
-            nextOptions?.presentation === 'modal' ||
-            nextOptions?.presentation === 'transparentModal' ||
-            getIsModalPresentation(cardStyleInterpolator)
-          ) &&
-          Platform.OS === 'ios' &&
-          descriptor.options.header === undefined
-            ? 'float'
-            : 'screen');
-
-        const isRTL = props.direction === 'rtl';
-
-        const scene = {
-          route,
-          descriptor: {
-            ...descriptor,
-            options: {
-              ...descriptor.options,
-              animation,
-              cardOverlayEnabled,
-              cardStyleInterpolator,
-              gestureDirection,
-              gestureEnabled,
-              headerStyleInterpolator,
-              transitionSpec,
-              headerMode,
-            },
+      const isAnimationEnabled = getAnimationEnabled(animation);
+
+      const transitionPreset =
+        animation !== 'default'
+          ? NAMED_TRANSITIONS_PRESETS[animation]
+          : optionsForTransitionConfig.presentation === 'transparentModal'
+            ? ModalFadeTransition
+            : optionsForTransitionConfig.presentation === 'modal' || isModal
+              ? ModalTransition
+              : DefaultTransition;
+
+      const {
+        gestureEnabled = Platform.OS === 'ios' && isAnimationEnabled,
+        gestureDirection = transitionPreset.gestureDirection,
+        transitionSpec = transitionPreset.transitionSpec,
+        cardStyleInterpolator = isAnimationEnabled
+          ? transitionPreset.cardStyleInterpolator
+          : forNoAnimationCard,
+        headerStyleInterpolator = transitionPreset.headerStyleInterpolator,
+        cardOverlayEnabled = (Platform.OS !== 'ios' &&
+          optionsForTransitionConfig.presentation !== 'transparentModal') ||
+          getIsModalPresentation(cardStyleInterpolator),
+      } = optionsForTransitionConfig;
+
+      const headerMode: StackHeaderMode =
+        descriptor.options.headerMode ??
+        (!(
+          optionsForTransitionConfig.presentation === 'modal' ||
+          optionsForTransitionConfig.presentation === 'transparentModal' ||
+          nextOptions?.presentation === 'modal' ||
+          nextOptions?.presentation === 'transparentModal' ||
+          getIsModalPresentation(cardStyleInterpolator)
+        ) &&
+        Platform.OS === 'ios' &&
+        descriptor.options.header === undefined
+          ? 'float'
+          : 'screen');
+
+      const isRTL = props.direction === 'rtl';
+
+      const scene = {
+        route,
+        descriptor: {
+          ...descriptor,
+          options: {
+            ...descriptor.options,
+            animation,
+            cardOverlayEnabled,
+            cardStyleInterpolator,
+            gestureDirection,
+            gestureEnabled,
+            headerStyleInterpolator,
+            transitionSpec,
+            headerMode,
           },
-          progress: {
-            current: getProgressFromGesture(
-              currentGesture,
-              state.layout,
-              descriptor.options,
-              isRTL
-            ),
-            next:
-              nextGesture && nextOptions?.presentation !== 'transparentModal'
-                ? getProgressFromGesture(
-                    nextGesture,
-                    state.layout,
-                    nextOptions,
-                    isRTL
-                  )
-                : undefined,
-            previous: previousGesture
+        },
+        progress: {
+          current: getProgressFromGesture(
+            currentGesture,
+            state.layout,
+            descriptor.options,
+            isRTL
+          ),
+          next:
+            nextGesture && nextOptions?.presentation !== 'transparentModal'
               ? getProgressFromGesture(
-                  previousGesture,
+                  nextGesture,
                   state.layout,
-                  previousOptions,
+                  nextOptions,
                   isRTL
                 )
               : undefined,
-          },
-          __memo: [
-            state.layout,
-            descriptor,
-            nextOptions,
-            previousOptions,
-            currentGesture,
-            nextGesture,
-            previousGesture,
-          ],
-        };
-
-        if (
-          oldScene &&
-          scene.__memo.every((it, i) => {
-            // @ts-expect-error: we haven't added __memo to the annotation to prevent usage elsewhere
-            return oldScene.__memo[i] === it;
-          })
-        ) {
-          return oldScene;
-        }
-
-        return scene;
+          previous: previousGesture
+            ? getProgressFromGesture(
+                previousGesture,
+                state.layout,
+                previousOptions,
+                isRTL
+              )
+            : undefined,
+        },
+        __memo: [
+          state.layout,
+          descriptor,
+          nextOptions,
+          previousOptions,
+          currentGesture,
+          nextGesture,
+          previousGesture,
+        ],
+      };
+
+      if (
+        oldScene &&
+        scene.__memo.every((it, i) => {
+          // @ts-expect-error: we haven't added __memo to the annotation to prevent usage elsewhere
+          return oldScene.__memo[i] === it;
+        })
+      ) {
+        return oldScene;
       }
-    );
+
+      return scene;
+    });
 
     return {
       routes: props.routes,
@@ -586,6 +599,8 @@ export class CardStack extends React.Component<Props, State> {
 
     const { scenes, layout, gestures, headerHeights } = this.state;
 
+    const allRoutes = getAllRoutes(routes, state);
+
     const focusedRoute = state.routes[state.index];
 
     const isFloatHeaderAbsolute = scenes.slice(-2).some((scene) => {
@@ -627,26 +642,15 @@ export class CardStack extends React.Component<Props, State> {
           ],
         })}
         <View style={styles.container} onLayout={this.handleLayout}>
-          {[...routes, ...state.preloadedRoutes].map((route, index, self) => {
+          {allRoutes.map((route, index, self) => {
             const focused = focusedRoute.key === route.key;
             const gesture = gestures[route.key];
             const scene = scenes[index];
-            // It is possible that for a short period the route appears in both arrays.
-            // Particularly, if the screen is removed with `retain`, then it needs a moment to execute the animation.
-            // However, due to the router action, it immediately populates the `preloadedRoutes` array.
-            // Practically, the logic below takes care that it is rendered only once.
-            const isPreloaded =
-              state.preloadedRoutes.includes(route) && !routes.includes(route);
-            if (
-              state.preloadedRoutes.includes(route) &&
-              routes.includes(route) &&
-              index >= routes.length
-            ) {
-              return null;
-            }
+            const isInactive = isInactiveRoute(route, this.props.routes);
 
             const {
               inactiveBehavior = 'pause',
+              animation,
               headerShown = true,
               headerTransparent,
             } = scene.descriptor.options;
@@ -667,6 +671,16 @@ export class CardStack extends React.Component<Props, State> {
               isParentModal
             );
 
+            const isAnimationEnabled =
+              getAnimationEnabled(animation) ||
+              // Also check next screen's animation,
+              // As it will result in both screens being visible
+              (scenes[index + 1]
+                ? getAnimationEnabled(
+                    scenes[index + 1].descriptor.options.animation
+                  )
+                : false);
+
             const isNextScreenTransparent =
               scenes[index + 1]?.descriptor.options.presentation ===
               'transparentModal';
@@ -683,22 +697,23 @@ export class CardStack extends React.Component<Props, State> {
 
             const isBeforeLast = index === routes.length - 2;
 
-            // Keep animating and the last two rendered routes visible for smoother transitions.
-            // Preloaded routes should stay mounted, but remain hidden until focused.
+            // Keep animating and the last two rendered routes visible for smoother transitions
             const isVisible =
               focused ||
-              isFocusing ||
-              isRemoving ||
               isNextScreenTransparent ||
-              (!isPreloaded && index >= routes.length - 2);
+              // We only need to keep other screens visible when animation is enabled
+              (isAnimationEnabled &&
+                (isFocusing ||
+                  isRemoving ||
+                  // Preloaded and retained screens should stay mounted, but remain hidden until focused
+                  (!isInactive && index >= routes.length - 2)));
 
             const activityMode = // Render focused and animating screens normally
               focused || isFocusing
                 ? 'normal'
                 : inactiveBehavior === 'none' ||
-                    // Unpause preloaded screens so updates are visible
-                    // This lets preloaded screens initialize
-                    isPreloaded ||
+                    // Unpause preloaded or retained screens so updates are visible
+                    isInactive ||
                     // Keep the screen before transparent screen active
                     // This lets the screen under the transparent screen update and animate
                     isNextScreenTransparent ||
@@ -753,7 +768,7 @@ export class CardStack extends React.Component<Props, State> {
                 onTransitionStart={onTransitionStart}
                 onTransitionEnd={onTransitionEnd}
                 isNextScreenTransparent={isNextScreenTransparent}
-                preloaded={isPreloaded}
+                preloaded={isInactive}
               >
                 <ActivityView
                   mode={activityMode}

package/src/views/Stack/StackView.tsx

@@ -62,10 +62,13 @@ export class StackView extends React.Component<Props, State> {
     props: Readonly<Props>,
     state: Readonly<State>
   ) {
-    const allRoutes = [...props.state.routes, ...props.state.preloadedRoutes];
-    const previousRoutes = state.previousState
-      ? [...state.previousState.routes, ...state.previousState.preloadedRoutes]
-      : [];
+    const allRoutes = props.state.routes;
+    const previousRoutes = state.previousState?.routes ?? [];
+    const previousFocusedRoute = state.previousState
+      ? state.previousState.routes[state.previousState.index]
+      : undefined;
+    const nextFocusedRouteFromState = props.state.routes[props.state.index];
+    const activeRoutes = props.state.routes.slice(0, props.state.index + 1);
 
     // If there was no change in routes, we don't need to compute anything
     if (
@@ -73,6 +76,7 @@ export class StackView extends React.Component<Props, State> {
         allRoutes.map((r) => r.key),
         previousRoutes.map((r) => r.key)
       ) &&
+      previousFocusedRoute?.key === nextFocusedRouteFromState?.key &&
       state.routes.length
     ) {
       // If there were any routes being closed or replaced,
@@ -83,16 +87,16 @@ export class StackView extends React.Component<Props, State> {
       const closingRoutes = state.routes.filter(
         (r) =>
           state.closingRouteKeys.includes(r.key) &&
-          !props.state.routes.some((pr) => pr.key === r.key)
+          !activeRoutes.some((pr) => pr.key === r.key)
       );
 
       const replacingRoutes = state.routes.filter(
         (r) =>
           state.replacingRouteKeys.includes(r.key) &&
-          !props.state.routes.some((pr) => pr.key === r.key)
+          !activeRoutes.some((pr) => pr.key === r.key)
       );
 
-      let routes: Route<string>[] = props.state.routes.slice();
+      let routes: Route<string>[] = activeRoutes.slice();
 
       // Replacing routes go before the focused route (they're being covered)
       if (replacingRoutes.length) {
@@ -117,9 +121,10 @@ export class StackView extends React.Component<Props, State> {
         routes = routes.map((route) => map[route.key] || route);
       }
 
+      const routeKeys = new Set(routes.map((route) => route.key));
       const descriptors = [
         ...routes,
-        ...props.state.preloadedRoutes,
+        ...props.state.routes.filter((route) => !routeKeys.has(route.key)),
       ].reduce<StackDescriptorMap>((acc, route) => {
         acc[route.key] =
           props.descriptors[route.key] || state.descriptors[route.key];
@@ -137,32 +142,20 @@ export class StackView extends React.Component<Props, State> {
     // Here we determine which routes were added or removed to animate them
     // We keep a copy of the route being removed in local state to be able to animate it
 
-    let routes =
-      props.state.index < props.state.routes.length - 1
-        ? // Remove any extra routes from the state
-          // The last visible route should be the focused route, i.e. at current index
-          props.state.routes.slice(0, props.state.index + 1)
-        : props.state.routes;
-
     let { openingRouteKeys, closingRouteKeys, replacingRouteKeys } = state;
 
     // If a route that was closing or being replaced is now back in the routes,
     // it was added back before the animation finished, so stop tracking it
     closingRouteKeys = closingRouteKeys.filter(
-      (key) => !routes.some((r) => r.key === key)
+      (key) => !activeRoutes.some((r) => r.key === key)
     );
 
     replacingRouteKeys = replacingRouteKeys.filter(
-      (key) => !routes.some((r) => r.key === key)
+      (key) => !activeRoutes.some((r) => r.key === key)
     );
 
-    // Get previous focused route from previousState (actual focused route, not last in previousRoutes
-    // which can be a preloaded route that was never focused)
-    const previousFocusedRoute = state.previousState
-      ? state.previousState.routes[state.previousState.index]
-      : undefined;
-
-    const nextFocusedRoute = routes[routes.length - 1];
+    // Get previous focused route from previous active routes
+    const nextFocusedRoute = activeRoutes[activeRoutes.length - 1];
 
     const isAnimationEnabled = (key: string) => {
       const descriptor = props.descriptors[key] || state.descriptors[key];
@@ -176,6 +169,8 @@ export class StackView extends React.Component<Props, State> {
       return descriptor.options.animationTypeForReplace ?? 'push';
     };
 
+    let routes = activeRoutes;
+
     if (
       previousFocusedRoute &&
       previousFocusedRoute.key !== nextFocusedRoute.key
@@ -301,9 +296,10 @@ export class StackView extends React.Component<Props, State> {
       );
     }
 
+    const routeKeys = new Set(routes.map((route) => route.key));
     const descriptors = [
       ...routes,
-      ...props.state.preloadedRoutes,
+      ...props.state.routes.filter((route) => !routeKeys.has(route.key)),
     ].reduce<StackDescriptorMap>((acc, route) => {
       acc[route.key] =
         props.descriptors[route.key] || state.descriptors[route.key];
@@ -352,25 +348,33 @@ export class StackView extends React.Component<Props, State> {
     const { state, navigation } = this.props;
     const { closingRouteKeys, replacingRouteKeys } = this.state;
 
+    const activeRoutes = state.routes.slice(0, state.index + 1);
+
     if (
       closingRouteKeys.some((key) => key === route.key) &&
       replacingRouteKeys.every((key) => key !== route.key) &&
       state.routeNames.includes(route.name) &&
-      !state.routes.some((r) => r.key === route.key)
+      !activeRoutes.some((r) => r.key === route.key)
     ) {
-      // If route isn't present in current state, but was closing, assume that a close animation was cancelled
+      // If route is no longer active, but was closing, assume that a close animation was cancelled
       // So we need to add this route back to the state
       navigation.dispatch((state) => {
-        const routes = [
-          ...state.routes.filter((r) => r.key !== route.key),
-          route,
-        ];
+        const activeRoutes = state.routes
+          .slice(0, state.index + 1)
+          .filter((r) => r.key !== route.key);
+        const inactiveRoutes = state.routes
+          .slice(state.index + 1)
+          .filter((r) => r.key !== route.key);
+
+        const routes = [...activeRoutes, route];
 
-        return CommonActions.reset({
+        const resetState = {
           ...state,
-          routes,
           index: routes.length - 1,
-        });
+          routes: routes.concat(inactiveRoutes),
+        };
+
+        return CommonActions.reset(resetState);
       });
     } else {
       this.setState((state) => {
@@ -408,7 +412,9 @@ export class StackView extends React.Component<Props, State> {
   private handleCloseRoute = ({ route }: { route: Route<string> }) => {
     const { state, navigation } = this.props;
 
-    if (state.routes.some((r) => r.key === route.key)) {
+    const activeRoutes = state.routes.slice(0, state.index + 1);
+
+    if (activeRoutes.some((r) => r.key === route.key)) {
       // If a route exists in state, trigger a pop
       // This will happen in when the route was closed from the card component
       // e.g. When the close animation triggered from a gesture ends