@react-navigation/core 8.0.0-alpha.24 → 8.0.0-alpha.25

package/src/checkSerializable.tsx

@@ -1,16 +1,18 @@
-type Result =
-  | { serializable: true }
-  | {
-      serializable: false;
-      location: (string | number)[];
-      reason: string;
-    };
+type Success = { serializable: true };
+
+type Failure = {
+  serializable: false;
+  location: (string | number)[];
+  reason: string;
+};
+
+type Result = Success | Failure;
 
 const checkSerializableWithoutCircularReference = (
   o: { [key: string]: any },
   seen: Set<any>,
   location: (string | number)[]
-): Result => {
+): Failure | undefined => {
   if (
     o === undefined ||
     o === null ||
@@ -18,7 +20,7 @@ const checkSerializableWithoutCircularReference = (
     typeof o === 'number' ||
     typeof o === 'string'
   ) {
-    return { serializable: true };
+    return undefined;
   }
 
   if (
@@ -52,7 +54,7 @@ const checkSerializableWithoutCircularReference = (
       );
       location.pop();
 
-      if (!childResult.serializable) {
+      if (childResult) {
         seen.delete(o);
         return childResult;
       }
@@ -67,7 +69,7 @@ const checkSerializableWithoutCircularReference = (
       );
       location.pop();
 
-      if (!childResult.serializable) {
+      if (childResult) {
         seen.delete(o);
         return childResult;
       }
@@ -76,9 +78,13 @@ const checkSerializableWithoutCircularReference = (
 
   seen.delete(o);
 
-  return { serializable: true };
+  return undefined;
 };
 
-export function checkSerializable(o: { [key: string]: any }) {
-  return checkSerializableWithoutCircularReference(o, new Set<any>(), []);
+export function checkSerializable(o: { [key: string]: any }): Result {
+  return (
+    checkSerializableWithoutCircularReference(o, new Set<any>(), []) ?? {
+      serializable: true,
+    }
+  );
 }

package/src/createNavigationContainerRef.tsx

@@ -30,6 +30,8 @@ export function createNavigationContainerRef<
 
   const listeners: Record<string, ((...args: any[]) => void)[]> = {};
 
+  let current: NavigationContainerRef<ParamList> | null = null;
+
   const removeListener = (
     event: string,
     callback: (...args: any[]) => void
@@ -37,9 +39,12 @@ export function createNavigationContainerRef<
     if (listeners[event]) {
       listeners[event] = listeners[event].filter((cb) => cb !== callback);
     }
-  };
 
-  let current: NavigationContainerRef<ParamList> | null = null;
+    current?.removeListener(
+      event as keyof NavigationContainerEventMap,
+      callback
+    );
+  };
 
   const ref: NavigationContainerRefWithCurrent<ParamList> = {
     get current() {
@@ -68,7 +73,11 @@ export function createNavigationContainerRef<
     },
     ...methods.reduce<any>((acc, name) => {
       acc[name] = (...args: any[]) => {
-        if (current == null) {
+        if (name === 'removeListener') {
+          const [event, callback] = args;
+
+          removeListener(event, callback);
+        } else if (current == null) {
           switch (name) {
             case 'addListener': {
               const [event, callback] = args;
@@ -78,12 +87,6 @@ export function createNavigationContainerRef<
 
               return () => removeListener(event, callback);
             }
-            case 'removeListener': {
-              const [event, callback] = args;
-
-              removeListener(event, callback);
-              break;
-            }
             default:
               console.error(NOT_INITIALIZED_ERROR);
           }

package/src/createNavigatorFactory.tsx

@@ -5,6 +5,7 @@ import { Group } from './Group';
 import { Screen } from './Screen';
 import {
   createComponentForStaticConfig,
+  type NoExcessStaticConfig,
   type StaticConfig,
   type StaticParamList,
 } from './StaticNavigation';
@@ -14,25 +15,24 @@ import type {
   NestedNavigatorsForParamList,
   TypedNavigator,
 } from './types';
-import type { KeysOf } from './utilities';
+import type { KeysOf, NoExcessObject } from './utilities';
 
-type ValidNavigatorNesting<
-  ParamList extends ParamListBase,
-  Nesting,
-> = Nesting extends Partial<Record<keyof ParamList, unknown>> &
-  Record<Exclude<keyof Nesting, keyof ParamList>, never>
-  ? Nesting
-  : never;
+type NavigatorNesting<ParamList extends ParamListBase, Nesting> = {
+  [RouteName in keyof ParamList]?: unknown;
+} & Record<Exclude<KeysOf<Nesting>, keyof ParamList>, never>;
+
+type ValidNavigatorNesting<ParamList extends ParamListBase, Nesting> =
+  Nesting extends NavigatorNesting<ParamList, Nesting> ? Nesting : never;
+
+type AnyStaticConfig<TypeBag extends NavigatorTypeBagBase> = StaticConfig<
+  NavigatorTypeBagFor<TypeBag, ParamListBase>
+>;
 
 export type TypedNavigatorFactory<in out TypeBag extends NavigatorTypeBagBase> =
   {
     <
       const ParamList extends ParamListBase,
-      const Nesting extends Partial<Record<keyof ParamList, unknown>> &
-        // Extra keys satisfy the structural constraint via width subtyping,
-        // Force any key in `Nesting` that isn't in the param list to `never`.
-        // So typos in the nesting config will cause an error.
-        Record<Exclude<keyof Nesting, keyof ParamList>, never> =
+      const Nesting extends NavigatorNesting<ParamList, Nesting> =
         ValidNavigatorNesting<
           ParamList,
           NestedNavigatorsForParamList<ParamList>
@@ -43,22 +43,10 @@ export type TypedNavigatorFactory<in out TypeBag extends NavigatorTypeBagBase> =
       Nesting
     >;
     <
-      const Config extends StaticConfig<
-        NavigatorTypeBagFor<TypeBag, ParamListBase>
-      > &
-        // TS only checks for excess properties for non-generic object literal types.
-        // Since `Config` is generic, extra keys satisfy the constraint and slip through.
-        // So we force any key in `Config` that isn't a known key to have the type `never`,
-        // Thus causing an error for any extra key.
-        Record<
-          Exclude<
-            keyof Config,
-            KeysOf<StaticConfig<NavigatorTypeBagFor<TypeBag, ParamListBase>>>
-          >,
-          never
-        >,
+      const Config extends AnyStaticConfig<TypeBag> &
+        NoExcessObject<Config, AnyStaticConfig<TypeBag>>,
     >(
-      config: Config
+      config: Config & NoExcessStaticConfig<NoInfer<Config>, TypeBag>
     ): TypedNavigator<
       NavigatorTypeBagFor<TypeBag, StaticParamList<{ config: Config }>>,
       Config

package/src/getActionFromState.tsx

@@ -51,25 +51,27 @@ export function getActionFromState(
     normalizedConfig = {};
   }
 
-  const routes =
-    state.index != null ? state.routes.slice(0, state.index + 1) : state.routes;
+  const routesLength =
+    state.index == null || state.index >= state.routes.length
+      ? state.routes.length
+      : state.index + 1;
 
-  if (routes.length === 0) {
+  if (routesLength === 0) {
     return undefined;
   }
 
-  const firstRoute = routes[0];
+  const firstRoute = state.routes[0];
 
   if (firstRoute == null) {
     return undefined;
   }
 
-  const secondRoute = routes[1];
+  const secondRoute = state.routes[1];
 
   if (
     !(
-      (routes.length === 1 && firstRoute.key == null) ||
-      (routes.length === 2 &&
+      (routesLength === 1 && firstRoute.key == null) ||
+      (routesLength === 2 &&
         firstRoute.key == null &&
         firstRoute.name === normalizedConfig?.initialRouteName &&
         secondRoute?.key == null)
@@ -121,24 +123,24 @@ export function getActionFromState(
       return undefined;
     }
 
-    const routes =
-      current.index != null
-        ? current.routes.slice(0, current.index + 1)
-        : current.routes;
+    const routesLength =
+      current.index == null || current.index >= current.routes.length
+        ? current.routes.length
+        : current.index + 1;
 
-    const route = routes[routes.length - 1];
+    const route = current.routes[routesLength - 1];
 
     if (route == null) {
       return undefined;
     }
 
-    const firstRoute = routes[0];
+    const firstRoute = current.routes[0];
 
     if (firstRoute == null) {
       return undefined;
     }
 
-    const secondRoute = routes[1];
+    const secondRoute = current.routes[1];
 
     // Explicitly set to override existing value when merging params
     Object.assign(params, {
@@ -148,11 +150,11 @@ export function getActionFromState(
       state: undefined,
     });
 
-    if (routes.length === 1 && firstRoute.key == null) {
+    if (routesLength === 1 && firstRoute.key == null) {
       params.initial = true;
       params.screen = route.name;
     } else if (
-      routes.length === 2 &&
+      routesLength === 2 &&
       firstRoute.key == null &&
       firstRoute.name === config?.initialRouteName &&
       secondRoute?.key == null

package/src/getPathFromState.tsx

@@ -40,7 +40,12 @@ const encodePathParam = (value: string) => {
 };
 
 const getActiveRoute = (
-  state: State
+  state: State,
+  configs: Record<string, ConfigItem> | undefined,
+  getRouteState: (
+    route: State['routes'][number],
+    config: ConfigItem | undefined
+  ) => State | undefined
 ): { name: string; params?: object | undefined } => {
   const route =
     typeof state.index === 'number'
@@ -51,74 +56,41 @@ const getActiveRoute = (
     throw new Error(`Couldn't find the active route.`);
   }
 
-  if (route.state) {
-    return getActiveRoute(route.state);
+  const config = configs?.[route.name];
+  const routeState = getRouteState(route, config);
+
+  if (routeState) {
+    return getActiveRoute(routeState, config?.screens, getRouteState);
   }
 
   return route;
 };
 
 const cachedNormalizedConfigs = new WeakMap<
-  PathConfigMap<{}>,
+  Options<{}>,
   Record<string, ConfigItem>
 >();
 
 const getNormalizedConfigs = (options?: Options<{}>) => {
-  if (!options?.screens) return {};
+  if (!options) {
+    return {};
+  }
+
+  const cached = cachedNormalizedConfigs.get(options);
 
-  const cached = cachedNormalizedConfigs.get(options?.screens);
+  if (cached) {
+    return cached;
+  }
 
-  if (cached) return cached;
+  validatePathConfig(options);
 
   const normalizedConfigs = createNormalizedConfigs(options.screens);
 
-  cachedNormalizedConfigs.set(options.screens, normalizedConfigs);
+  cachedNormalizedConfigs.set(options, normalizedConfigs);
 
   return normalizedConfigs;
 };
 
-const getTransformedState = (
-  state: State,
-  configs: Record<string, ConfigItem> | undefined
-): Omit<PartialState<NavigationState>, 'stale'> => {
-  const routes = state.routes.map(
-    (route): Omit<PartialState<NavigationState>, 'stale'>['routes'][number] => {
-      const config = configs?.[route.name];
-
-      if (
-        route.state ||
-        (config?.screens &&
-          route.params &&
-          (('screen' in route.params &&
-            typeof route.params.screen === 'string' &&
-            config.screens[route.params.screen]) ||
-            'state' in route.params))
-      ) {
-        const nestedState: State | undefined =
-          route.state ?? getStateFromRouteParams(route.params);
-
-        if (nestedState) {
-          return {
-            ...route,
-            state: getTransformedState(
-              nestedState,
-              configs?.[route.name]?.screens
-            ),
-          };
-        }
-      }
-
-      // @ts-expect-error route.state is handled in previous condition
-      return route;
-    }
-  );
-
-  return {
-    ...state,
-    routes,
-  };
-};
-
 /**
  * Utility to serialize a navigation state object to a path string.
  *
@@ -158,15 +130,45 @@ export function getPathFromState<ParamList extends {}>(
     );
   }
 
-  if (options) {
-    validatePathConfig(options);
-  }
-
   const configs = getNormalizedConfigs(options);
-  const transformedState = getTransformedState(state, configs);
+  const cachedRouteStates = new Map<object, State | undefined>();
+
+  const getRouteState = (
+    route: State['routes'][number],
+    config: ConfigItem | undefined
+  ) => {
+    if (route.state) {
+      return route.state;
+    }
+
+    const hasScreenParams =
+      route.params &&
+      'screen' in route.params &&
+      typeof route.params.screen === 'string' &&
+      config?.screens?.[route.params.screen];
+
+    const hasStateParams =
+      route.params && 'state' in route.params && config?.screens;
+
+    if (
+      !route.params ||
+      !config?.screens ||
+      (!hasScreenParams && !hasStateParams)
+    ) {
+      return undefined;
+    }
+
+    if (!cachedRouteStates.has(route)) {
+      cachedRouteStates.set(route, getStateFromRouteParams(route.params));
+    }
+
+    return cachedRouteStates.get(route);
+  };
+
+  const focusedRoute = getActiveRoute(state, configs, getRouteState);
 
   let path = '/';
-  let current: State | undefined = transformedState;
+  let current: State | undefined = state;
 
   const allParams: Record<string, string> = {};
 
@@ -187,8 +189,6 @@ export function getPathFromState<ParamList extends {}>(
     let focusedParams: Record<string, string> | undefined;
     let currentOptions = configs;
 
-    const focusedRoute = getActiveRoute(transformedState);
-
     // Keep all the route names that appeared during going deeper in config in case the pattern is resolved to undefined
     const nestedRouteNames = [];
 
@@ -262,16 +262,18 @@ export function getPathFromState<ParamList extends {}>(
       }
 
       // If there is no `screens` property or no nested state, we return pattern
-      if (!config.screens || route.state == null) {
+      const routeState = getRouteState(route, config);
+
+      if (!config.screens || routeState == null) {
         hasNext = false;
       } else {
         index =
-          typeof route.state.index === 'number'
-            ? route.state.index
-            : route.state.routes.length - 1;
+          typeof routeState.index === 'number'
+            ? routeState.index
+            : routeState.routes.length - 1;
 
         const nextRoute: State['routes'][number] | undefined =
-          route.state.routes[index];
+          routeState.routes[index];
 
         if (nextRoute == null) {
           throw new Error(`Couldn't find a route at index ${index}.`);
@@ -290,6 +292,8 @@ export function getPathFromState<ParamList extends {}>(
       }
     }
 
+    const routeState = getRouteState(route, currentOptions[route.name]);
+
     if (currentOptions[route.name] != null) {
       if (parts) {
         let index = 0;
@@ -345,7 +349,7 @@ export function getPathFromState<ParamList extends {}>(
       }
     }
 
-    if (route.state) {
+    if (routeState) {
       path += '/';
     } else if (focusedParams) {
       const query = queryString.stringify(focusedParams, { sort: false });
@@ -355,7 +359,7 @@ export function getPathFromState<ParamList extends {}>(
       }
     }
 
-    current = route.state;
+    current = routeState;
   }
 
   // Include the root path if specified

package/src/getPatternParts.tsx

@@ -52,8 +52,8 @@ export function getPatternParts(path: string): PatternPart[] {
         if (regexInnerParens) {
           // The ')' is part of the regex if we're already inside one
           regexInnerParens--;
-          current.regex += char;
         } else {
+          current.regex += char;
           isRegex = false;
           isParam = false;
         }
@@ -62,7 +62,7 @@ export function getPatternParts(path: string): PatternPart[] {
           `Encountered ')' without preceding '(' in path: ${path}`
         );
       }
-    } else if (char === '?') {
+    } else if (char === '?' && !isRegex) {
       if (current.param) {
         isParam = false;