one 1.1.390 → 1.1.392

package/src/fork/getStateFromPath.ts

@@ -1,70 +1,72 @@
-import type { PathConfigMap } from '@react-navigation/core'
-import type { InitialState } from '@react-navigation/routers'
-// biome-ignore lint/suspicious/noShadowRestrictedNames: <explanation>
+/**
+ * This file is copied from the react-navigation repo:
+ * https://github.com/react-navigation/react-navigation/blob/%40react-navigation/core%407.1.2/packages/core/src/getStateFromPath.tsx
+ *
+ * Please refrain from making changes to this file, as it will make merging updates from the upstream harder.
+ * All modifications except formatting should be marked with `// @modified` comment.
+ */
+
+import type { InitialState, NavigationState, PartialState } from '@react-navigation/routers'
+// biome-ignore lint/suspicious/noShadowRestrictedNames: ignore from forked code // @modified
 import escape from 'escape-string-regexp'
-import type { RouteNode } from '../router/Route'
-import { matchGroupName, stripGroupSegmentsFromPath } from '../router/matchers'
-import { findFocusedRoute } from './findFocusedRoute'
-import validatePathConfig from './validatePathConfig'
-import type { OneRouter } from '../interfaces/router'
+// import * as queryString from 'query-string'
 
-type Options<ParamList extends object> = {
+import { findFocusedRoute } from './findFocusedRoute'
+import type { PathConfigMap } from '@react-navigation/core' // @modified
+import { validatePathConfig } from './validatePathConfig'
+import {
+  type AdditionalRouteConfig,
+  appendIsInitial,
+  createConfigItemAdditionalProperties,
+  decodeURIComponentSafe,
+  formatRegexPattern,
+  getParamValue,
+  getRouteConfigSorter,
+  getUrlWithReactNavigationConcessions,
+  matchForEmptyPath,
+  parseQueryParamsExtended,
+  populateParams,
+} from './getStateFromPath-mods'
+
+type Options<ParamList extends {}> = {
+  path?: string
   initialRouteName?: string
   screens: PathConfigMap<ParamList>
 }
 
 type ParseConfig = Record<string, (value: string) => any>
 
-type RouteConfig = {
-  isInitial?: boolean
+// @modified: add export
+export type RouteConfig = {
   screen: string
   regex?: RegExp
   path: string
   pattern: string
   routeNames: string[]
   parse?: ParseConfig
-  hasChildren: boolean
-  userReadableName: string
-  _route?: RouteNode
-}
+} & AdditionalRouteConfig // @modified: union with AdditionalRouteConfig
 
-type InitialRouteConfig = {
+// @modified: add export
+export type InitialRouteConfig = {
   initialRouteName: string
   parentScreens: string[]
 }
 
-type ParsedRoute = {
+type ResultState = PartialState<NavigationState> & {
+  state?: ResultState
+}
+
+// @modified: add export
+export type ParsedRoute = {
   name: string
   path?: string
-  params?: Record<string, any>
+  params?: Record<string, any> | undefined
 }
 
-export function getUrlWithReactNavigationConcessions(
-  path: string,
-  baseUrl: string | undefined = process.env.EXPO_BASE_URL
-) {
-  let parsed: URL
-  try {
-    parsed = new URL(path, baseUrl || 'http://phony.example')
-  } catch (err) {
-    console.warn(`Error parsing url ${path}: ${err?.['message']}`)
-    // Do nothing with invalid URLs.
-    return {
-      nonstandardPathname: path,
-      inputPathnameWithoutHash: path.replace(/#.*$/g, ''),
-      url: null,
-    }
-  }
-
-  const pathname = parsed.pathname
-
-  // Make sure there is a trailing slash
-  return {
-    // The slashes are at the end, not the beginning
-    nonstandardPathname:
-      stripBaseUrl(pathname, baseUrl).replace(/^\/+/g, '').replace(/\/+$/g, '') + '/',
-    url: parsed,
-  }
+type ConfigResources = {
+  initialRoutes: InitialRouteConfig[]
+  configs: RouteConfig[]
+  configWithRegexes: RouteConfig[]
 }
 
 /**
@@ -88,322 +90,276 @@ export function getUrlWithReactNavigationConcessions(
  * @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 default function getStateFromPath<ParamList extends object>(
+export function getStateFromPath<ParamList extends {}>(
   path: string,
   options?: Options<ParamList>
-): OneRouter.ResultState | undefined {
-  const { initialRoutes, configs } = getMatchableRouteConfigs(options)
-  return getStateFromPathWithConfigs(path, configs, initialRoutes)
-}
-
-export function getMatchableRouteConfigs<ParamList extends object>(options?: Options<ParamList>) {
-  if (options) {
-    validatePathConfig(options)
-  }
+): ResultState | undefined {
+  const { initialRoutes, configs, configWithRegexes } = getConfigResources(options)
 
   const screens = options?.screens
-  // One disallows usage without a linking config.
-  if (!screens) {
-    throw Error("You must pass a 'screens' object to 'getStateFromPath' to generate a path.")
-  }
 
-  // This will be mutated...
-  const initialRoutes: InitialRouteConfig[] = []
+  // @modified - start
+  const pathData = getUrlWithReactNavigationConcessions(path)
+  // @modified - end
 
-  if (options?.initialRouteName) {
-    initialRoutes.push({
-      initialRouteName: options.initialRouteName,
-      parentScreens: [],
-    })
-  }
+  let remaining = pathData.nonstandardPathname // @modified: use `pathData.nonstandardPathname` instead of `path`
+    .replace(/\/+/g, '/') // Replace multiple slash (//) with single ones
+    .replace(/^\//, '') // Remove extra leading slash
+    .replace(/\?.*$/, '') // Remove query params which we will handle later
 
-  // Create a normalized configs array which will be easier to use.
-  const converted = Object.keys(screens)
-    .flatMap((key) => createNormalizedConfigs(key, screens, [], initialRoutes))
-    .flat()
-
-  const resolvedInitialPatterns = initialRoutes.map((route) =>
-    joinPaths(...route.parentScreens, route.initialRouteName)
-  )
+  // Make sure there is a trailing slash
+  remaining = remaining.endsWith('/') ? remaining : `${remaining}/`
 
-  const convertedWithInitial = converted.map((config) => ({
-    ...config,
-    // TODO: Probably a safer way to do this
-    // Mark initial routes to give them potential priority over other routes that match.
-    isInitial: resolvedInitialPatterns.includes(config.routeNames.join('/')),
-  }))
+  const prefix = options?.path?.replace(/^\//, '') // Remove extra leading slash
 
-  // Sort in order of resolution. This is extremely important for the algorithm to work.
-  const configs = convertedWithInitial.sort(sortConfigs)
+  if (prefix) {
+    // Make sure there is a trailing slash
+    const normalizedPrefix = prefix.endsWith('/') ? prefix : `${prefix}/`
 
-  // Assert any duplicates before we start parsing.
-  assertConfigDuplicates(configs)
+    // If the path doesn't start with the prefix, it's not a match
+    if (!remaining.startsWith(normalizedPrefix)) {
+      return undefined
+    }
 
-  return { configs, initialRoutes }
-}
+    // Remove the prefix from the path
+    remaining = remaining.replace(normalizedPrefix, '')
+  }
 
-function assertConfigDuplicates(configs: RouteConfig[]) {
-  // Check for duplicate patterns in the config
-  configs.reduce<Record<string, RouteConfig>>((acc, config) => {
-    // NOTE: Uses the regex pattern as key to detect duplicate slugs.
-    const indexedKey = config.regex?.toString() ?? config.pattern
-    const alpha = acc[indexedKey]
+  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 }
+      })
 
-    // NOTE: Skips checking nodes that have children.
-    if (alpha && !alpha.hasChildren && !config.hasChildren) {
-      const a = alpha.routeNames
-      const b = config.routeNames
+    if (routes.length) {
+      // @modified - start
+      // return createNestedStateObject(path, routes, initialRoutes)
+      return createNestedStateObject(pathData, routes, initialRoutes, [], pathData.url.hash)
+      // @modified - end
+    }
 
-      // 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)
+    return undefined
+  }
 
-      if (!intersects) {
-        // NOTE: Adds more context to the error message since we know about the
-        // file-based routing.
-        const last = config.pattern.split('/').pop()
-
-        if (!last?.match(/^\*not-found$/)) {
-          const routeType = last?.startsWith(':')
-            ? 'dynamic route'
-            : last?.startsWith('*')
-              ? 'dynamic-rest route'
-              : 'route'
-
-          throw new Error(
-            `The ${routeType} pattern '${config.pattern || '/'}' resolves to both '${
-              alpha.userReadableName
-            }' and '${
-              config.userReadableName
-            }'. Patterns must be unique and cannot resolve to more than one route.`
-          )
-        }
-      }
+  if (remaining === '/') {
+    // We need to add special handling of empty path so navigation to empty path also works
+    // When handling empty path, we should only look at the root level config
+    // @modified - start
+    // const match = configs.find(
+    //   (config) =>
+    //     config.path === '' &&
+    //     config.routeNames.every(
+    //       // Make sure that none of the parent configs have a non-empty path defined
+    //       (name) => !configs.find((c) => c.screen === name)?.path
+    //     )
+    // )
+    const match = matchForEmptyPath(configWithRegexes)
+    // @modified - end
+
+    if (match) {
+      return createNestedStateObject(
+        pathData, // @modified: pass pathData instead of path
+        match.routeNames.map((name) => ({ name })),
+        initialRoutes,
+        configs
+      )
     }
 
-    return Object.assign(acc, {
-      [indexedKey]: config,
-    })
-  }, {})
-}
+    return undefined
+  }
 
-function sortConfigs(a: RouteConfig, b: RouteConfig): number {
-  // Sort config so that:
-  // - the most exhaustive ones are always at the beginning
-  // - patterns with wildcard are always at the end
+  let result: PartialState<NavigationState> | undefined
+  let current: PartialState<NavigationState> | undefined
 
-  // 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 (a.pattern === b.pattern) {
-    return b.routeNames.join('>').localeCompare(a.routeNames.join('>'))
-  }
+  // 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, configWithRegexes)
 
-  // If one of the patterns starts with the other, it's more exhaustive
-  // So move it up
-  if (
-    a.pattern.startsWith(b.pattern) &&
-    // NOTE: This is a hack to make sure that `*` is always at the end
-    b.screen !== 'index'
-  ) {
-    return -1
+  if (routes !== undefined) {
+    // This will always be empty if full path matched
+    // @modified: pass pathData instead of path
+    current = createNestedStateObject(pathData, routes, initialRoutes, configs)
+    remaining = remainingPath
+    result = current
   }
 
-  if (b.pattern.startsWith(a.pattern) && a.screen !== 'index') {
-    return 1
+  if (current == null || result == null) {
+    return undefined
   }
 
-  // NOTE: Here we append `index` if the screen was `index` so the length is the same
-  // as a slug or wildcard when nested more than one level deep.
-  // This is so we can compare the length of the pattern, e.g. `foo/*` > `foo` vs `*` < ``.
-  const aParts = a.pattern
-    .split('/')
-    // Strip out group names to ensure they don't affect the priority.
-    .filter((part) => matchGroupName(part) == null)
-  if (a.screen === 'index' || a.screen.match(/\/index$/)) {
-    aParts.push('index')
-  }
+  return result
+}
 
-  const bParts = b.pattern.split('/').filter((part) => matchGroupName(part) == null)
-  if (b.screen === 'index' || b.screen.match(/\/index$/)) {
-    bParts.push('index')
-  }
+/**
+ * Reference to the last used config resources. This is used to avoid recomputing the config resources when the options are the same.
+ */
+const cachedConfigResources = new WeakMap<Options<{}>, ConfigResources>()
 
-  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
-    // if b is longer, b get higher priority
-    if (aParts[i] == null) {
-      return 1
-    }
-    // if a is longer, a get higher priority
-    if (bParts[i] == null) {
-      return -1
-    }
+function getConfigResources<ParamList extends {}>(options: Options<ParamList> | undefined) {
+  if (!options) return prepareConfigResources()
 
-    const aWildCard = aParts[i].startsWith('*')
-    const bWildCard = bParts[i].startsWith('*')
-    // if both are wildcard we compare next component
-    if (aWildCard && bWildCard) {
-      const aNotFound = aParts[i].match(/^[*]not-found$/)
-      const bNotFound = bParts[i].match(/^[*]not-found$/)
+  const cached = cachedConfigResources.get(options)
 
-      if (aNotFound && bNotFound) {
-        continue
-      }
-      if (aNotFound) {
-        return 1
-      }
-      if (bNotFound) {
-        return -1
-      }
-      continue
-    }
-    // if only a is wild card, b get higher priority
-    if (aWildCard) {
-      return 1
-    }
-    // if only b is wild card, a get higher priority
-    if (bWildCard) {
-      return -1
-    }
+  if (cached) return cached
 
-    const aSlug = aParts[i].startsWith(':')
-    const bSlug = bParts[i].startsWith(':')
+  const resources = prepareConfigResources(options)
 
-    // if both are wildcard we compare next component
-    if (aSlug && bSlug) {
-      const aNotFound = aParts[i].match(/^[*]not-found$/)
-      const bNotFound = bParts[i].match(/^[*]not-found$/)
+  cachedConfigResources.set(options, resources)
 
-      if (aNotFound && bNotFound) {
-        continue
-      }
-      if (aNotFound) {
-        return 1
-      }
-      if (bNotFound) {
-        return -1
-      }
+  return resources
+}
 
-      continue
-    }
-    // if only a is wild card, b get higher priority
-    if (aSlug) {
-      return 1
-    }
-    // if only b is wild card, a get higher priority
-    if (bSlug) {
-      return -1
-    }
+// @modified: add previousSegments parameter
+function prepareConfigResources(options?: Options<{}>, previousSegments?: string[]) {
+  if (options) {
+    validatePathConfig(options)
   }
 
-  // Sort initial routes with a higher priority than routes which will push more screens
-  // this ensures shared routes go to the shortest path.
-  if (a.isInitial && !b.isInitial) {
-    return -1
-  }
-  if (!a.isInitial && b.isInitial) {
-    return 1
-  }
+  const initialRoutes = getInitialRoutes(options)
 
-  return bParts.length - aParts.length
-}
+  // @modified: pass previousSegments
+  const configs = getNormalizedConfigs(initialRoutes, options?.screens, previousSegments)
 
-function getStateFromEmptyPathWithConfigs(
-  path: string,
-  hash: string,
-  configs: RouteConfig[],
-  initialRoutes: InitialRouteConfig[]
-): OneRouter.ResultState | undefined {
-  // We need to add special handling of empty path so navigation to empty path also works
-  // When handling empty path, we should only look at the root level config
-
-  // NOTE: We only care about matching leaf nodes.
-  const leafNodes = configs
-    .filter((config) => !config.hasChildren)
-    .map((value) => {
-      return {
-        ...value,
-        // Collapse all levels of group segments before testing.
-        // This enables `app/(one)/(two)/index.js` to be matched.
-        path: stripGroupSegmentsFromPath(value.path),
-      }
-    })
+  checkForDuplicatedConfigs(configs)
 
-  const match =
-    leafNodes.find(
-      (config) =>
-        // NOTE: Test leaf node index routes that either don't have a regex or match an empty string.
-        config.path === '' && (!config.regex || config.regex.test(''))
-    ) ??
-    leafNodes.find(
-      (config) =>
-        // NOTE: Test leaf node dynamic routes that match an empty string.
-        config.path.startsWith(':') && config.regex!.test('')
-    ) ??
-    // NOTE: Test leaf node deep dynamic routes that match a slash.
-    // This should be done last to enable dynamic routes having a higher priority.
-    leafNodes.find((config) => config.path.startsWith('*') && config.regex!.test('/'))
-
-  if (!match) {
-    return undefined
+  const configWithRegexes = getConfigsWithRegexes(configs)
+
+  return {
+    initialRoutes,
+    configs,
+    configWithRegexes,
   }
+}
 
-  const routes = match.routeNames.map((name) => {
-    if (!match._route) {
-      return { name }
-    }
-    return {
-      name,
-      _route: match._route,
-    }
-  })
+function getInitialRoutes(options?: Options<{}>) {
+  const initialRoutes: InitialRouteConfig[] = []
 
-  return createNestedStateObject(path, hash, routes, configs, initialRoutes)
+  if (options?.initialRouteName) {
+    initialRoutes.push({
+      initialRouteName: options.initialRouteName,
+      parentScreens: [],
+    })
+  }
+
+  return initialRoutes
 }
 
-function getStateFromPathWithConfigs(
-  path: string,
-  configs: RouteConfig[],
+function getNormalizedConfigs(
   initialRoutes: InitialRouteConfig[],
-  baseUrl: string | undefined = process.env.EXPO_BASE_URL
-): OneRouter.ResultState | undefined {
-  const formattedPaths = getUrlWithReactNavigationConcessions(path)
-
-  if (!formattedPaths.url) {
-    console.warn(`No url found for ${path}`)
-    return
-  }
+  screens: PathConfigMap<object> = {},
+  // @modified - start
+  previousSegments?: string[]
+  // @modified - end
+) {
+  // Create a normalized configs array which will be easier to use
+  return (
+    ([] as RouteConfig[])
+      .concat(
+        ...Object.keys(screens).map((key) =>
+          createNormalizedConfigs(key, screens as PathConfigMap<object>, [], initialRoutes, [])
+        )
+      )
+    /* @modified - start */
+      // .sort((a, b) => {
+      //   // Sort config so that:
+      //   // - the most exhaustive ones are always at the beginning
+      //   // - patterns with wildcard are always at the end
+
+      //   // 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 (a.pattern === b.pattern) {
+      //     return b.routeNames.join('>').localeCompare(a.routeNames.join('>'))
+      //   }
+
+      //   // If one of the patterns starts with the other, it's more exhaustive
+      //   // So move it up
+      //   if (a.pattern.startsWith(b.pattern)) {
+      //     return -1
+      //   }
+
+      //   if (b.pattern.startsWith(a.pattern)) {
+      //     return 1
+      //   }
+
+      //   const aParts = a.pattern.split('/')
+      //   const bParts = b.pattern.split('/')
+
+      //   for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+      //     // if b is longer, b get higher priority
+      //     if (aParts[i] == null) {
+      //       return 1
+      //     }
+      //     // if a is longer, a get higher priority
+      //     if (bParts[i] == null) {
+      //       return -1
+      //     }
+      //     const aWildCard = aParts[i] === '*' || aParts[i].startsWith(':')
+      //     const bWildCard = bParts[i] === '*' || bParts[i].startsWith(':')
+      //     // if both are wildcard we compare next component
+      //     if (aWildCard && bWildCard) {
+      //       continue
+      //     }
+      //     // if only a is wild card, b get higher priority
+      //     if (aWildCard) {
+      //       return 1
+      //     }
+      //     // if only b is wild card, a get higher priority
+      //     if (bWildCard) {
+      //       return -1
+      //     }
+      //   }
+      //   return bParts.length - aParts.length
+      // })
+      .map(appendIsInitial(initialRoutes))
+      .sort(getRouteConfigSorter(previousSegments))
+    /* @modified - end */
+  )
+}
 
-  let cleanPath =
-    stripBaseUrl(stripGroupSegmentsFromPath(formattedPaths.url.pathname), baseUrl) +
-    formattedPaths.url.search
+function checkForDuplicatedConfigs(configs: RouteConfig[]) {
+  // Check for duplicate patterns in the config
+  configs.reduce<Record<string, RouteConfig>>((acc, config) => {
+    if (acc[config.pattern]) {
+      const a = acc[config.pattern].routeNames
+      const b = config.routeNames
 
-  if (!path.startsWith('/')) cleanPath = cleanPath.slice(1)
+      // 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 (formattedPaths.nonstandardPathname === '/') {
-    return getStateFromEmptyPathWithConfigs(
-      cleanPath,
-      formattedPaths.url.hash.slice(1),
-      configs,
-      initialRoutes
-    )
-  }
+      if (!intersects) {
+        throw new Error(
+          `Found conflicting screens with the same pattern. The pattern '${
+            config.pattern
+          }' resolves to both '${a.join(' > ')}' and '${b.join(
+            ' > '
+          )}'. Patterns must be unique and cannot resolve to more than one screen.`
+        )
+      }
+    }
 
-  // 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 = matchAgainstConfigs(formattedPaths.nonstandardPathname, configs)
+    return Object.assign(acc, {
+      [config.pattern]: config,
+    })
+  }, {})
+}
 
-  if (routes == null) {
-    return undefined
-  }
-  // This will always be empty if full path matched
-  return createNestedStateObject(
-    cleanPath,
-    formattedPaths.url.hash.slice(1),
-    routes,
-    configs,
-    initialRoutes
-  )
+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
+    // @modified - start
+    // regex: c.regex ? new RegExp(c.regex.source + '$') : undefined,
+    regex: c.pattern
+      ? new RegExp(`^(${c.pattern.split('/').map(formatRegexPattern).join('')})$`)
+      : undefined,
+    // @modified - end
+  }))
 }
 
 const joinPaths = (...paths: string[]): string =>
@@ -412,10 +368,14 @@ const joinPaths = (...paths: string[]): string =>
     .filter(Boolean)
     .join('/')
 
-function matchAgainstConfigs(remaining: string, configs: RouteConfig[]): ParsedRoute[] | undefined {
+const matchAgainstConfigs = (remaining: string, configs: RouteConfig[]) => {
   let routes: ParsedRoute[] | undefined
   let remainingPath = remaining
 
+  // @modified - start
+  const allParams = Object.create(null)
+  // @modified - end
+
   // Go through all configs, and see if the next path segment matches our regex
   for (const config of configs) {
     if (!config.regex) {
@@ -425,112 +385,104 @@ function matchAgainstConfigs(remaining: string, configs: RouteConfig[]): ParsedR
     const match = remainingPath.match(config.regex)
 
     // If our regex matches, we need to extract params from the path
-    if (!match) {
-      continue
-    }
-
-    // TODO: Add support for wildcard routes
-    const matchedParams = config.pattern
-      ?.split('/')
-      .filter((p) => p.match(/^[:*]/))
-      .reduce<Record<string, any>>((acc, p, i) => {
-        if (p.match(/^\*/)) {
-          return {
-            ...acc,
-            [p]: match![(i + 1) * 2], //?.replace(/\//, ""),
+    if (match) {
+      const matchResult = config.pattern?.split('/').reduce<{
+        pos: number // Position of the current path param segment in the path (e.g in pattern `a/:b/:c`, `:a` is 0 and `:b` is 1)
+        matchedParams: Record<string, Record<string, string>> // The extracted params
+      }>(
+        (acc, p, index) => {
+          if (!p.startsWith(':')) {
+            return acc
           }
-        }
-        return Object.assign(acc, {
-          // The param segments appear every second item starting from 2 in the regex match result.
-          // This will only work if we ensure groups aren't included in the match.
-          [p]: match![(i + 1) * 2]?.replace(/\//, ''),
-        })
-      }, {})
 
-    const routeFromName = (name: string) => {
-      const config = configs.find((c) => c.screen === name)
-      if (!config?.path) {
-        return { name }
-      }
+          // Path parameter so increment position for the segment
+          acc.pos += 1
 
-      const segments = config.path.split('/')
+          const decodedParamSegment = decodeURIComponentSafe(
+            // @modified: use decodeURIComponent**Safe**
+            // The param segments appear every second item starting from 2 in the regex match result
+            match![(acc.pos + 1) * 2]
+              // Remove trailing slash
+              .replace(/\/$/, '')
+          )
 
-      const params: Record<string, any> = {}
+          Object.assign(acc.matchedParams, {
+            [p]: Object.assign(acc.matchedParams[p] || {}, {
+              [index]: decodedParamSegment,
+            }),
+          })
 
-      segments
-        .filter((p) => p.match(/^[:*]/))
-        .forEach((p) => {
-          let value = matchedParams[p]
-          if (value) {
-            if (p.match(/^\*/)) {
-              // Convert to an array before providing as a route.
-              value = value?.split('/').filter(Boolean)
-            }
+          return acc
+        },
+        { pos: -1, matchedParams: {} }
+      )
 
-            const key = p.replace(/^[:*]/, '').replace(/\?$/, '')
-            params[key] = config.parse?.[key] ? config.parse[key](value) : value
-          }
+      const matchedParams = matchResult.matchedParams || {}
+
+      routes = config.routeNames.map((name) => {
+        const routeConfig = configs.find((c) => {
+          // Check matching name AND pattern in case same screen is used at different levels in config
+          return c.screen === name && config.pattern.startsWith(c.pattern)
         })
 
-      if (params && Object.keys(params).length) {
-        return { name, params }
-      }
+        // Normalize pattern to remove any leading, trailing slashes, duplicate slashes etc.
+        const normalizedPath = routeConfig?.path.split('/').filter(Boolean).join('/')
 
-      return { name }
-    }
+        // Get the number of segments in the initial pattern
+        const numInitialSegments = routeConfig?.pattern
+          // Extract the prefix from the pattern by removing the ending path pattern (e.g pattern=`a/b/c/d` and normalizedPath=`c/d` becomes `a/b`)
+          .replace(new RegExp(`${escape(normalizedPath!)}$`), '')
+          ?.split('/').length
 
-    routes = config.routeNames.map((name) => {
-      if (!config._route) {
-        return { ...routeFromName(name) }
-      }
-      return {
-        ...routeFromName(name),
-        _route: config._route,
-      }
-    })
-
-    // TODO: Maybe we should warn / assert if multiple slugs use the same param name.
-    const combinedParams = routes.reduce<Record<string, any>>(
-      (acc, r) => Object.assign(acc, r.params),
-      {}
-    )
+        const params = normalizedPath
+          ?.split('/')
+          .reduce<Record<string, unknown>>((acc, p, index) => {
+            if (!p.startsWith(':')) {
+              return acc
+            }
 
-    const hasCombinedParams = Object.keys(combinedParams).length > 0
+            // Get the real index of the path parameter in the matched path
+            // by offsetting by the number of segments in the initial pattern
+            const offset = numInitialSegments ? numInitialSegments - 1 : 0
+            // @modified - start
+            // const value = matchedParams[p]?.[index + offset]
+            const value = getParamValue(p, matchedParams[p]?.[index + offset])
+            // @modified - end
+
+            if (value) {
+              const key = p.replace(/^:/, '').replace(/\?$/, '')
+              acc[key] = routeConfig?.parse?.[key] ? routeConfig.parse[key](value as any) : value
+            }
 
-    // Combine all params so a route `[foo]/[bar]/other.js` has access to `{ foo, bar }`
-    routes = routes.map((r) => {
-      if (hasCombinedParams) {
-        r.params = combinedParams
-      }
-      return r
-    })
+            return acc
+          }, {})
 
-    remainingPath = remainingPath.replace(match[1], '')
+        if (params && Object.keys(params).length) {
+          return { name, params }
+        }
 
-    break
-  }
+        return { name }
+      })
 
-  return routes
-}
+      remainingPath = remainingPath.replace(match[1], '')
 
-function equalHeritage(a: string[], b: string[]): boolean {
-  if (a.length !== b.length) {
-    return false
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i].localeCompare(b[i]) !== 0) {
-      return false
+      break
     }
   }
-  return true
+
+  // @modified - start
+  populateParams(routes, allParams)
+  // @modified - end
+
+  return { routes, remainingPath }
 }
 
 const createNormalizedConfigs = (
   screen: string,
   routeConfig: PathConfigMap<object>,
   routeNames: string[] = [],
-  initials: InitialRouteConfig[] = [],
-  parentScreens: string[] = [],
+  initials: InitialRouteConfig[],
+  parentScreens: string[],
   parentPattern?: string
 ): RouteConfig[] => {
   const configs: RouteConfig[] = []
@@ -539,19 +491,16 @@ const createNormalizedConfigs = (
 
   parentScreens.push(screen)
 
-  const config = (routeConfig as any)[screen]
+  const config = routeConfig[screen]
 
   if (typeof config === 'string') {
-    // TODO: This should never happen with the addition of `_route`
-
     // If a string is specified as the value of the key(e.g. Foo: '/path'), use it as the pattern
     const pattern = parentPattern ? joinPaths(parentPattern, config) : config
 
-    configs.push(createConfigItem(screen, routeNames, pattern, config, false))
+    configs.push(createConfigItem(screen, routeNames, pattern, config))
   } else if (typeof config === 'object') {
     let pattern: string | undefined
 
-    const { _route } = config
     // 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
@@ -567,17 +516,12 @@ const createNormalizedConfigs = (
           ? joinPaths(parentPattern || '', config.path || '')
           : config.path || ''
 
+      // @modified - start
+      // configs.push(createConfigItem(screen, routeNames, pattern!, config.path, config.parse))
       configs.push(
-        createConfigItem(
-          screen,
-          routeNames,
-          pattern!,
-          config.path,
-          config.screens ? !!Object.keys(config.screens)?.length : false,
-          config.parse,
-          _route
-        )
+        createConfigItem(screen, routeNames, pattern!, config.path, config.parse, config)
       )
+      // @modified - end
     }
 
     if (config.screens) {
@@ -609,44 +553,32 @@ const createNormalizedConfigs = (
   return configs
 }
 
-function formatRegexPattern(it: string): string {
-  // Allow spaces in file path names.
-  it = it.replace(' ', '%20')
-
-  if (it.startsWith(':')) {
-    // TODO: Remove unused match group
-    return `(([^/]+\\/)${it.endsWith('?') ? '?' : ''})`
-  }
-
-  if (it.startsWith('*')) {
-    return `((.*\\/)${it.endsWith('?') ? '?' : ''})`
-  }
-
-  // Strip groups from the matcher
-  if (matchGroupName(it) != null) {
-    // Groups are optional segments
-    // this enables us to match `/bar` and `/(foo)/bar` for the same route
-    // NOTE: Ignore this match in the regex to avoid capturing the group
-    return `(?:${escape(it)}\\/)?`
-  }
-
-  return escape(it) + `\\/`
-}
-
 const createConfigItem = (
   screen: string,
   routeNames: string[],
   pattern: string,
   path: string,
-  hasChildren?: boolean,
-  parse?: ParseConfig,
-  _route?: any
+  parse: ParseConfig | undefined = undefined,
+  // @modified - start
+  config: Record<string, any> = {}
+  // @modified - end
 ): RouteConfig => {
   // Normalize pattern to remove any leading, trailing slashes, duplicate slashes etc.
   pattern = pattern.split('/').filter(Boolean).join('/')
 
   const regex = pattern
-    ? new RegExp(`^(${pattern.split('/').map(formatRegexPattern).join('')})$`)
+    ? new RegExp(
+        `^(${pattern
+          .split('/')
+          .map((it) => {
+            if (it.startsWith(':')) {
+              return `(([^/]+\\/)${it.endsWith('?') ? '?' : ''})`
+            }
+
+            return `${it === '*' ? '.*' : escape(it)}\\/`
+          })
+          .join('')})`
+      )
     : undefined
 
   return {
@@ -657,17 +589,17 @@ const createConfigItem = (
     // The routeNames array is mutated, so copy it to keep the current state
     routeNames: [...routeNames],
     parse,
-    userReadableName: [...routeNames.slice(0, -1), path || screen].join('/'),
-    hasChildren: !!hasChildren,
-    _route,
+    // @modified - start
+    ...createConfigItemAdditionalProperties(screen, pattern, routeNames, config),
+    // @modified - end
   }
 }
 
 const findParseConfigForRoute = (
   routeName: string,
-  routeConfigs: RouteConfig[]
+  flatConfig: RouteConfig[]
 ): ParseConfig | undefined => {
-  for (const config of routeConfigs) {
+  for (const config of flatConfig) {
     if (routeName === config.routeNames[config.routeNames.length - 1]) {
       return config.parse
     }
@@ -683,10 +615,17 @@ const findInitialRoute = (
   initialRoutes: InitialRouteConfig[]
 ): string | undefined => {
   for (const config of initialRoutes) {
-    if (equalHeritage(parentScreens, config.parentScreens)) {
-      // If the parents are the same but the route name doesn't match the initial route
-      // then we return the initial route.
-      return routeName !== config.initialRouteName ? config.initialRouteName : undefined
+    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) {
+          sameParents = false
+          break
+        }
+      }
+      if (sameParents) {
+        return routeName !== config.initialRouteName ? config.initialRouteName : undefined
+      }
     }
   }
   return undefined
@@ -695,9 +634,9 @@ const findInitialRoute = (
 // returns state object with values depending on whether
 // it is the end of state and if there is initialRoute for this level
 const createStateObject = (
+  initialRoute: string | undefined,
   route: ParsedRoute,
-  isEmpty: boolean,
-  initialRoute?: string
+  isEmpty: boolean
 ): InitialState => {
   if (isEmpty) {
     if (initialRoute) {
@@ -705,29 +644,37 @@ const createStateObject = (
         index: 1,
         routes: [{ name: initialRoute }, route],
       }
+      // biome-ignore lint/style/noUselessElse: not changing forked code
+    } else {
+      return {
+        routes: [route],
+      }
     }
-    return {
-      routes: [route],
-    }
-  }
-
-  if (initialRoute) {
-    return {
-      index: 1,
-      routes: [{ name: initialRoute }, { ...route, state: { routes: [] } }],
+    // biome-ignore lint/style/noUselessElse: not changing forked code
+  } else {
+    if (initialRoute) {
+      return {
+        index: 1,
+        routes: [{ name: initialRoute }, { ...route, state: { routes: [] } }],
+      }
+      // biome-ignore lint/style/noUselessElse: not changing forked code
+    } else {
+      return {
+        routes: [{ ...route, state: { routes: [] } }],
+      }
     }
   }
-  return {
-    routes: [{ ...route, state: { routes: [] } }],
-  }
 }
 
 const createNestedStateObject = (
-  path: string,
-  hash: string | undefined,
+  // @modified - start
+  // path: string,
+  { path, ...restPathData }: ReturnType<typeof getUrlWithReactNavigationConcessions>,
+  // @modified - end
   routes: ParsedRoute[],
-  routeConfigs: RouteConfig[],
-  initialRoutes: InitialRouteConfig[]
+  initialRoutes: InitialRouteConfig[],
+  flatConfig?: RouteConfig[],
+  hash?: string // @modified: added
 ) => {
   let route = routes.shift() as ParsedRoute
   const parentScreens: string[] = []
@@ -736,7 +683,7 @@ const createNestedStateObject = (
 
   parentScreens.push(route.name)
 
-  const state: InitialState = createStateObject(route, routes.length === 0, initialRoute)
+  const state: InitialState = createStateObject(initialRoute, route, routes.length === 0)
 
   if (routes.length > 0) {
     let nestedState = state
@@ -747,9 +694,9 @@ const createNestedStateObject = (
       const nestedStateIndex = nestedState.index || nestedState.routes.length - 1
 
       nestedState.routes[nestedStateIndex].state = createStateObject(
+        initialRoute,
         route,
-        routes.length === 0,
-        initialRoute
+        routes.length === 0
       )
 
       if (routes.length > 0) {
@@ -761,81 +708,43 @@ const createNestedStateObject = (
   }
 
   route = findFocusedRoute(state) as ParsedRoute
-
-  // Remove groups from the path while preserving a trailing slash.
-  route.path = path
-
-  const params = parseQueryParams(route.path, findParseConfigForRoute(route.name, routeConfigs))
+  // @modified - start
+  // route.path = path
+  route.path = restPathData.pathWithoutGroups
+  // @modified - end
+
+  // @modified - start
+  // const params = parseQueryParams(
+  //   path,
+  //   flatConfig ? findParseConfigForRoute(route.name, flatConfig) : undefined
+  // )
+  const params = parseQueryParamsExtended(
+    path,
+    route,
+    flatConfig ? findParseConfigForRoute(route.name, flatConfig) : undefined,
+    hash
+  )
+  // @modified - end
 
   if (params) {
-    route.params = Object.assign(Object.create(null), route.params) as Record<string, any>
-    for (const [name, value] of Object.entries(params)) {
-      if (route.params?.[name]) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn(
-            `Route '/${route.name}' with param '${name}' was specified both in the path and as a param, removing from path`
-          )
-        }
-      }
-
-      if (!route.params?.[name]) {
-        route.params[name] = value
-        continue
-      }
-    }
-
-    if (Object.keys(route.params).length === 0) {
-      delete route.params
-    }
-  }
-
-  if (hash) {
-    route.params = Object.assign(Object.create(null), route.params) as Record<string, any>
-    route.params['#'] = hash
+    route.params = { ...route.params, ...params }
   }
 
   return state
 }
 
-const parseQueryParams = (path: string, parseConfig?: Record<string, (value: string) => any>) => {
-  const query = path.split('?')[1]
-  const searchParams = new URLSearchParams(query)
-  const params = Object.fromEntries(
-    // @ts-ignore: [Symbol.iterator] is indeed, available on every platform.
-    searchParams
-  )
-
-  if (parseConfig) {
-    Object.keys(params).forEach((name) => {
-      if (Object.hasOwnProperty.call(parseConfig, name) && typeof params[name] === 'string') {
-        params[name] = parseConfig[name](params[name] as string)
-      }
-    })
-  }
-
-  return Object.keys(params).length ? params : undefined
-}
-
-const baseUrlCache = new Map<string, RegExp>()
-
-function getBaseUrlRegex(baseUrl: string) {
-  if (baseUrlCache.has(baseUrl)) {
-    return baseUrlCache.get(baseUrl)!
-  }
-  const regex = new RegExp(`^\\/?${escape(baseUrl)}`, 'g')
-  baseUrlCache.set(baseUrl, regex)
-  return regex
-}
-
-export function stripBaseUrl(
-  path: string,
-  baseUrl: string | undefined = process.env.EXPO_BASE_URL
-) {
-  if (process.env.NODE_ENV !== 'development') {
-    if (baseUrl) {
-      const reg = getBaseUrlRegex(baseUrl)
-      return path.replace(/^\/+/g, '/').replace(reg, '')
-    }
-  }
-  return path
-}
+// @modified: commenting out unused code
+// const parseQueryParams = (path: string, parseConfig?: Record<string, (value: string) => any>) => {
+//   const query = path.split('?')[1]
+//   const params = queryString.parse(query)
+
+//   if (parseConfig) {
+//     Object.keys(params).forEach((name) => {
+//       if (Object.hasOwnProperty.call(parseConfig, name) && typeof params[name] === 'string') {
+//         params[name] = parseConfig[name](params[name] as string)
+//       }
+//     })
+//   }
+
+//   return Object.keys(params).length ? params : undefined
+// }