@react-navigation/core 8.0.0-alpha.2 → 8.0.0-alpha.21

package/src/getStateFromPath.tsx

@@ -4,30 +4,46 @@ import type {
   PartialState,
 } from '@react-navigation/routers';
 import escape from 'escape-string-regexp';
-import * as queryString from 'query-string';
+import queryString from 'query-string';
 
 import { arrayStartsWith } from './arrayStartsWith';
 import { findFocusedRoute } from './findFocusedRoute';
-import { getPatternParts, type PatternPart } from './getPatternParts';
+import {
+  combinePatternParts,
+  getPatternParts,
+  type PatternPart,
+} from './getPatternParts';
 import { isArrayEqual } from './isArrayEqual';
 import type { PathConfig, PathConfigMap } from './types';
+import type {
+  StandardSchemaV1,
+  StandardSchemaValidationResult,
+} from './utilities';
 import { validatePathConfig } from './validatePathConfig';
 
 type Options<ParamList extends {}> = {
-  path?: string;
-  initialRouteName?: string;
+  path?: string | undefined;
+  initialRouteName?: string | undefined;
   screens: PathConfigMap<ParamList>;
 };
 
-type ParseConfig = Record<string, ((value: string) => unknown) | undefined>;
+type ParseConfigValue =
+  | ((value: string) => unknown)
+  | StandardSchemaV1<unknown, unknown>;
+
+type ParseConfig = Record<string, ParseConfigValue | undefined>;
 
 type RouteConfig = {
   screen: string;
-  regex?: RegExp;
+  order: number;
+  regex?: RegExp | undefined;
   segments: string[];
-  params: { screen: string; name?: string; index: number }[];
+  params: { screen: string; name?: string | undefined; index: number }[];
   routeNames: string[];
-  parse?: ParseConfig;
+  parse?: ParseConfig | undefined;
+  explicitParamNames?: Set<string> | undefined;
+  hasNestedScreens: boolean;
+  shared: boolean;
 };
 
 type InitialRouteConfig = {
@@ -36,18 +52,80 @@ type InitialRouteConfig = {
 };
 
 type ResultState = PartialState<NavigationState> & {
-  state?: ResultState;
+  state?: ResultState | undefined;
 };
 
 type ParsedRoute = {
   name: string;
-  path?: string;
+  path?: string | undefined;
   params?: Record<string, unknown> | undefined;
 };
 
+type RoutePatternPart = PatternPart & { screen: string };
+
 type ConfigResources = {
   initialRoutes: InitialRouteConfig[];
   configs: RouteConfig[];
+  configsByScreen: Record<string, RouteConfig[]>;
+  configsByPattern: Record<string, RouteConfig[]>;
+};
+
+const INVALID_SCHEMA_RESULT_ERROR =
+  'Invalid validation result from schema. It should be an object with either "value" or "issues" property and cannot be asynchronous.';
+
+const INVALID_PARSER_ERROR =
+  'Invalid parser. Expected a function or a Standard Schema V1 object.';
+
+const PARAM_GROUP_PREFIX = 'param_';
+
+const NESTED_SCREEN_PARAM_NAMES = [
+  'screen',
+  'params',
+  'initial',
+  'path',
+  'merge',
+  'pop',
+];
+
+const getExplicitParamNames = (parse?: ParseConfig) => {
+  const names = Object.entries(parse ?? {})
+    .filter(([, parser]) => parser != null)
+    .map(([name]) => name);
+
+  return names.length ? new Set(names) : undefined;
+};
+
+const getStandardSchema = (parser: ParseConfigValue) => {
+  if (
+    '~standard' in parser &&
+    typeof parser['~standard'] === 'object' &&
+    parser['~standard'] !== null &&
+    'version' in parser['~standard'] &&
+    parser['~standard'].version === 1 &&
+    'validate' in parser['~standard'] &&
+    typeof parser['~standard'].validate === 'function'
+  ) {
+    return parser['~standard'];
+  }
+
+  return undefined;
+};
+
+const getValidationResult = (
+  schema: StandardSchemaV1<unknown, unknown>['~standard'],
+  value: unknown
+): StandardSchemaValidationResult<unknown> => {
+  const result = schema.validate(value);
+
+  if (
+    result != null &&
+    typeof result === 'object' &&
+    ('value' in result || ('issues' in result && Array.isArray(result.issues)))
+  ) {
+    return result;
+  }
+
+  throw new Error(INVALID_SCHEMA_RESULT_ERROR);
 };
 
 /**
@@ -73,12 +151,28 @@ type ConfigResources = {
  */
 export function getStateFromPath<ParamList extends {}>(
   path: string,
-  options?: Options<ParamList>
+  options?: Options<ParamList>,
+  previous?: NavigationState
 ): ResultState | undefined {
-  const { initialRoutes, configs } = getConfigResources(options);
+  const { initialRoutes, configs, configsByScreen, configsByPattern } =
+    getConfigResources(options);
 
   const screens = options?.screens;
 
+  // When a matched config is shared, the same pattern can resolve to multiple branches
+  // pick the one that best matches the current navigation state
+  const resolveSharedConfig = (config: RouteConfig) => {
+    if (config.shared) {
+      const candidates = configsByPattern[config.segments.join('/')];
+
+      if (candidates) {
+        return selectSharedConfig(config, candidates, previous, initialRoutes);
+      }
+    }
+
+    return config;
+  };
+
   let remaining = path
     .replace(/\/+/g, '/') // Replace multiple slash (//) with single ones
     .replace(/^\//, '') // Remove extra leading slash
@@ -102,15 +196,23 @@ export function getStateFromPath<ParamList extends {}>(
     remaining = remaining.replace(normalizedPrefix, '');
   }
 
+  const decodedSegments: string[] = [];
+
+  for (const segment of remaining.split('/')) {
+    if (!segment) {
+      continue;
+    }
+
+    try {
+      decodedSegments.push(decodeURIComponent(segment));
+    } catch {
+      return undefined;
+    }
+  }
+
   if (screens === undefined) {
     // When no config is specified, use the path segments as route names
-    const routes = remaining
-      .split('/')
-      .filter(Boolean)
-      .map((segment) => {
-        const name = decodeURIComponent(segment);
-        return { name };
-      });
+    const routes = decodedSegments.map((name) => ({ name }));
 
     if (routes.length) {
       return createNestedStateObject(path, routes, initialRoutes);
@@ -125,36 +227,58 @@ export function getStateFromPath<ParamList extends {}>(
     const match = configs.find((config) => config.segments.join('/') === '');
 
     if (match) {
+      const config = resolveSharedConfig(match);
+
       return createNestedStateObject(
         path,
-        match.routeNames.map((name) => ({ name })),
+        config.routeNames.map((name) => ({ name })),
         initialRoutes,
-        configs
+        config
       );
     }
 
     return undefined;
   }
 
-  let result: PartialState<NavigationState> | undefined;
-  let current: PartialState<NavigationState> | undefined;
-
   // We match the whole path against the regex instead of segments
   // This makes sure matches such as wildcard will catch any unmatched routes, even if nested
-  const { routes, remainingPath } = matchAgainstConfigs(remaining, configs);
+  for (const config of configs) {
+    const routes = matchAgainstConfig(remaining, config, configsByScreen);
 
-  if (routes !== undefined) {
-    // This will always be empty if full path matched
-    current = createNestedStateObject(path, routes, initialRoutes, configs);
-    remaining = remainingPath;
-    result = current;
-  }
+    if (routes === undefined) {
+      continue;
+    }
 
-  if (current == null || result == null) {
-    return undefined;
+    let selectedConfig = resolveSharedConfig(config);
+    let selectedRoutes = routes;
+
+    if (selectedConfig !== config) {
+      const rematchedRoutes = matchAgainstConfig(
+        remaining,
+        selectedConfig,
+        configsByScreen
+      );
+
+      if (rematchedRoutes === undefined) {
+        selectedConfig = config;
+      } else {
+        selectedRoutes = rematchedRoutes;
+      }
+    }
+
+    const state = createNestedStateObject(
+      path,
+      selectedRoutes,
+      initialRoutes,
+      selectedConfig
+    );
+
+    if (state !== undefined) {
+      return state;
+    }
   }
 
-  return result;
+  return undefined;
 }
 
 /**
@@ -188,12 +312,19 @@ function prepareConfigResources(options?: Options<{}>) {
 
   checkForDuplicatedConfigs(configs);
 
-  const configWithRegexes = getConfigsWithRegexes(configs);
+  const configsByScreen: Record<string, RouteConfig[]> = {};
+  const configsByPattern: Record<string, RouteConfig[]> = {};
+
+  for (const c of configs) {
+    (configsByScreen[c.screen] ??= []).push(c);
+    (configsByPattern[c.segments.join('/')] ??= []).push(c);
+  }
 
   return {
     initialRoutes,
     configs,
-    configWithRegexes,
+    configsByScreen,
+    configsByPattern,
   };
 }
 
@@ -221,6 +352,7 @@ function getSortedNormalizedConfigs(
         createNormalizedConfigs(key, screens, initialRoutes, [], [], [])
       )
     )
+    .map((config, order) => ({ ...config, order }))
     .sort((a, b) => {
       // Sort config from most specific to least specific:
       // - more segments
@@ -246,22 +378,25 @@ function getSortedNormalizedConfigs(
       }
 
       for (let i = 0; i < Math.max(a.segments.length, b.segments.length); i++) {
+        const aSegment = a.segments[i];
+        const bSegment = b.segments[i];
+
         // if b is longer, b gets higher priority
-        if (a.segments[i] == null) {
+        if (aSegment == null) {
           return 1;
         }
 
         // if a is longer, a gets higher priority
-        if (b.segments[i] == null) {
+        if (bSegment == null) {
           return -1;
         }
 
-        const aWildCard = a.segments[i] === '*';
-        const bWildCard = b.segments[i] === '*';
-        const aParam = a.segments[i].startsWith(':');
-        const bParam = b.segments[i].startsWith(':');
-        const aRegex = aParam && a.segments[i].includes('(');
-        const bRegex = bParam && b.segments[i].includes('(');
+        const aWildCard = aSegment === '*';
+        const bWildCard = bSegment === '*';
+        const aParam = aSegment.startsWith(':');
+        const bParam = bSegment.startsWith(':');
+        const aRegex = aParam && aSegment.includes('(');
+        const bRegex = bParam && bSegment.includes('(');
 
         // if both are wildcard or regex, we compare next component
         if ((aWildCard && bWildCard) || (aRegex && bRegex)) {
@@ -319,13 +454,13 @@ function checkForDuplicatedConfigs(configs: RouteConfig[]) {
           ? b.every((it, i) => a[i] === it)
           : a.every((it, i) => b[i] === it);
 
-      if (!intersects) {
+      if (!intersects && (!acc[pattern].shared || !config.shared)) {
         throw new Error(
           `Found conflicting screens with the same pattern. The pattern '${
             pattern
           }' resolves to both '${a.join(' > ')}' and '${b.join(
             ' > '
-          )}'. Patterns must be unique and cannot resolve to more than one screen.`
+          )}'. Patterns must be unique and cannot resolve to more than one screen unless shared: true is specified.`
         );
       }
     }
@@ -336,90 +471,118 @@ function checkForDuplicatedConfigs(configs: RouteConfig[]) {
   }, {});
 }
 
-function getConfigsWithRegexes(configs: RouteConfig[]) {
-  return configs.map((c) => ({
-    ...c,
-    // Add `$` to the regex to make sure it matches till end of the path and not just beginning
-    regex: c.regex ? new RegExp(c.regex.source + '$') : undefined,
-  }));
-}
+const matchAgainstConfig = (
+  remaining: string,
+  config: RouteConfig,
+  configsByScreen: Record<string, RouteConfig[]>
+) => {
+  if (!config.regex) {
+    return undefined;
+  }
 
-const matchAgainstConfigs = (remaining: string, configs: RouteConfig[]) => {
-  let routes: ParsedRoute[] | undefined;
-  let remainingPath = remaining;
+  const match = remaining.match(config.regex);
 
-  // Go through all configs, and see if the next path segment matches our regex
-  for (const config of configs) {
-    if (!config.regex) {
-      continue;
-    }
+  if (!match) {
+    return undefined;
+  }
 
-    const match = remainingPath.match(config.regex);
+  let validationFailed = false;
+  const matchedRoutes: ParsedRoute[] = [];
 
-    // If our regex matches, we need to extract params from the path
-    if (match) {
-      routes = config.routeNames.map((routeName) => {
-        const routeConfig = configs.find((c) => {
-          // Check matching name AND pattern in case same screen is used at different levels in config
-          return (
-            c.screen === routeName &&
-            arrayStartsWith(config.segments, c.segments)
-          );
-        });
+  for (const [index, routeName] of config.routeNames.entries()) {
+    // Check matching name, route names and pattern in case same screen is used
+    // at different levels or branches in config
+    const routeConfig = configsByScreen[routeName]?.find(
+      (c) =>
+        index === c.routeNames.length - 1 &&
+        arrayStartsWith(config.routeNames, c.routeNames) &&
+        arrayStartsWith(config.segments, c.segments)
+    );
 
-        const params =
-          routeConfig && match.groups
-            ? Object.fromEntries(
-                Object.entries(match.groups)
-                  .map(([key, value]) => {
-                    const index = Number(key.replace('param_', ''));
-                    const param = routeConfig.params.find(
-                      (it) => it.index === index
-                    );
-
-                    if (param?.screen === routeName && param?.name) {
-                      return [param.name, value];
-                    }
-
-                    return null;
-                  })
-                  .filter((it) => it != null)
-                  .map(([key, value]) => {
-                    if (value == null) {
-                      return [key, undefined];
-                    }
-
-                    const decoded = decodeURIComponent(value);
-                    const parsed = routeConfig.parse?.[key]
-                      ? routeConfig.parse[key](decoded)
-                      : decoded;
-
-                    return [key, parsed];
-                  })
-              )
-            : undefined;
+    let params: Record<string, unknown> | undefined;
+
+    if (routeConfig && match.groups) {
+      const paramEntries: [string, unknown][] = [];
+
+      for (const [key, value] of Object.entries(match.groups)) {
+        const index = Number(key.replace(PARAM_GROUP_PREFIX, ''));
+        const param = routeConfig.params.find((it) => it.index === index);
+
+        if (param?.screen !== routeName || !param.name) {
+          continue;
+        }
 
-        if (params && Object.keys(params).length) {
-          return { name: routeName, params };
+        if (value == null) {
+          paramEntries.push([param.name, undefined]);
+          continue;
         }
 
-        return { name: routeName };
-      });
+        let decoded: string;
 
-      remainingPath = remainingPath.replace(match[0], '');
+        try {
+          decoded = decodeURIComponent(value);
+        } catch {
+          return undefined;
+        }
 
-      break;
+        const parser = routeConfig.parse?.[param.name];
+
+        if (!parser) {
+          paramEntries.push([param.name, decoded]);
+          continue;
+        }
+
+        const schema = getStandardSchema(parser);
+
+        if (schema) {
+          const result = getValidationResult(schema, decoded);
+
+          if (result.issues) {
+            validationFailed = true;
+            break;
+          }
+
+          paramEntries.push([param.name, result.value]);
+          continue;
+        }
+
+        if (typeof parser === 'function') {
+          paramEntries.push([param.name, parser(decoded)]);
+          continue;
+        }
+
+        throw new Error(INVALID_PARSER_ERROR);
+      }
+
+      if (validationFailed) {
+        // A failed param validation invalidates the whole nested route chain for this config.
+        break;
+      }
+
+      if (paramEntries.length) {
+        params = Object.fromEntries(paramEntries);
+      }
+    }
+
+    if (params && Object.keys(params).length) {
+      matchedRoutes.push({ name: routeName, params });
+    } else {
+      matchedRoutes.push({ name: routeName });
     }
   }
 
-  return { routes, remainingPath };
+  if (validationFailed) {
+    return undefined;
+  }
+
+  return matchedRoutes;
 };
 
 const createNormalizedConfigs = (
   screen: string,
   routeConfig: Record<string, string | PathConfig<{}>>,
   initials: InitialRouteConfig[],
-  paths: { screen: string; path: string }[],
+  parts: RoutePatternPart[],
   parentScreens: string[],
   routeNames: string[]
 ): RouteConfig[] => {
@@ -432,19 +595,28 @@ const createNormalizedConfigs = (
   const config = routeConfig[screen];
 
   if (typeof config === 'string') {
-    paths.push({ screen, path: config });
-    configs.push(createConfigItem(screen, [...routeNames], [...paths]));
+    const configParts = combinePatternParts(
+      parts,
+      getPatternParts(config).map((part) => ({ ...part, screen }))
+    );
+
+    configs.push(createConfigItem(screen, [...routeNames], configParts));
   } else if (typeof config === 'object') {
     // if an object is specified as the value (e.g. Foo: { ... }),
     // it can have `path` property and
     // it could have `screens` prop which has nested configs
-    if (typeof config.path === 'string') {
-      if (config.exact && config.path == null) {
-        throw new Error(
-          `Screen '${screen}' doesn't specify a 'path'. A 'path' needs to be specified when specifying 'exact: true'. If you don't want this screen in the URL, specify it as empty string, e.g. \`path: ''\`.`
-        );
-      }
+    const nestedScreens = 'screens' in config ? config.screens : undefined;
+    const hasNestedScreens = !!nestedScreens;
+    const currentParts =
+      typeof config.path === 'string'
+        ? combinePatternParts(
+            parts,
+            getPatternParts(config.path).map((part) => ({ ...part, screen })),
+            config.exact
+          )
+        : parts;
 
+    if (typeof config.path === 'string') {
       // We should add alias configs after the main config
       // So unless they are more specific, main config will be matched first
       const aliasConfigs = [];
@@ -456,8 +628,13 @@ const createNormalizedConfigs = (
               createConfigItem(
                 screen,
                 [...routeNames],
-                [...paths, { screen, path: alias }],
-                config.parse
+                combinePatternParts(
+                  parts,
+                  getPatternParts(alias).map((part) => ({ ...part, screen }))
+                ),
+                config.parse,
+                hasNestedScreens,
+                false
               )
             );
           } else if (typeof alias === 'object') {
@@ -465,25 +642,32 @@ const createNormalizedConfigs = (
               createConfigItem(
                 screen,
                 [...routeNames],
-                alias.exact
-                  ? [{ screen, path: alias.path }]
-                  : [...paths, { screen, path: alias.path }],
-                alias.parse
+                combinePatternParts(
+                  parts,
+                  getPatternParts(alias.path).map((part) => ({
+                    ...part,
+                    screen,
+                  })),
+                  alias.exact
+                ),
+                alias.parse,
+                hasNestedScreens,
+                alias.shared === true
               )
             );
           }
         }
       }
 
-      if (config.exact) {
-        // If it's an exact path, we don't need to keep track of the parent screens
-        // So we can clear it
-        paths.length = 0;
-      }
-
-      paths.push({ screen, path: config.path });
       configs.push(
-        createConfigItem(screen, [...routeNames], [...paths], config.parse)
+        createConfigItem(
+          screen,
+          [...routeNames],
+          currentParts,
+          config.parse,
+          hasNestedScreens,
+          config.shared === true
+        )
       );
 
       configs.push(...aliasConfigs);
@@ -499,7 +683,7 @@ const createNormalizedConfigs = (
       );
     }
 
-    if ('screens' in config && config.screens) {
+    if (hasNestedScreens) {
       // property `initialRouteName` without `screens` has no purpose
       if (
         'initialRouteName' in config &&
@@ -511,12 +695,12 @@ const createNormalizedConfigs = (
         });
       }
 
-      Object.keys(config.screens).forEach((nestedConfig) => {
+      Object.keys(nestedScreens).forEach((nestedConfig) => {
         const result = createNormalizedConfigs(
           nestedConfig,
-          config.screens as Record<string, string | PathConfig<{}>>,
+          nestedScreens as Record<string, string | PathConfig<{}>>,
           initials,
-          [...paths],
+          currentParts,
           [...parentScreens],
           routeNames
         );
@@ -534,16 +718,11 @@ const createNormalizedConfigs = (
 const createConfigItem = (
   screen: string,
   routeNames: string[],
-  paths: { screen: string; path: string }[],
-  parse?: ParseConfig
+  parts: RoutePatternPart[],
+  parse?: ParseConfig,
+  hasNestedScreens = false,
+  shared = false
 ): RouteConfig => {
-  const parts: (PatternPart & { screen: string })[] = [];
-
-  // Parse the path string into parts for easier matching
-  for (const { screen, path } of paths) {
-    parts.push(...getPatternParts(path).map((part) => ({ ...part, screen })));
-  }
-
   const regex = parts.length
     ? new RegExp(
         `^(${parts
@@ -551,7 +730,7 @@ const createConfigItem = (
             if (it.param) {
               const reg = it.regex || '[^/]+';
 
-              return `(((?<param_${i}>${reg})\\/)${it.optional ? '?' : ''})`;
+              return `(((?<${PARAM_GROUP_PREFIX}${i}>${reg})\\/)${it.optional ? '?' : ''})`;
             }
 
             return `${it.segment === '*' ? '.*' : escape(it.segment)}\\/`;
@@ -575,25 +754,95 @@ const createConfigItem = (
 
   return {
     screen,
+    order: 0,
     regex,
     segments,
     params,
     routeNames,
     parse,
+    explicitParamNames: getExplicitParamNames(parse),
+    hasNestedScreens,
+    shared,
   };
 };
 
-const findParseConfigForRoute = (
-  routeName: string,
-  flatConfig: RouteConfig[]
-): ParseConfig | undefined => {
-  for (const config of flatConfig) {
-    if (routeName === config.routeNames[config.routeNames.length - 1]) {
-      return config.parse;
+const selectSharedConfig = (
+  match: RouteConfig,
+  candidates: RouteConfig[],
+  previous: NavigationState | PartialState<NavigationState> | undefined,
+  initialRoutes: InitialRouteConfig[]
+) => {
+  // Walk the previous state down to the focused leaf to get the active route path
+  const focusedRouteNames: string[] = [];
+
+  let current = previous;
+
+  while (current?.routes.length) {
+    const index =
+      typeof current.index === 'number'
+        ? current.index
+        : current.routes.length - 1;
+
+    const route = current.routes[index];
+
+    if (route == null) {
+      break;
     }
+
+    focusedRouteNames.push(route.name);
+    current = route.state;
   }
 
-  return undefined;
+  // Rank a candidate by how far it aligns with the focused path, then by
+  // how many of its levels match a configured initial route
+  const score = (routeNames: string[]) => {
+    let focused = 0;
+
+    while (
+      routeNames[focused] !== undefined &&
+      routeNames[focused] === focusedRouteNames[focused]
+    ) {
+      focused++;
+    }
+
+    let initial = 0;
+
+    for (const config of initialRoutes) {
+      if (
+        arrayStartsWith(routeNames, config.parentScreens) &&
+        routeNames[config.parentScreens.length] === config.initialRouteName
+      ) {
+        initial++;
+      }
+    }
+
+    return { focused, initial };
+  };
+
+  let selected = match;
+  let best = { focused: -1, initial: -1 };
+
+  for (const candidate of candidates) {
+    if (!candidate.shared) {
+      continue;
+    }
+
+    const { focused, initial } = score(candidate.routeNames);
+
+    const better =
+      focused !== best.focused
+        ? focused > best.focused
+        : initial !== best.initial
+          ? initial > best.initial
+          : candidate.order < selected.order;
+
+    if (better) {
+      selected = candidate;
+      best = { focused, initial };
+    }
+  }
+
+  return selected;
 };
 
 // Try to find an initial route connected with the one passed
@@ -606,7 +855,14 @@ const findInitialRoute = (
     if (parentScreens.length === config.parentScreens.length) {
       let sameParents = true;
       for (let i = 0; i < parentScreens.length; i++) {
-        if (parentScreens[i].localeCompare(config.parentScreens[i]) !== 0) {
+        const parentScreen = parentScreens[i];
+        const configParentScreen = config.parentScreens[i];
+
+        if (
+          parentScreen == null ||
+          configParentScreen == null ||
+          parentScreen.localeCompare(configParentScreen) !== 0
+        ) {
           sameParents = false;
           break;
         }
@@ -657,9 +913,14 @@ const createNestedStateObject = (
   path: string,
   routes: ParsedRoute[],
   initialRoutes: InitialRouteConfig[],
-  flatConfig?: RouteConfig[]
-) => {
-  let route = routes.shift() as ParsedRoute;
+  routeConfig?: RouteConfig
+): InitialState | undefined => {
+  let route = routes.shift();
+
+  if (route == null) {
+    return undefined;
+  }
+
   const parentScreens: string[] = [];
 
   let initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
@@ -675,57 +936,171 @@ const createNestedStateObject = (
   if (routes.length > 0) {
     let nestedState = state;
 
-    while ((route = routes.shift() as ParsedRoute)) {
+    let nextRoute = routes.shift();
+
+    while (nextRoute != null) {
+      route = nextRoute;
       initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
 
       const nestedStateIndex =
         nestedState.index || nestedState.routes.length - 1;
+      const nestedRoute = nestedState.routes[nestedStateIndex];
 
-      nestedState.routes[nestedStateIndex].state = createStateObject(
+      if (nestedRoute == null) {
+        throw new Error(`Couldn't find a route at index ${nestedStateIndex}.`);
+      }
+
+      nestedRoute.state = createStateObject(
         initialRoute,
         route,
         routes.length === 0
       );
 
       if (routes.length > 0) {
-        nestedState = nestedState.routes[nestedStateIndex]
-          .state as InitialState;
+        if (nestedRoute.state == null) {
+          throw new Error(
+            `Couldn't find nested state for route '${route.name}'.`
+          );
+        }
+
+        nestedState = nestedRoute.state;
       }
 
       parentScreens.push(route.name);
+      nextRoute = routes.shift();
     }
   }
 
-  route = findFocusedRoute(state) as ParsedRoute;
-  route.path = path.replace(/\/$/, '');
+  const focusedRoute = findFocusedRoute(state);
+
+  if (focusedRoute == null) {
+    return undefined;
+  }
 
-  const params = parseQueryParams(
+  focusedRoute.path = path.replace(/\/$/, '');
+
+  const pathParamNames = new Set(
+    routeConfig?.params
+      .filter(
+        (param): param is { screen: string; name: string; index: number } =>
+          param.screen === routeConfig.screen && typeof param.name === 'string'
+      )
+      .map((param) => param.name)
+  );
+
+  const queryParams = parseQueryParams(
     path,
-    flatConfig ? findParseConfigForRoute(route.name, flatConfig) : undefined
+    routeConfig?.parse,
+    pathParamNames,
+    routeConfig?.explicitParamNames,
+    routeConfig?.hasNestedScreens,
+    focusedRoute.params
   );
 
-  if (params) {
-    route.params = { ...route.params, ...params };
+  if (!queryParams.valid) {
+    return undefined;
+  }
+
+  if (queryParams.params) {
+    focusedRoute.params = { ...focusedRoute.params, ...queryParams.params };
   }
 
   return state;
 };
 
-const parseQueryParams = (path: string, parseConfig?: ParseConfig) => {
+const parseQueryParams = (
+  path: string,
+  parseConfig?: ParseConfig,
+  pathParamNames: Set<string> = new Set(),
+  explicitParamNames?: Set<string>,
+  hasNestedScreens = false,
+  routeParams?: object
+):
+  | { valid: true; params?: Record<string, unknown> | undefined }
+  | { valid: false } => {
   const query = path.split('?')[1];
-  const params: Record<string, unknown> = queryString.parse(query);
+  const params: Record<string, unknown> = query ? queryString.parse(query) : {};
+
+  // Path params should always win over same-named query params.
+  for (const name of pathParamNames) {
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete params[name];
+  }
 
   if (parseConfig) {
-    Object.keys(params).forEach((name) => {
-      if (
-        Object.hasOwnProperty.call(parseConfig, name) &&
-        parseConfig[name] &&
-        typeof params[name] === 'string'
-      ) {
-        params[name] = parseConfig[name](params[name]);
+    for (const [name, parser] of Object.entries(parseConfig)) {
+      if (!parser || pathParamNames.has(name)) {
+        continue;
       }
-    });
+
+      const schema = getStandardSchema(parser);
+
+      if (!Object.hasOwn(params, name)) {
+        if (!schema) {
+          continue;
+        }
+
+        const result = getValidationResult(schema, undefined);
+
+        if (result.issues) {
+          return { valid: false };
+        }
+
+        if (result.value !== undefined) {
+          params[name] = result.value;
+        }
+
+        continue;
+      }
+
+      if (schema) {
+        const result = getValidationResult(schema, params[name]);
+
+        if (result.issues) {
+          return { valid: false };
+        }
+
+        params[name] = result.value;
+        continue;
+      }
+
+      const value = Array.isArray(params[name])
+        ? params[name][0]
+        : params[name];
+
+      if (typeof value !== 'string') {
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete params[name];
+        continue;
+      }
+
+      if (typeof parser === 'function') {
+        params[name] = parser(value);
+        continue;
+      }
+
+      throw new Error(INVALID_PARSER_ERROR);
+    }
   }
 
-  return Object.keys(params).length ? params : undefined;
+  if (
+    hasNestedScreens &&
+    !explicitParamNames?.has('screen') &&
+    (typeof params.screen === 'string' ||
+      (routeParams != null &&
+        'screen' in routeParams &&
+        typeof routeParams.screen === 'string'))
+  ) {
+    for (const name of NESTED_SCREEN_PARAM_NAMES) {
+      if (!explicitParamNames?.has(name)) {
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete params[name];
+      }
+    }
+  }
+
+  return {
+    valid: true,
+    params: Object.keys(params).length ? params : undefined,
+  };
 };