@react-navigation/core 8.0.0-alpha.19 → 8.0.0-alpha.20

package/src/findFocusedRoute.tsx

@@ -12,11 +12,16 @@ type Result =
 export function findFocusedRoute(state: InitialState): Result {
   let current: InitialState | undefined = state;
 
-  while (current?.routes[current.index ?? 0].state != null) {
-    current = current.routes[current.index ?? 0].state;
-  }
+  while (current != null) {
+    const route: InitialState['routes'][number] | undefined =
+      current.routes[current.index ?? 0];
+
+    if (route?.state == null) {
+      return route;
+    }
 
-  const route = current?.routes[current?.index ?? 0];
+    current = route.state;
+  }
 
-  return route;
+  return undefined;
 }

package/src/getActionFromState.tsx

@@ -2,9 +2,7 @@ import type {
   CommonActions,
   NavigationState,
   ParamListBase,
-  PartialRoute,
   PartialState,
-  Route,
 } from '@react-navigation/routers';
 
 import type { NavigatorScreenParams, PathConfig, PathConfigMap } from './types';
@@ -60,13 +58,21 @@ export function getActionFromState(
     return undefined;
   }
 
+  const firstRoute = routes[0];
+
+  if (firstRoute == null) {
+    return undefined;
+  }
+
+  const secondRoute = routes[1];
+
   if (
     !(
-      (routes.length === 1 && routes[0].key === undefined) ||
+      (routes.length === 1 && firstRoute.key == null) ||
       (routes.length === 2 &&
-        routes[0].key === undefined &&
-        routes[0].name === normalizedConfig?.initialRouteName &&
-        routes[1].key === undefined)
+        firstRoute.key == null &&
+        firstRoute.name === normalizedConfig?.initialRouteName &&
+        secondRoute?.key == null)
     )
   ) {
     return {
@@ -77,20 +83,20 @@ export function getActionFromState(
 
   const route = state.routes[state.index ?? state.routes.length - 1];
 
-  let current: PartialState<NavigationState> | undefined = route?.state;
-  let config: ConfigItem | undefined = normalizedConfig?.screens?.[route?.name];
+  if (route == null) {
+    return undefined;
+  }
+
+  let current: PartialState<NavigationState> | undefined = route.state;
+  let config: ConfigItem | undefined = normalizedConfig?.screens?.[route.name];
   let params = { ...route.params } as NavigatorScreenParams<ParamListBase>;
 
-  const payload:
-    | {
-        name: string;
-        params: NavigatorScreenParams<ParamListBase>;
-        path?: string | undefined;
-        pop?: boolean | undefined;
-      }
-    | undefined = route
-    ? { name: route.name, path: route.path, params }
-    : undefined;
+  const payload: {
+    name: string;
+    params: NavigatorScreenParams<ParamListBase>;
+    path?: string | undefined;
+    pop?: boolean | undefined;
+  } = { name: route.name, path: route.path, params };
 
   // If the screen contains a navigator, pop other screens to navigate to it
   // This avoid pushing multiple instances of navigators onto a stack
@@ -106,7 +112,7 @@ export function getActionFromState(
   // There are 2 ways we can detect if a screen contains a navigator:
   // - The route contains nested state in `route.state`
   // - Nested screens are defined in the config
-  if (payload && config?.screens && Object.keys(config.screens).length) {
+  if (config?.screens && Object.keys(config.screens).length) {
     payload.pop = true;
   }
 
@@ -120,8 +126,19 @@ export function getActionFromState(
         ? current.routes.slice(0, current.index + 1)
         : current.routes;
 
-    const route: Route<string> | PartialRoute<Route<string>> =
-      routes[routes.length - 1];
+    const route = routes[routes.length - 1];
+
+    if (route == null) {
+      return undefined;
+    }
+
+    const firstRoute = routes[0];
+
+    if (firstRoute == null) {
+      return undefined;
+    }
+
+    const secondRoute = routes[1];
 
     // Explicitly set to override existing value when merging params
     Object.assign(params, {
@@ -131,14 +148,14 @@ export function getActionFromState(
       state: undefined,
     });
 
-    if (routes.length === 1 && routes[0].key === undefined) {
+    if (routes.length === 1 && firstRoute.key == null) {
       params.initial = true;
       params.screen = route.name;
     } else if (
       routes.length === 2 &&
-      routes[0].key === undefined &&
-      routes[0].name === config?.initialRouteName &&
-      routes[1].key === undefined
+      firstRoute.key == null &&
+      firstRoute.name === config?.initialRouteName &&
+      secondRoute?.key == null
     ) {
       params.initial = false;
       params.screen = route.name;
@@ -164,14 +181,10 @@ export function getActionFromState(
     }
   }
 
-  if (payload?.params.screen || payload?.params.state) {
+  if (payload.params.screen || payload.params.state) {
     payload.pop = true;
   }
 
-  if (!payload) {
-    return;
-  }
-
   // Try to construct payload for a `NAVIGATE` action from the state
   // This lets us preserve the navigation state and not lose it
   return {

package/src/getPathFromState.tsx

@@ -1,8 +1,4 @@
-import type {
-  NavigationState,
-  PartialState,
-  Route,
-} from '@react-navigation/routers';
+import type { NavigationState, PartialState } from '@react-navigation/routers';
 import queryString from 'query-string';
 
 import { getPatternParts, type PatternPart } from './getPatternParts';
@@ -34,6 +30,10 @@ const getActiveRoute = (
       ? state.routes[state.index]
       : state.routes[state.routes.length - 1];
 
+  if (route == null) {
+    throw new Error(`Couldn't find the active route.`);
+  }
+
   if (route.state) {
     return getActiveRoute(route.state);
   }
@@ -66,13 +66,15 @@ const getTransformedState = (
 ): Omit<PartialState<NavigationState>, 'stale'> => {
   const routes = state.routes.map(
     (route): Omit<PartialState<NavigationState>, 'stale'>['routes'][number] => {
+      const config = configs?.[route.name];
+
       if (
         route.state ||
-        (configs?.[route.name]?.screens &&
+        (config?.screens &&
           route.params &&
           (('screen' in route.params &&
             typeof route.params.screen === 'string' &&
-            configs[route.name].screens?.[route.params.screen]) ||
+            config.screens[route.params.screen]) ||
             'state' in route.params))
       ) {
         const nestedState: State | undefined =
@@ -152,10 +154,16 @@ export function getPathFromState<ParamList extends {}>(
   const allParams: Record<string, string> = {};
 
   while (current) {
-    let index = typeof current.index === 'number' ? current.index : 0;
-    let route = current.routes[index] as Route<string> & {
-      state?: State;
-    };
+    let index: number = typeof current.index === 'number' ? current.index : 0;
+
+    const initialRoute: State['routes'][number] | undefined =
+      current.routes[index];
+
+    if (initialRoute == null) {
+      throw new Error(`Couldn't find a route at index ${index}.`);
+    }
+
+    let route: State['routes'][number] = initialRoute;
 
     let parts: PatternPart[] | undefined;
 
@@ -169,13 +177,19 @@ export function getPathFromState<ParamList extends {}>(
 
     let hasNext = true;
 
-    while (route.name in currentOptions && hasNext) {
-      parts = currentOptions[route.name].parts;
+    while (hasNext) {
+      const config = currentOptions[route.name];
+
+      if (config == null) {
+        break;
+      }
+
+      parts = config.parts;
 
       nestedRouteNames.push(route.name);
 
       if (route.params) {
-        const options = currentOptions[route.name];
+        const options = config;
 
         const currentParams = Object.fromEntries(
           Object.entries(route.params)
@@ -225,7 +239,7 @@ export function getPathFromState<ParamList extends {}>(
       }
 
       // If there is no `screens` property or no nested state, we return pattern
-      if (!currentOptions[route.name].screens || route.state === undefined) {
+      if (!config.screens || route.state == null) {
         hasNext = false;
       } else {
         index =
@@ -233,12 +247,18 @@ export function getPathFromState<ParamList extends {}>(
             ? route.state.index
             : route.state.routes.length - 1;
 
-        const nextRoute = route.state.routes[index];
-        const nestedConfig = currentOptions[route.name].screens;
+        const nextRoute: State['routes'][number] | undefined =
+          route.state.routes[index];
+
+        if (nextRoute == null) {
+          throw new Error(`Couldn't find a route at index ${index}.`);
+        }
+
+        const nestedConfig = config.screens;
 
         // if there is config for next route name, we go deeper
-        if (nestedConfig && nextRoute.name in nestedConfig) {
-          route = nextRoute as Route<string> & { state?: State };
+        if (nextRoute.name in nestedConfig) {
+          route = nextRoute;
           currentOptions = nestedConfig;
         } else {
           // If not, there is no sense in going deeper in config
@@ -247,7 +267,7 @@ export function getPathFromState<ParamList extends {}>(
       }
     }
 
-    if (currentOptions[route.name] !== undefined) {
+    if (currentOptions[route.name] != null) {
       path += parts
         ?.map(({ segment, param, optional }) => {
           // We don't know what to show for wildcard patterns

package/src/getPatternParts.tsx

@@ -124,3 +124,11 @@ export function getPatternParts(path: string): PatternPart[] {
 
   return parts;
 }
+
+export function combinePatternParts<T extends PatternPart>(
+  parentParts: T[],
+  parts: T[],
+  exact = false
+): T[] {
+  return exact ? parts : [...parentParts, ...parts];
+}