@react-navigation/core 8.0.0-alpha.26 → 8.0.0-alpha.27

package/src/getStateFromPath.tsx

@@ -39,7 +39,12 @@ type RouteConfig = {
   regex?: RegExp | undefined;
   pattern: string;
   segments: string[];
-  params: { screen: string; name: string; index: number }[];
+  params: {
+    screen: string;
+    name: string;
+    index: number;
+    regex?: RegExp | undefined;
+  }[];
   routeNames: string[];
   parse?: ParseConfig | undefined;
   explicitParamNames?: Set<string> | undefined;
@@ -69,6 +74,7 @@ type ConfigResources = {
   configs: RouteConfig[];
   configsByScreen: Record<string, RouteConfig[]>;
   configsByPattern: Record<string, RouteConfig[]>;
+  prefixRegex?: RegExp | undefined;
 };
 
 const INVALID_SCHEMA_RESULT_ERROR =
@@ -88,6 +94,17 @@ const NESTED_SCREEN_PARAM_NAMES = [
   'pop',
 ];
 
+const getStaticSegmentPattern = (segment: string) =>
+  Array.from(segment, (char) => {
+    const encoded = encodeURIComponent(char);
+    const percentEncoded =
+      encoded === char
+        ? `%${char.charCodeAt(0).toString(16).padStart(2, '0').toUpperCase()}`
+        : encoded;
+
+    return `(?:${escape(char)}|${escape(percentEncoded)})`;
+  }).join('');
+
 const getExplicitParamNames = (parse?: ParseConfig) => {
   const names: string[] = [];
 
@@ -161,8 +178,13 @@ export function getStateFromPath<ParamList extends {}>(
   options?: Options<ParamList>,
   previous?: NavigationState
 ): ResultState | undefined {
-  const { initialRoutes, configs, configsByScreen, configsByPattern } =
-    getConfigResources(options);
+  const {
+    initialRoutes,
+    configs,
+    configsByScreen,
+    configsByPattern,
+    prefixRegex,
+  } = getConfigResources(options);
 
   const screens = options?.screens;
 
@@ -183,24 +205,20 @@ export function getStateFromPath<ParamList extends {}>(
   let remaining = path
     .replace(/\/+/g, '/') // Replace multiple slash (//) with single ones
     .replace(/^\//, '') // Remove extra leading slash
-    .replace(/\?.*$/, ''); // Remove query params which we will handle later
+    .replace(/\?.*$/, '') // Remove query params which we will handle later
+    .replace(/%[0-9a-f]{2}/gi, (m) => m.toUpperCase()); // Normalize percent-encoding as hex digits are case-insensitive
 
   // Make sure there is a trailing slash
   remaining = remaining.endsWith('/') ? remaining : `${remaining}/`;
 
-  const prefix = options?.path?.replace(/^\//, ''); // Remove extra leading slash
-
-  if (prefix) {
-    // Make sure there is a trailing slash
-    const normalizedPrefix = prefix.endsWith('/') ? prefix : `${prefix}/`;
+  if (prefixRegex) {
+    const prefixMatch = remaining.match(prefixRegex);
 
-    // If the path doesn't start with the prefix, it's not a match
-    if (!remaining.startsWith(normalizedPrefix)) {
+    if (prefixMatch == null) {
       return undefined;
     }
 
-    // Remove the prefix from the path
-    remaining = remaining.replace(normalizedPrefix, '');
+    remaining = remaining.slice(prefixMatch[0].length);
   }
 
   if (screens === undefined) {
@@ -358,6 +376,19 @@ function getConfigResources<ParamList extends {}>(
 function prepareConfigResources(options?: Options<{}>) {
   const initialRoutes = getInitialRoutes(options);
   const configs = getSortedNormalizedConfigs(initialRoutes, options?.screens);
+  const prefix = options?.path?.replace(/^\//, '');
+
+  let prefixRegex: RegExp | undefined;
+
+  if (prefix) {
+    const normalizedPrefix = prefix.endsWith('/') ? prefix : `${prefix}/`;
+    const prefixPattern = normalizedPrefix
+      .split('/')
+      .map(getStaticSegmentPattern)
+      .join('/');
+
+    prefixRegex = new RegExp(`^${prefixPattern}`);
+  }
 
   const configsByScreen: Record<string, RouteConfig[]> = {};
   const configsByPattern: Record<string, RouteConfig[]> = {};
@@ -380,6 +411,7 @@ function prepareConfigResources(options?: Options<{}>) {
     configs,
     configsByScreen,
     configsByPattern,
+    prefixRegex,
   };
 }
 
@@ -428,7 +460,21 @@ function getSortedNormalizedConfigs(
     // If 2 patterns are same, move the one with less route names up
     // This is an error state, so it's only useful for consistent error messages
     if (isArrayEqual(a.segments, b.segments)) {
-      return b.routeNames.join('>').localeCompare(a.routeNames.join('>'));
+      if (
+        a.routeNames.length > b.routeNames.length &&
+        arrayStartsWith(a.routeNames, b.routeNames)
+      ) {
+        return -1;
+      }
+
+      if (
+        b.routeNames.length > a.routeNames.length &&
+        arrayStartsWith(b.routeNames, a.routeNames)
+      ) {
+        return 1;
+      }
+
+      return a.routeNames.length - b.routeNames.length || a.order - b.order;
     }
 
     // If one of the patterns starts with the other, it's more exhaustive
@@ -585,6 +631,12 @@ const matchAgainstConfig = (
           return undefined;
         }
 
+        // Percent-encoded values are matched permissively
+        // So validate the decoded value against the custom regex
+        if (param.regex && value !== decoded && !param.regex.test(decoded)) {
+          return undefined;
+        }
+
         const parser = routeConfig.parse?.[param.name];
 
         if (!parser) {
@@ -799,20 +851,27 @@ const createConfigItem = (
       segments.push(part.segment);
 
       if (part.param) {
-        const reg = part.regex || '[^/]+';
+        // A custom regex may not match the percent-encoded form of the value
+        // So also accept segments containing an encoded character and validate them after decoding
+        const reg = part.regex
+          ? `(?:${part.regex})|(?=[^/]*%[0-9A-F]{2})[^/]+`
+          : '[^/]+';
 
         regexString += `(((?<${PARAM_GROUP_PREFIX}${index}>${reg})\\/)${part.optional ? '?' : ''})`;
         params.push({
           index,
           screen: part.screen,
           name: part.param,
+          regex: part.regex ? new RegExp(`^(?:${part.regex})$`) : undefined,
         });
 
         if (part.screen === screen) {
           pathParamNames.add(part.param);
         }
+      } else if (part.segment === '*') {
+        regexString += `.*\\/`;
       } else {
-        regexString += `${part.segment === '*' ? '.*' : escape(part.segment)}\\/`;
+        regexString += `${getStaticSegmentPattern(part.segment)}\\/`;
       }
 
       index++;
@@ -1083,7 +1142,8 @@ const parseQueryParams = (
 ):
   | { valid: true; params?: Record<string, unknown> | undefined }
   | { valid: false } => {
-  const query = path.split('?')[1];
+  const queryIndex = path.indexOf('?');
+  const query = queryIndex === -1 ? undefined : path.slice(queryIndex + 1);
   const params: Record<string, unknown> = query ? queryString.parse(query) : {};
 
   // Path params should always win over same-named query params.

package/src/index.tsx

@@ -11,6 +11,10 @@ export { getFocusedRouteNameFromRoute } from './getFocusedRouteNameFromRoute';
 export { getPathFromState } from './getPathFromState';
 export { getStateFromPath } from './getStateFromPath';
 export { NavigationContainerRefContext } from './NavigationContainerRefContext';
+export {
+  type FocusedRouteState,
+  NavigationFocusedRouteStateContext,
+} from './NavigationFocusedRouteStateContext';
 export { NavigationHelpersContext } from './NavigationHelpersContext';
 export { NavigationIndependentTree } from './NavigationIndependentTree';
 export { NavigationMetaContext } from './NavigationMetaContext';
@@ -61,6 +65,7 @@ export type {
   NavigatorTypeBagBase,
   NavigatorTypeBagFor,
   NestedNavigatorsForParamList,
+  ParamListForNavigator,
   PathConfig,
   PathConfigMap,
   RootNavigator,

package/src/types.tsx

@@ -298,7 +298,7 @@ type NavigatorLike =
       getComponent: () => React.ComponentType<any>;
     };
 
-type ParamListForNavigator<T extends {}> = T extends NavigatorLike
+export type ParamListForNavigator<T extends {}> = T extends NavigatorLike
   ? T extends PrivateValueStore<[infer ParamList extends {}, any, any, any]>
     ? ParamList
     : T
@@ -1654,7 +1654,7 @@ export type PathConfig<Params> = FlatType<
     path?: string | undefined;
     /**
      * An object mapping the param name to a function which converts the param value to a string.
-     * By default, all params are converted to strings using `String(value)`.
+     * By default, arrays and null are preserved for query params, and other values are converted using `String(value)`.
      * Keys are constrained to valid param names when Params type is provided.
      *
      * @example

package/src/useDescriptors.tsx

@@ -315,7 +315,7 @@ export function useDescriptors<
       render() {
         return element;
       },
-      options: customOptions as ScreenOptions,
+      options: customOptions,
     };
 
     return acc;

package/src/useFocusEvents.tsx

@@ -51,7 +51,12 @@ export function useFocusEvents<State extends NavigationState>({
   React.useEffect(() => {
     const lastFocusedKey = lastFocusedKeyRef.current;
 
-    lastFocusedKeyRef.current = currentFocusedKey;
+    const isFocused = navigation ? navigation.isFocused() : true;
+
+    if (isFocused) {
+      // Remember the current route as focused if the navigator is focused
+      lastFocusedKeyRef.current = currentFocusedKey;
+    }
 
     // We wouldn't have `lastFocusedKey` on initial mount
     // Fire focus event for the current route on mount if there's no parent navigator
@@ -61,10 +66,7 @@ export function useFocusEvents<State extends NavigationState>({
 
     // We should only emit events when the focused key changed and navigator is focused
     // When navigator is not focused, screens inside shouldn't receive focused status either
-    if (
-      lastFocusedKey === currentFocusedKey ||
-      !(navigation ? navigation.isFocused() : true)
-    ) {
+    if (lastFocusedKey === currentFocusedKey || !isFocused) {
       return;
     }
 

package/src/useLazyValue.tsx

@@ -1,11 +1,11 @@
 import * as React from 'react';
 
-export function useLazyValue<T>(create: () => T) {
+export function useLazyValue<T>(create: () => T): T {
   const lazyRef = React.useRef<T>(undefined);
 
   if (lazyRef.current === undefined) {
     lazyRef.current = create();
   }
 
-  return lazyRef.current as T;
+  return lazyRef.current;
 }

package/src/useNavigationBuilder.tsx

@@ -337,7 +337,7 @@ export function useNavigationBuilder<
 
   const isNestedParamsConsumed =
     typeof route?.params === 'object' && route.params != null
-      ? consumedParams?.isConsumed(route.params)
+      ? consumedParams?.has(route.params)
       : false;
 
   const {
@@ -571,7 +571,14 @@ export function useNavigationBuilder<
         return [stateBeforeInitialization, hydratedState, true, paramsForState];
       }
 
-      return [undefined, hydratedState, false, paramsForState];
+      return [
+        undefined,
+        hydratedState,
+        false,
+        // Current state is already initialized
+        // So params weren't used, and need to be handled later
+        isStateInitialized(currentState) ? undefined : paramsForState,
+      ];
     }
     // We explicitly don't include routeNames, route.params etc. in the dep list
     // below. We want to avoid forcing a new state to be calculated in those cases
@@ -719,18 +726,16 @@ export function useNavigationBuilder<
         : nextState;
   }
 
-  const setConsumedParams = consumedParams?.setConsumed;
-
   React.useEffect(() => {
     if (
-      setConsumedParams &&
+      consumedParams &&
       didConsumeNestedParams &&
       typeof route?.params === 'object' &&
       route.params != null
     ) {
-      setConsumedParams(route.params);
+      consumedParams.set(route.params, true);
     }
-  }, [didConsumeNestedParams, route?.params, setConsumedParams]);
+  }, [consumedParams, didConsumeNestedParams, route?.params]);
 
   const shouldUpdate = state !== nextState;
 

package/src/useOnAction.tsx

@@ -1,16 +1,14 @@
 import type {
   NavigationAction,
-  NavigationRoute,
   NavigationState,
-  ParamListBase,
-  PartialRoute,
   PartialState,
   Router,
   RouterConfigOptions,
 } from '@react-navigation/routers';
 import * as React from 'react';
 
-import { getLoaderForState } from './DataLoading';
+import { ConsumedParamsContext } from './ConsumedParamsContext';
+import { getLoaderForStateChange } from './DataLoading';
 import {
   type ChildActionListener,
   type ChildBeforeRemoveListener,
@@ -32,40 +30,6 @@ type Options<State extends NavigationState> = {
   emitter: NavigationEventEmitter<EventMapCore<any>>;
 };
 
-type MaybePartialRoute =
-  | NavigationRoute<ParamListBase, string>
-  | PartialRoute<NavigationRoute<ParamListBase, string>>;
-
-const didFocusedRouteChange = (
-  currentState: NavigationState | PartialState<NavigationState>,
-  nextState: NavigationState | PartialState<NavigationState>
-) => {
-  let currentFocusedRoute: MaybePartialRoute | undefined =
-    currentState.routes[currentState.index ?? 0];
-
-  let nextFocusedRoute: MaybePartialRoute | undefined =
-    nextState.routes[nextState.index ?? 0];
-
-  let changed = currentFocusedRoute?.key !== nextFocusedRoute?.key;
-
-  while (
-    !changed &&
-    currentFocusedRoute?.state != null &&
-    nextFocusedRoute?.state != null &&
-    currentFocusedRoute.state !== nextFocusedRoute.state
-  ) {
-    currentFocusedRoute =
-      currentFocusedRoute.state.routes[currentFocusedRoute.state.index ?? 0];
-
-    nextFocusedRoute =
-      nextFocusedRoute.state.routes[nextFocusedRoute.state.index ?? 0];
-
-    changed = currentFocusedRoute?.key !== nextFocusedRoute?.key;
-  }
-
-  return changed;
-};
-
 /**
  * Hook to handle actions for a navigator, including state updates and bubbling.
  *
@@ -93,6 +57,7 @@ export function useOnAction<State extends NavigationState>({
   } = React.use(NavigationBuilderContext);
 
   const tree = React.use(StaticTreeContext);
+  const consumedParams = React.use(ConsumedParamsContext);
 
   const routerConfigOptionsRef =
     React.useRef<RouterConfigOptions>(routerConfigOptions);
@@ -146,8 +111,13 @@ export function useOnAction<State extends NavigationState>({
 
             onDispatchAction(action, false);
 
-            if (tree && didFocusedRouteChange(state, result)) {
-              const loader = getLoaderForState(tree, result);
+            if (tree) {
+              const loader = getLoaderForStateChange(
+                tree,
+                result,
+                state,
+                consumedParams
+              );
 
               loader?.();
             }
@@ -194,6 +164,7 @@ export function useOnAction<State extends NavigationState>({
     [
       actionListeners,
       beforeRemoveListeners,
+      consumedParams,
       emitter,
       getState,
       key,

package/src/useOnPreventRemove.tsx

@@ -39,9 +39,10 @@ export const shouldPreventRemove = (
       .filter(([, route]) => route.key != null)
   );
 
-  const visitedRouteKeys: Set<string> =
-    // @ts-expect-error: add this property to mark that we've already emitted this action
-    action[VISITED_ROUTE_KEYS] ?? new Set<string>();
+  const visitedRouteKeys =
+    VISITED_ROUTE_KEYS in action && action[VISITED_ROUTE_KEYS] instanceof Set
+      ? action[VISITED_ROUTE_KEYS]
+      : new Set<string>();
 
   const beforeRemoveAction = {
     ...action,

package/src/useRouteCache.tsx

@@ -41,10 +41,7 @@ export function useRouteCache<State extends NavigationState>(
       // FIXME: since the state is updated with mutation, the route object cannot be frozen
       // As a workaround, loop through the object and make the properties readonly
       // Only needed once per proxy - skip if we're reusing a previously-frozen one
-      for (const key in proxy) {
-        // @ts-expect-error: this is fine since we are looping through the object
-        const value = proxy[key];
-
+      for (const [key, value] of Object.entries(proxy)) {
         Object.defineProperty(proxy, key, {
           enumerable: true,
           configurable: true,

package/src/useSyncState.tsx

@@ -26,9 +26,10 @@ const createStore = <T,>(getInitialState: () => T) => {
 
   const setState = (newState: T) => {
     state = deepFreeze(newState);
-    didUpdate = true;
 
-    if (!isBatching) {
+    if (isBatching) {
+      didUpdate = true;
+    } else {
       listeners.forEach((listener) => listener());
     }
   };

package/src/utilities.tsx

@@ -26,6 +26,25 @@ export type NoExcessObject<Provided, Allowed> = Record<
   never
 >;
 
+/**
+ * Check an object captured as a generic type against an allowed type,
+ * e.g. an object returned from a callback isn't checked for excess properties.
+ */
+export type NoExcessCallbackReturn<
+  Provided extends {},
+  Allowed extends {},
+> = Allowed & Provided & NoExcessObject<Provided, Allowed>;
+
+/**
+ * Apply excess property checking to a value,
+ * or to the return value if the value is a function.
+ */
+export type NoExcessValue<Provided, Allowed extends {}> = Provided extends (
+  ...args: never[]
+) => infer Return
+  ? (...args: never[]) => Allowed & NoExcessObject<Return, Allowed>
+  : NoExcessObject<Provided, Allowed>;
+
 /**
  * We get a union type when using keyof, but we want an intersection instead.
  * https://stackoverflow.com/a/50375286/1665026