one 1.1.389 → 1.1.391

package/src/fork/getPathFromState.ts

@@ -1,19 +1,33 @@
-import { validatePathConfig, type PathConfig, type PathConfigMap } from '@react-navigation/core'
-import type { NavigationState, PartialState, Route } from '@react-navigation/routers'
+/**
+ * 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/getPathFromState.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.
+ */
 
+// @modified - start
 import {
-  matchDeepDynamicRouteName,
-  matchDynamicName,
-  matchGroupName,
-  testNotFound,
-} from '../matchers'
+  type ConfigItemMods,
+  getPathWithConventionsCollapsed,
+  appendBaseUrl,
+  type AdditionalOptions,
+} from './getPathFromState-mods'
+// @modified - end
 
-type Options<ParamList extends object> = {
+import type { NavigationState, PartialState, Route } from '@react-navigation/routers'
+// import * as queryString from 'query-string' // @modified: not used
+
+import type { PathConfig, PathConfigMap } from '@react-navigation/core' // @modified: import from package instead of relative code
+import { validatePathConfig } from './validatePathConfig'
+
+type Options<ParamList extends {}> = {
+  path?: string
   initialRouteName?: string
   screens: PathConfigMap<ParamList>
-}
+} & AdditionalOptions // @modified: add `AdditionalOptions`
 
-export type State = NavigationState | Omit<PartialState<NavigationState>, 'stale'>
+export type State = NavigationState | Omit<PartialState<NavigationState>, 'stale'> // @modified: add export
 
 type StringifyConfig = Record<string, (value: any) => string>
 
@@ -21,15 +35,7 @@ type ConfigItem = {
   pattern?: string
   stringify?: StringifyConfig
   screens?: Record<string, ConfigItem>
-  // Used as fallback for groups
-  initialRouteName?: string
-}
-
-type CustomRoute = Route<string> & {
-  state?: State
-}
-
-const DEFAULT_SCREENS: PathConfigMap<object> = {}
+} & ConfigItemMods // @modified: union `ConfigItemMods` for modifications
 
 const getActiveRoute = (state: State): { name: string; params?: object } => {
   const route =
@@ -41,44 +47,26 @@ const getActiveRoute = (state: State): { name: string; params?: object } => {
     return getActiveRoute(route.state)
   }
 
-  if (route && isInvalidParams(route.params)) {
-    return getActiveRoute(createFakeState(route.params))
-  }
-
   return route
 }
 
-function createFakeState(params: StateAsParams) {
-  return {
-    stale: false,
-    type: 'UNKNOWN',
-    key: 'UNKNOWN',
-    index: 0,
-    routeNames: [],
-    routes: [
-      {
-        key: 'UNKNOWN',
-        name: params.screen,
-        params: params.params,
-        path: params.path,
-      },
-    ],
-  }
-}
+const cachedNormalizedConfigs = new WeakMap<PathConfigMap<{}>, Record<string, ConfigItem>>()
 
-function segmentMatchesConvention(segment: string): boolean {
-  return (
-    segment === 'index' ||
-    matchDynamicName(segment) != null ||
-    matchGroupName(segment) != null ||
-    matchDeepDynamicRouteName(segment) != null
-  )
-}
+const getNormalizedConfigs = (options?: Options<{}>) => {
+  if (!options?.screens) return {}
+
+  const cached = cachedNormalizedConfigs.get(options?.screens)
+
+  if (cached) return cached
 
-function encodeURIComponentPreservingBrackets(str: string) {
-  return encodeURIComponent(str).replace(/%5B/g, '[').replace(/%5D/g, ']')
+  const normalizedConfigs = createNormalizedConfigs(options.screens)
+
+  cachedNormalizedConfigs.set(options.screens, normalizedConfigs)
+
+  return normalizedConfigs
 }
 
+// @modified - start: extract an underlying `getPathDataFromState` function so we can get both the path and the params
 /**
  * Utility to serialize a navigation state object to a path string.
  *
@@ -108,513 +96,273 @@ function encodeURIComponentPreservingBrackets(str: string) {
  * @param options Extra options to fine-tune how to serialize the path.
  * @returns Path representing the state, e.g. /foo/bar?count=42.
  */
-export default function getPathFromState<ParamList extends object>(
+export function getPathFromState<ParamList extends {}>(
   state: State,
-  _options?: Options<ParamList> & {
-    preserveGroups?: boolean
-    preserveDynamicRoutes?: boolean
-  }
+  options?: Options<ParamList>
 ): string {
-  return getPathDataFromState(state, _options).path
+  return getPathDataFromState(state, options).path
 }
 
-export function getPathDataFromState<ParamList extends object>(
+export function getPathDataFromState<ParamList extends {}>(
   state: State,
-  _options: Options<ParamList> & {
-    preserveGroups?: boolean
-    preserveDynamicRoutes?: boolean
-  } = { screens: DEFAULT_SCREENS }
+  options?: Options<ParamList>
 ) {
+  // @modified - end
+
   if (state == null) {
     throw Error("Got 'undefined' for the navigation state. You must pass a valid state object.")
   }
 
-  const { preserveGroups, preserveDynamicRoutes, ...options } = _options
-
-  validatePathConfig(options)
-
-  // One disallows usage without a linking config.
-  if (Object.is(options.screens, DEFAULT_SCREENS)) {
-    throw Error("You must pass a 'screens' object to 'getPathFromState' to generate a path.")
+  if (options) {
+    validatePathConfig(options)
   }
 
-  return getPathFromResolvedState(
-    state,
-    // Create a normalized configs object which will be easier to use
-    createNormalizedConfigs(options.screens),
-    { preserveGroups, preserveDynamicRoutes }
-  )
-}
+  const configs = getNormalizedConfigs(options)
 
-function processParamsWithUserSettings(configItem: ConfigItem, params: Record<string, any>) {
-  const stringify = configItem?.stringify
-
-  return Object.fromEntries(
-    Object.entries(params).map(([key, value]) => [
-      key,
-      // TODO: Strip nullish values here.
-      stringify?.[key]
-        ? stringify[key](value)
-        : // Preserve rest params
-          Array.isArray(value)
-          ? value
-          : String(value),
-    ])
-  )
-}
+  let path = '/'
+  let current: State | undefined = state
 
-export function deepEqual(a: any, b: any) {
-  if (a === b) {
-    return true
-  }
+  const allParams: Record<string, any> = {}
 
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return false
+  while (current) {
+    let index = typeof current.index === 'number' ? current.index : 0
+    let route = current.routes[index] as Route<string> & {
+      state?: State
     }
 
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) {
-        return false
-      }
-    }
+    let pattern: string | undefined
 
-    return true
-  }
+    let focusedParams: Record<string, any> | undefined // @modified: value change to any type
+    const focusedRoute = getActiveRoute(state)
+    let currentOptions = configs
 
-  if (typeof a === 'object' && typeof b === 'object') {
-    const keysA = Object.keys(a)
-    const keysB = Object.keys(b)
+    // Keep all the route names that appeared during going deeper in config in case the pattern is resolved to undefined
+    const nestedRouteNames: string[] = [] // @modified: add type annotation
 
-    if (keysA.length !== keysB.length) {
-      return false
-    }
+    let hasNext = true
 
-    for (const key of keysA) {
-      if (!deepEqual(a[key], b[key])) {
-        return false
-      }
-    }
+    while (route.name in currentOptions && hasNext) {
+      pattern = currentOptions[route.name].pattern
 
-    return true
-  }
+      nestedRouteNames.push(route.name)
 
-  return false
-}
+      if (route.params) {
+        const stringify = currentOptions[route.name]?.stringify
 
-function walkConfigItems(
-  route: CustomRoute,
-  focusedRoute: {
-    name: string
-    params?: object
-  },
-  configs: Record<string, ConfigItem>,
-  {
-    preserveDynamicRoutes,
-  }: {
-    preserveDynamicRoutes?: boolean
-  }
-) {
-  // NOTE: Fill in current route using state that was passed as params.
-  if (!route.state && isInvalidParams(route.params)) {
-    // FIXME: This is a hack to make things work since the `route` object is immutable on react-navigation v7 (`TypeError: Cannot add property state, object is not extensible`), and seems that things are working. But we might want to do a proper migration for these forked code.
-    // route.state = createFakeState(route.params)
-  }
+        // @modified - start
 
-  let pattern: string | null = null
-  let focusedParams: Record<string, any> | undefined
-  let hash: string | undefined
+        // const currentParams = Object.fromEntries(
+        //   Object.entries(route.params).map(([key, value]) => [
+        //     key,
+        //     stringify?.[key] ? stringify[key](value) : String(value),
+        //   ])
+        // )
 
-  const collectedParams: Record<string, any> = {}
+        // Better handle array params
+        const currentParams = Object.fromEntries(
+          Object.entries(route.params!).flatMap(([key, value]) => {
+            if (key === 'screen' || key === 'params') {
+              return []
+            }
 
-  while (route.name in configs) {
-    const configItem = configs[route.name]
-    const inputPattern = configItem.pattern
+            return [
+              [
+                key,
+                stringify?.[key]
+                  ? stringify[key](value)
+                  : Array.isArray(value)
+                    ? value.map(String)
+                    : String(value),
+              ],
+            ]
+          })
+        )
 
-    if (inputPattern == null) {
-      // This should never happen in One.
-      throw new Error('Unexpected: No pattern found for route ' + route.name)
-    }
-    pattern = inputPattern
+        // @modified - end
 
-    if (route.params) {
-      if (route.params['#']) {
-        hash = route.params['#']
-        delete route.params['#']
-      }
+        // @modified - start
 
-      const params = processParamsWithUserSettings(configItem, route.params)
+        // if (pattern) {
+        //   Object.assign(allParams, currentParams)
+        // }
 
-      if (pattern !== undefined && pattern !== null) {
-        Object.assign(collectedParams, params)
-      }
+        // Always assign params, as non pattern routes may still have query params
+        Object.assign(allParams, currentParams)
 
-      if (deepEqual(focusedRoute, route)) {
-        if (preserveDynamicRoutes) {
-          focusedParams = params
-        } else {
+        // @modified - end
+
+        if (focusedRoute === route) {
           // If this is the focused route, keep the params for later use
           // We save it here since it's been stringified already
-          focusedParams = getParamsWithConventionsCollapsed({
-            params,
-            pattern,
-            routeName: route.name,
-          })
+          focusedParams = { ...currentParams }
+
+          pattern
+            ?.split('/')
+            .filter((p) => p.startsWith(':'))
+            // eslint-disable-next-line no-loop-func
+            .forEach((p) => {
+              const name = getParamName(p)
+
+              // Remove the params present in the pattern since we'll only use the rest for query string
+              if (focusedParams) {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete focusedParams[name]
+              }
+            })
         }
       }
-    }
 
-    if (!route.state && isInvalidParams(route.params)) {
-      // FIXME: This is a hack to make things work since the `route` object is immutable on react-navigation v7, and seems that things are working. But we might want to do a proper migration for these forked code.
-      // route.state = createFakeState(route.params)
-    }
-
-    // If there is no `screens` property or no nested state, we return pattern
-    if (!configItem.screens || route.state === undefined) {
-      if (
-        configItem.initialRouteName &&
-        configItem.screens &&
-        configItem.initialRouteName in configItem.screens &&
-        configItem.screens[configItem.initialRouteName]?.pattern
-      ) {
-        const initialRouteConfig = configItem.screens[configItem.initialRouteName]
-
-        // NOTE: Big hack to support initial route changes in tab bars.
-        pattern = initialRouteConfig.pattern!
-        if (focusedParams) {
-          if (!preserveDynamicRoutes) {
-            // If this is the focused route, keep the params for later use
-            // We save it here since it's been stringified already
-            focusedParams = getParamsWithConventionsCollapsed({
-              params: focusedParams,
-              pattern,
-              routeName: route.name,
-            })
-          }
+      // If there is no `screens` property or no nested state, we return pattern
+      if (!currentOptions[route.name].screens || route.state === undefined) {
+        // @modified - start
+
+        // hasNext = false
+
+        // One can end up in some configs that React Navigation doesn't seem to support
+        // We can get around this by providing a fake state
+        const screens = currentOptions[route.name].screens
+        const screen =
+          route.params && 'screen' in route.params
+            ? route.params.screen?.toString()
+            : screens
+              ? Object.keys(screens)[0]
+              : undefined
+
+        if (screen && screens && currentOptions[route.name].screens?.[screen]) {
+          route = { ...screens[screen], name: screen, key: screen }
+          currentOptions = screens
+        } else {
+          hasNext = false
         }
-      }
-      break
-    }
 
-    const index = route.state.index ?? route.state.routes.length - 1
+        // @modified - end
+      } else {
+        index =
+          typeof route.state.index === 'number' ? route.state.index : route.state.routes.length - 1
 
-    const nextRoute = route.state.routes[index]
-    const nestedScreens = configItem.screens
+        const nextRoute = route.state.routes[index]
+        const nestedConfig = currentOptions[route.name].screens
 
-    // if there is config for next route name, we go deeper
-    if (nestedScreens && nextRoute.name in nestedScreens) {
-      route = nextRoute as CustomRoute
-      configs = nestedScreens
-    } else {
-      // If not, there is no sense in going deeper in config
-      break
+        // if there is config for next route name, we go deeper
+        if (nestedConfig && nextRoute.name in nestedConfig) {
+          route = nextRoute as Route<string> & { state?: State }
+          currentOptions = nestedConfig
+        } else {
+          // If not, there is no sense in going deeper in config
+          hasNext = false
+        }
+      }
     }
-  }
 
-  if (pattern == null) {
-    throw new Error(
-      `No pattern found for route "${route.name}". Options are: ${Object.keys(configs).join(', ')}.`
-    )
-  }
+    // @modified - start
+    if (currentOptions[route.name] !== undefined) {
+      // path += pattern
+      //   .split('/')
+      //   .map((p) => {
+      //     const name = getParamName(p)
+
+      //     // We don't know what to show for wildcard patterns
+      //     // Showing the route name seems ok, though whatever we show here will be incorrect
+      //     // Since the page doesn't actually exist
+      //     if (p === '*') {
+      //       return route.name
+      //     }
+
+      //     // If the path has a pattern for a param, put the param in the path
+      //     if (p.startsWith(':')) {
+      //       const value = allParams[name]
+
+      //       if (value === undefined && p.endsWith('?')) {
+      //         // Optional params without value assigned in route.params should be ignored
+      //         return ''
+      //       }
+
+      //       // Valid characters according to
+      //       // https://datatracker.ietf.org/doc/html/rfc3986#section-3.3 (see pchar definition)
+      //       return String(value).replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]/g, (char) =>
+      //         encodeURIComponent(char)
+      //       )
+      //     }
+
+      //     return encodeURIComponent(p)
+      //   })
+      //   .join('/')
+
+      if (pattern === undefined) {
+        pattern = nestedRouteNames.join('/')
+      }
 
-  if (pattern && !focusedParams && focusedRoute.params) {
-    if (preserveDynamicRoutes) {
-      focusedParams = focusedRoute.params
-    } else {
-      // If this is the focused route, keep the params for later use
-      // We save it here since it's been stringified already
-      focusedParams = getParamsWithConventionsCollapsed({
-        params: focusedRoute.params,
+      path += getPathWithConventionsCollapsed({
+        ...options,
         pattern,
-        routeName: route.name,
+        route,
+        params: allParams,
+        initialRouteName: configs[route.name]?.initialRouteName,
       })
-    }
-    focusedParams = {
-      ...focusedParams,
-      ...collectedParams,
-    }
-  }
-
-  return {
-    pattern,
-    nextRoute: route,
-    focusedParams,
-    hash,
-    params: collectedParams,
-  }
-}
-
-function getPathFromResolvedState(
-  state: State,
-  configs: Record<string, ConfigItem>,
-  {
-    preserveGroups,
-    preserveDynamicRoutes,
-  }: { preserveGroups?: boolean; preserveDynamicRoutes?: boolean }
-) {
-  let path = ''
-  let current: State = state
-  let hash: string | undefined
-
-  const allParams: Record<string, any> = {}
-
-  while (current) {
-    path += '/'
-
-    // Make mutable copies to ensure we don't leak state outside of the function.
-    const route = current.routes[current.index ?? 0] as CustomRoute
 
-    // NOTE: Fill in current route using state that was passed as params.
-    // if (isInvalidParams(route.params)) {
-    if (!route.state && isInvalidParams(route.params)) {
-      // FIXME: This is a hack to make things work since the `route` object is immutable on react-navigation v7, and seems that things are working. But we might want to do a proper migration for these forked code.
-      // route.state = createFakeState(route.params)
+      // } else {
+    } else if (!route.name.startsWith('+')) {
+      path += encodeURIComponent(route.name)
     }
+    // @modified - end
 
-    const {
-      pattern,
-      params,
-      nextRoute,
-      focusedParams,
-      hash: $hash,
-    } = walkConfigItems(route, getActiveRoute(current), { ...configs }, { preserveDynamicRoutes })
-
-    if ($hash) {
-      hash = $hash
+    if (!focusedParams) {
+      focusedParams = focusedRoute.params
     }
 
-    Object.assign(allParams, params)
-
-    path += getPathWithConventionsCollapsed({
-      pattern,
-      routePath: nextRoute.path,
-      params: allParams,
-      initialRouteName: configs[nextRoute.name]?.initialRouteName,
-      preserveGroups,
-      preserveDynamicRoutes,
-    })
-
-    if (
-      nextRoute.state &&
-      // NOTE: The upstream implementation allows for sending in synthetic states (states that weren't generated by `getStateFromPath`)
-      // and any invalid routes will simply be ignored.
-      // Because of this, we need to check if the next route is valid before continuing, otherwise our more strict
-      // implementation will throw an error.
-      configs[nextRoute.state.routes?.[nextRoute.state?.index ?? 0]?.name]
-    ) {
-      // Continue looping with the next state if available.
-      current = nextRoute.state
-    } else {
-      // Finished crawling state.
-
-      // Check for query params before exiting.
-      if (
-        focusedParams &&
-        // note: using [...route] is returning an array which shouldn't go on search, this is just
-        // an initial hacky test to work around this as we dont want to pass that to search
-        !Array.isArray(focusedParams)
-      ) {
-        for (const param in focusedParams) {
-          // TODO: This is not good. We shouldn't squat strings named "undefined".
-          if (focusedParams[param] === 'undefined') {
-            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-            delete focusedParams[param]
-          }
-        }
-
-        const query = new URLSearchParams(focusedParams).toString()
-        if (query) {
-          path += `?${query}`
+    if (route.state) {
+      path += '/'
+    } else if (focusedParams) {
+      for (const param in focusedParams) {
+        if (focusedParams[param] === 'undefined') {
+          // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+          delete focusedParams[param]
         }
       }
-      break
-    }
-  }
-
-  if (hash) {
-    allParams['#'] = hash
-    path += `#${hash}`
-  }
 
-  const params = decodeParams(allParams)
+      // @modified - start
+      delete focusedParams['#']
+      // @modified - end
 
-  return { path: appendBaseUrl(basicSanitizePath(path)), params }
-}
-
-function decodeParams(params: Record<string, string>) {
-  const parsed: Record<string, any> = {}
+      // @modified - start
+      // const query = queryString.stringify(focusedParams, { sort: false })
+      const query = new URLSearchParams(focusedParams).toString()
+      // @modified - end
 
-  for (const [key, value] of Object.entries(params)) {
-    try {
-      if (Array.isArray(value)) {
-        parsed[key] = value.map((v) => decodeURIComponent(v))
-      } else {
-        parsed[key] = decodeURIComponent(value)
+      if (query) {
+        path += `?${query}`
       }
-    } catch {
-      parsed[key] = value
     }
-  }
 
-  return parsed
-}
-
-function getPathWithConventionsCollapsed({
-  pattern,
-  routePath,
-  params,
-  preserveGroups,
-  preserveDynamicRoutes,
-  initialRouteName,
-}: {
-  pattern: string
-  routePath?: string
-  params: Record<string, any>
-  preserveGroups?: boolean
-  preserveDynamicRoutes?: boolean
-  initialRouteName?: string
-}) {
-  const segments = pattern.split('/')
-  return segments
-    .map((p, i) => {
-      const name = getParamName(p)
-
-      // We don't know what to show for wildcard patterns
-      // Showing the route name seems ok, though whatever we show here will be incorrect
-      // Since the page doesn't actually exist
-      if (p.startsWith('*')) {
-        if (preserveDynamicRoutes) {
-          if (name === 'not-found') {
-            return '+not-found'
-          }
-          return `[...${name}]`
-        }
-        if (params[name]) {
-          if (Array.isArray(params[name])) {
-            return params[name].join('/')
-          }
-          return params[name]
-        }
-        if (i === 0) {
-          // This can occur when a wildcard matches all routes and the given path was `/`.
-          return routePath
-        }
-        // remove existing segments from route.path and return it
-        // this is used for nested wildcard routes. Without this, the path would add
-        // all nested segments to the beginning of the wildcard route.
-        return routePath
-          ?.split('/')
-          .slice(i + 1)
-          .join('/')
-      }
-
-      // If the path has a pattern for a param, put the param in the path
-      if (p.startsWith(':')) {
-        if (preserveDynamicRoutes) {
-          return `[${name}]`
-        }
-        // Optional params without value assigned in route.params should be ignored
-        return params[name]
-      }
-
-      if (!preserveGroups && matchGroupName(p) != null) {
-        // When the last part is a group it could be a shared URL
-        // if the route has an initialRouteName defined, then we should
-        // use that as the component path as we can assume it will be shown.
-        if (segments.length - 1 === i) {
-          if (initialRouteName) {
-            // Return an empty string if the init route is ambiguous.
-            if (segmentMatchesConvention(initialRouteName)) {
-              return ''
-            }
-            return encodeURIComponentPreservingBrackets(initialRouteName)
-          }
-        }
-        return ''
-      }
-      // Preserve dynamic syntax for rehydration
-      return encodeURIComponentPreservingBrackets(p)
-    })
-    .map((v) => v ?? '')
-    .join('/')
-}
-
-/** Given a set of query params and a pattern with possible conventions, collapse the conventions and return the remaining params. */
-function getParamsWithConventionsCollapsed({
-  pattern,
-  routeName,
-  params,
-}: {
-  pattern: string
-  /** Route name is required for matching the wildcard route. This is specific to One. */
-  routeName: string
-  params: object
-}): Record<string, string> {
-  const processedParams: Record<string, string> = { ...params }
-
-  // Remove the params present in the pattern since we'll only use the rest for query string
-
-  const segments = pattern.split('/')
-
-  // Dynamic Routes
-  segments
-    .filter((segment) => segment.startsWith(':'))
-    .forEach((segment) => {
-      const name = getParamName(segment)
-      delete processedParams[name]
-    })
-
-  // Deep Dynamic Routes
-  if (segments.some((segment) => segment.startsWith('*'))) {
-    // NOTE: Drop the param name matching the wildcard route name -- this is specific to One.
-    const name = testNotFound(routeName)
-      ? 'not-found'
-      : (matchDeepDynamicRouteName(routeName) ?? routeName)
-
-    delete processedParams[name]
+    current = route.state
   }
 
-  return processedParams
-}
+  // Remove multiple as well as trailing slashes
+  path = path.replace(/\/+/g, '/')
+  path = path.length > 1 ? path.replace(/\/$/, '') : path
 
-// Remove multiple as well as trailing slashes
-function basicSanitizePath(path: string) {
-  // Remove duplicate slashes like `foo//bar` -> `foo/bar`
-  const simplifiedPath = path.replace(/\/+/g, '/')
-  if (simplifiedPath.length <= 1) {
-    return simplifiedPath
+  // Include the root path if specified
+  if (options?.path) {
+    path = joinPaths(options.path, path)
   }
-  // Remove trailing slash like `foo/bar/` -> `foo/bar`
-  return simplifiedPath.replace(/\/$/, '')
-}
 
-type StateAsParams = {
-  initial: boolean
-  path?: string
-  screen: string
-  params: Record<string, any>
-}
+  // @modified - start
+  path = appendBaseUrl(path)
+  // @modified - end
 
-// TODO: Make StackRouter not do this...
-// Detect if the params came from StackRouter using `params` to pass around internal state.
-function isInvalidParams(params?: Record<string, any>): params is StateAsParams {
-  if (!params) {
-    return false
+  // @modified - start
+  if (allParams['#']) {
+    path += `#${allParams['#']}`
   }
+  // @modified - end
 
-  if ('params' in params && typeof params.params === 'object' && !!params.params) {
-    return true
-  }
-
-  return (
-    'initial' in params &&
-    typeof params.initial === 'boolean' &&
-    // "path" in params &&
-    'screen' in params
-  )
+  // @modified - start
+  // return path
+  return { path, params: allParams }
+  // @modified - end
 }
 
-const getParamName = (pattern: string) => pattern.replace(/^[:*]/, '').replace(/\?$/, '')
+const getParamName = (pattern: string) => pattern.replace(/^:/, '').replace(/\?$/, '')
 
 const joinPaths = (...paths: string[]): string =>
   ([] as string[])
@@ -651,7 +399,6 @@ const createConfigItem = (
     pattern: pattern?.split('/').filter(Boolean).join('/'),
     stringify: config.stringify,
     screens,
-    initialRouteName: config.initialRouteName,
   }
 }
 
@@ -660,17 +407,13 @@ const createNormalizedConfigs = (
   pattern?: string
 ): Record<string, ConfigItem> =>
   Object.fromEntries(
-    Object.entries(options).map(([name, c]) => [name, createConfigItem(c, pattern)])
+    Object.entries(options).map(([name, c]) => {
+      const result = createConfigItem(c, pattern)
+
+      return [name, result]
+    })
   )
 
-export function appendBaseUrl(
-  path: string,
-  baseUrl: string | undefined = process.env.EXPO_BASE_URL
-) {
-  if (process.env.NODE_ENV !== 'development') {
-    if (baseUrl) {
-      return `/${baseUrl.replace(/^\/+/, '').replace(/\/$/, '')}${path}`
-    }
-  }
-  return path
-}
+// @modified - start
+export default getPathFromState
+// @modified - end