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

package/lib/module/getStateFromPath.js

@@ -1,12 +1,34 @@
 "use strict";
 
 import escape from 'escape-string-regexp';
-import * as queryString from 'query-string';
+import queryString from 'query-string';
 import { arrayStartsWith } from "./arrayStartsWith.js";
 import { findFocusedRoute } from "./findFocusedRoute.js";
-import { getPatternParts } from "./getPatternParts.js";
+import { combinePatternParts, getPatternParts } from "./getPatternParts.js";
 import { isArrayEqual } from "./isArrayEqual.js";
 import { validatePathConfig } from "./validatePathConfig.js";
+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 => {
+  const names = Object.entries(parse ?? {}).filter(([, parser]) => parser != null).map(([name]) => name);
+  return names.length ? new Set(names) : undefined;
+};
+const getStandardSchema = parser => {
+  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, value) => {
+  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);
+};
+
 /**
  * Utility to parse a path string to initial state object accepted by the container.
  * This is useful for deep linking when we need to handle the incoming URL.
@@ -28,12 +50,26 @@ import { validatePathConfig } from "./validatePathConfig.js";
  * @param path Path string to parse and convert, e.g. /foo/bar?count=42.
  * @param options Extra options to fine-tune how to parse the path.
  */
-export function getStateFromPath(path, options) {
+export function getStateFromPath(path, options, previous) {
   const {
     initialRoutes,
-    configs
+    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 => {
+    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
   .replace(/\?.*$/, ''); // Remove query params which we will handle later
@@ -54,14 +90,22 @@ export function getStateFromPath(path, options) {
     // Remove the prefix from the path
     remaining = remaining.replace(normalizedPrefix, '');
   }
+  const decodedSegments = [];
+  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);
     }
@@ -72,31 +116,37 @@ export function getStateFromPath(path, options) {
     // When handling empty path, we should only look at the root level config
     const match = configs.find(config => config.segments.join('/') === '');
     if (match) {
-      return createNestedStateObject(path, match.routeNames.map(name => ({
+      const config = resolveSharedConfig(match);
+      return createNestedStateObject(path, config.routeNames.map(name => ({
         name
-      })), initialRoutes, configs);
+      })), initialRoutes, config);
     }
     return undefined;
   }
-  let result;
-  let current;
 
   // 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);
-  if (routes !== undefined) {
-    // This will always be empty if full path matched
-    current = createNestedStateObject(path, routes, initialRoutes, configs);
-    remaining = remainingPath;
-    result = current;
-  }
-  if (current == null || result == null) {
-    return undefined;
+  for (const config of configs) {
+    const routes = matchAgainstConfig(remaining, config, configsByScreen);
+    if (routes === undefined) {
+      continue;
+    }
+    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;
 }
 
 /**
@@ -118,11 +168,17 @@ function prepareConfigResources(options) {
   const initialRoutes = getInitialRoutes(options);
   const configs = getSortedNormalizedConfigs(initialRoutes, options?.screens);
   checkForDuplicatedConfigs(configs);
-  const configWithRegexes = getConfigsWithRegexes(configs);
+  const configsByScreen = {};
+  const configsByPattern = {};
+  for (const c of configs) {
+    (configsByScreen[c.screen] ??= []).push(c);
+    (configsByPattern[c.segments.join('/')] ??= []).push(c);
+  }
   return {
     initialRoutes,
     configs,
-    configWithRegexes
+    configsByScreen,
+    configsByPattern
   };
 }
 function getInitialRoutes(options) {
@@ -137,7 +193,10 @@ function getInitialRoutes(options) {
 }
 function getSortedNormalizedConfigs(initialRoutes, screens = {}) {
   // Create a normalized configs array which will be easier to use
-  return [].concat(...Object.keys(screens).map(key => createNormalizedConfigs(key, screens, initialRoutes, [], [], []))).sort((a, b) => {
+  return [].concat(...Object.keys(screens).map(key => createNormalizedConfigs(key, screens, initialRoutes, [], [], []))).map((config, order) => ({
+    ...config,
+    order
+  })).sort((a, b) => {
     // Sort config from most specific to least specific:
     // - more segments
     // - static segments
@@ -160,21 +219,24 @@ function getSortedNormalizedConfigs(initialRoutes, screens = {}) {
       return 1;
     }
     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) {
@@ -225,8 +287,8 @@ function checkForDuplicatedConfigs(configs) {
       // It's not a problem if the path string omitted from a inner most screen
       // For example, it's ok if a path resolves to `A > B > C` or `A > B`
       const intersects = a.length > b.length ? b.every((it, i) => a[i] === it) : a.every((it, i) => b[i] === it);
-      if (!intersects) {
-        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.`);
+      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 unless shared: true is specified.`);
       }
     }
     return Object.assign(acc, {
@@ -234,122 +296,131 @@ function checkForDuplicatedConfigs(configs) {
     });
   }, {});
 }
-function getConfigsWithRegexes(configs) {
-  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 matchAgainstConfigs = (remaining, configs) => {
-  let routes;
-  let remainingPath = remaining;
-
-  // Go through all configs, and see if the next path segment matches our regex
-  for (const config of configs) {
-    if (!config.regex) {
-      continue;
-    }
-    const match = remainingPath.match(config.regex);
-
-    // 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);
-        });
-        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 matchAgainstConfig = (remaining, config, configsByScreen) => {
+  if (!config.regex) {
+    return undefined;
+  }
+  const match = remaining.match(config.regex);
+  if (!match) {
+    return undefined;
+  }
+  let validationFailed = false;
+  const matchedRoutes = [];
+  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));
+    let params;
+    if (routeConfig && match.groups) {
+      const paramEntries = [];
+      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 (value == null) {
+          paramEntries.push([param.name, undefined]);
+          continue;
+        }
+        let decoded;
+        try {
+          decoded = decodeURIComponent(value);
+        } catch {
+          return undefined;
+        }
+        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;
           }
-          const decoded = decodeURIComponent(value);
-          const parsed = routeConfig.parse?.[key] ? routeConfig.parse[key](decoded) : decoded;
-          return [key, parsed];
-        })) : undefined;
-        if (params && Object.keys(params).length) {
-          return {
-            name: routeName,
-            params
-          };
+          paramEntries.push([param.name, result.value]);
+          continue;
         }
-        return {
-          name: routeName
-        };
+        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
       });
-      remainingPath = remainingPath.replace(match[0], '');
-      break;
     }
   }
-  return {
-    routes,
-    remainingPath
-  };
+  if (validationFailed) {
+    return undefined;
+  }
+  return matchedRoutes;
 };
-const createNormalizedConfigs = (screen, routeConfig, initials, paths, parentScreens, routeNames) => {
+const createNormalizedConfigs = (screen, routeConfig, initials, parts, parentScreens, routeNames) => {
   const configs = [];
   routeNames.push(screen);
   parentScreens.push(screen);
   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
+    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') {
-      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: ''\`.`);
-      }
-
       // We should add alias configs after the main config
       // So unless they are more specific, main config will be matched first
       const aliasConfigs = [];
       if (config.alias) {
         for (const alias of config.alias) {
           if (typeof alias === 'string') {
-            aliasConfigs.push(createConfigItem(screen, [...routeNames], [...paths, {
-              screen,
-              path: alias
-            }], config.parse));
+            aliasConfigs.push(createConfigItem(screen, [...routeNames], combinePatternParts(parts, getPatternParts(alias).map(part => ({
+              ...part,
+              screen
+            }))), config.parse, hasNestedScreens, false));
           } else if (typeof alias === 'object') {
-            aliasConfigs.push(createConfigItem(screen, [...routeNames], alias.exact ? [{
-              screen,
-              path: alias.path
-            }] : [...paths, {
-              screen,
-              path: alias.path
-            }], alias.parse));
+            aliasConfigs.push(createConfigItem(screen, [...routeNames], 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));
+      configs.push(createConfigItem(screen, [...routeNames], currentParts, config.parse, hasNestedScreens, config.shared === true));
       configs.push(...aliasConfigs);
     }
     if (typeof config !== 'string' && typeof config.path !== 'string' && config.alias?.length) {
       throw new Error(`Screen '${screen}' doesn't specify a 'path'. A 'path' needs to be specified in order to use 'alias'.`);
     }
-    if ('screens' in config && config.screens) {
+    if (hasNestedScreens) {
       // property `initialRouteName` without `screens` has no purpose
       if ('initialRouteName' in config && typeof config.initialRouteName === 'string') {
         initials.push({
@@ -357,8 +428,8 @@ const createNormalizedConfigs = (screen, routeConfig, initials, paths, parentScr
           parentScreens
         });
       }
-      Object.keys(config.screens).forEach(nestedConfig => {
-        const result = createNormalizedConfigs(nestedConfig, config.screens, initials, [...paths], [...parentScreens], routeNames);
+      Object.keys(nestedScreens).forEach(nestedConfig => {
+        const result = createNormalizedConfigs(nestedConfig, nestedScreens, initials, currentParts, [...parentScreens], routeNames);
         configs.push(...result);
       });
     }
@@ -366,23 +437,11 @@ const createNormalizedConfigs = (screen, routeConfig, initials, paths, parentScr
   routeNames.pop();
   return configs;
 };
-const createConfigItem = (screen, routeNames, paths, parse) => {
-  const parts = [];
-
-  // Parse the path string into parts for easier matching
-  for (const {
-    screen,
-    path
-  } of paths) {
-    parts.push(...getPatternParts(path).map(part => ({
-      ...part,
-      screen
-    })));
-  }
+const createConfigItem = (screen, routeNames, parts, parse, hasNestedScreens = false, shared = false) => {
   const regex = parts.length ? new RegExp(`^(${parts.map((it, i) => {
     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)}\\/`;
   }).join('')})$`) : undefined;
@@ -394,20 +453,72 @@ const createConfigItem = (screen, routeNames, paths, parse) => {
   } : null).filter(it => it != null);
   return {
     screen,
+    order: 0,
     regex,
     segments,
     params,
     routeNames,
-    parse
+    parse,
+    explicitParamNames: getExplicitParamNames(parse),
+    hasNestedScreens,
+    shared
   };
 };
-const findParseConfigForRoute = (routeName, flatConfig) => {
-  for (const config of flatConfig) {
-    if (routeName === config.routeNames[config.routeNames.length - 1]) {
-      return config.parse;
+const selectSharedConfig = (match, candidates, previous, initialRoutes) => {
+  // Walk the previous state down to the focused leaf to get the active route path
+  const focusedRouteNames = [];
+  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 => {
+    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
@@ -416,7 +527,9 @@ const findInitialRoute = (routeName, parentScreens, initialRoutes) => {
     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;
         }
@@ -470,45 +583,119 @@ const createStateObject = (initialRoute, route, isEmpty) => {
     }
   }
 };
-const createNestedStateObject = (path, routes, initialRoutes, flatConfig) => {
+const createNestedStateObject = (path, routes, initialRoutes, routeConfig) => {
   let route = routes.shift();
+  if (route == null) {
+    return undefined;
+  }
   const parentScreens = [];
   let initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
   parentScreens.push(route.name);
   const state = createStateObject(initialRoute, route, routes.length === 0);
   if (routes.length > 0) {
     let nestedState = state;
-    while (route = routes.shift()) {
+    let nextRoute = routes.shift();
+    while (nextRoute != null) {
+      route = nextRoute;
       initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
       const nestedStateIndex = nestedState.index || nestedState.routes.length - 1;
-      nestedState.routes[nestedStateIndex].state = createStateObject(initialRoute, route, routes.length === 0);
+      const nestedRoute = nestedState.routes[nestedStateIndex];
+      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;
+        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);
-  route.path = path.replace(/\/$/, '');
-  const params = parseQueryParams(path, flatConfig ? findParseConfigForRoute(route.name, flatConfig) : undefined);
-  if (params) {
-    route.params = {
-      ...route.params,
-      ...params
+  const focusedRoute = findFocusedRoute(state);
+  if (focusedRoute == null) {
+    return undefined;
+  }
+  focusedRoute.path = path.replace(/\/$/, '');
+  const pathParamNames = new Set(routeConfig?.params.filter(param => param.screen === routeConfig.screen && typeof param.name === 'string').map(param => param.name));
+  const queryParams = parseQueryParams(path, routeConfig?.parse, pathParamNames, routeConfig?.explicitParamNames, routeConfig?.hasNestedScreens, focusedRoute.params);
+  if (!queryParams.valid) {
+    return undefined;
+  }
+  if (queryParams.params) {
+    focusedRoute.params = {
+      ...focusedRoute.params,
+      ...queryParams.params
     };
   }
   return state;
 };
-const parseQueryParams = (path, parseConfig) => {
+const parseQueryParams = (path, parseConfig, pathParamNames = new Set(), explicitParamNames, hasNestedScreens = false, routeParams) => {
   const query = path.split('?')[1];
-  const params = queryString.parse(query);
+  const params = 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);
+    }
+  }
+  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 Object.keys(params).length ? params : undefined;
+  return {
+    valid: true,
+    params: Object.keys(params).length ? params : undefined
+  };
 };
 //# sourceMappingURL=getStateFromPath.js.map