@tanstack/react-router 1.22.5 → 1.22.6

package/src/router.ts

@@ -1,76 +1,80 @@
-import * as React from 'react'
+import { createBrowserHistory, createMemoryHistory } from '@tanstack/history'
+import { Store } from '@tanstack/react-store'
+import invariant from 'tiny-invariant'
+import warning from 'tiny-warning'
+import { rootRouteId } from './route'
+import { defaultParseSearch, defaultStringifySearch } from './searchParams'
+import {
+  deepEqual,
+  escapeJSON,
+  functionalUpdate,
+  isServer,
+  last,
+  pick,
+  replaceEqualDeep,
+} from './utils'
+import { getRouteMatch } from './RouterProvider'
 import {
+  cleanPath,
+  interpolatePath,
+  joinPaths,
+  matchPathname,
+  parsePathname,
+  resolvePath,
+  trimPath,
+  trimPathLeft,
+  trimPathRight,
+} from './path'
+import { isRedirect } from './redirects'
+import { isNotFound } from './not-found'
+import type * as React from 'react'
+import type {
   HistoryLocation,
   HistoryState,
   RouterHistory,
-  createBrowserHistory,
-  createMemoryHistory,
 } from '@tanstack/history'
-import { Store } from '@tanstack/react-store'
 
 //
 
-import {
-  AnySearchSchema,
-  AnyRoute,
+import type {
   AnyContext,
-  RouteMask,
-  Route,
+  AnyRoute,
+  AnySearchSchema,
   LoaderFnContext,
-  rootRouteId,
   NotFoundRouteComponent,
+  Route,
+  RouteMask,
 } from './route'
-import {
+import type {
   FullSearchSchema,
   RouteById,
   RoutePaths,
   RoutesById,
   RoutesByPath,
 } from './routeInfo'
-import { defaultParseSearch, defaultStringifySearch } from './searchParams'
-import {
-  PickAsRequired,
-  Updater,
+import type {
   NonNullableUpdater,
-  replaceEqualDeep,
-  deepEqual,
-  escapeJSON,
-  functionalUpdate,
-  last,
-  pick,
+  PickAsRequired,
   Timeout,
-  isServer,
+  Updater,
 } from './utils'
-import { RouteComponent } from './route'
-import { AnyRouteMatch, MatchRouteOptions, RouteMatch } from './Matches'
-import { ParsedLocation } from './location'
-import { SearchSerializer, SearchParser } from './searchParams'
-import {
+import type { RouteComponent } from './route'
+import type { AnyRouteMatch, MatchRouteOptions, RouteMatch } from './Matches'
+import type { ParsedLocation } from './location'
+import type { SearchParser, SearchSerializer } from './searchParams'
+import type {
   BuildLocationFn,
   CommitLocationOptions,
   InjectedHtmlEntry,
   NavigateFn,
-  getRouteMatch,
 } from './RouterProvider'
 
-import {
-  cleanPath,
-  interpolatePath,
-  joinPaths,
-  matchPathname,
-  parsePathname,
-  resolvePath,
-  trimPath,
-  trimPathLeft,
-  trimPathRight,
-} from './path'
-import invariant from 'tiny-invariant'
-import { AnyRedirect, ResolvedRedirect, isRedirect } from './redirects'
-import { NotFoundError, isNotFound } from './not-found'
-import { NavigateOptions, ResolveRelativePath, ToOptions } from './link'
-import { NoInfer } from '@tanstack/react-store'
-import warning from 'tiny-warning'
-import { DeferredPromiseState } from './defer'
+import type { AnyRedirect, ResolvedRedirect } from './redirects'
+
+import type { NotFoundError } from './not-found'
+import type { NavigateOptions, ResolveRelativePath, ToOptions } from './link'
+import type { NoInfer } from '@tanstack/react-store'
+import type { DeferredPromiseState } from './defer'
 
 //
 
@@ -133,7 +137,7 @@ export interface RouterOptions<
   context?: TRouteTree['types']['routerContext']
   dehydrate?: () => TDehydrated
   hydrate?: (dehydrated: TDehydrated) => void
-  routeMasks?: RouteMask<TRouteTree>[]
+  routeMasks?: Array<RouteMask<TRouteTree>>
   unmaskOnReload?: boolean
   Wrap?: (props: { children: any }) => React.ReactNode
   InnerWrap?: (props: { children: any }) => React.ReactNode
@@ -161,9 +165,9 @@ export interface RouterState<TRouteTree extends AnyRoute = AnyRoute> {
   status: 'pending' | 'idle'
   isLoading: boolean
   isTransitioning: boolean
-  matches: RouteMatch<TRouteTree>[]
-  pendingMatches?: RouteMatch<TRouteTree>[]
-  cachedMatches: RouteMatch<TRouteTree>[]
+  matches: Array<RouteMatch<TRouteTree>>
+  pendingMatches?: Array<RouteMatch<TRouteTree>>
+  cachedMatches: Array<RouteMatch<TRouteTree>>
   location: ParsedLocation<FullSearchSchema<TRouteTree>>
   resolvedLocation: ParsedLocation<FullSearchSchema<TRouteTree>>
   lastUpdated: number
@@ -191,7 +195,7 @@ export interface BuildNextOptions {
 }
 
 export interface DehydratedRouterState {
-  dehydratedMatches: DehydratedRouteMatch[]
+  dehydratedMatches: Array<DehydratedRouteMatch>
 }
 
 export type DehydratedRouteMatch = Pick<
@@ -264,11 +268,11 @@ export class Router<
   tempLocationKey: string | undefined = `${Math.round(
     Math.random() * 10000000,
   )}`
-  resetNextScroll: boolean = true
+  resetNextScroll = true
   navigateTimeout: Timeout | null = null
   latestLoadPromise: Promise<void> = Promise.resolve()
   subscribers = new Set<RouterListener<RouterEvent>>()
-  injectedHtml: InjectedHtmlEntry[] = []
+  injectedHtml: Array<InjectedHtmlEntry> = []
   dehydratedData?: TDehydrated
 
   // Must build in constructor
@@ -288,7 +292,7 @@ export class Router<
   routeTree!: TRouteTree
   routesById!: RoutesById<TRouteTree>
   routesByPath!: RoutesByPath<TRouteTree>
-  flatRoutes!: AnyRoute[]
+  flatRoutes!: Array<AnyRoute>
 
   /**
    * @deprecated Use the `createRouter` function instead
@@ -306,9 +310,9 @@ export class Router<
       defaultPendingMinMs: 500,
       context: undefined!,
       ...options,
-      stringifySearch: options?.stringifySearch ?? defaultStringifySearch,
-      parseSearch: options?.parseSearch ?? defaultParseSearch,
-      transformer: options?.transformer ?? JSON,
+      stringifySearch: options.stringifySearch ?? defaultStringifySearch,
+      parseSearch: options.parseSearch ?? defaultParseSearch,
+      transformer: options.transformer ?? JSON,
     })
 
     if (typeof document !== 'undefined') {
@@ -356,6 +360,7 @@ export class Router<
     }
 
     if (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       !this.history ||
       (this.options.history && this.options.history !== this.history)
     ) {
@@ -374,6 +379,7 @@ export class Router<
       this.buildRouteTree()
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!this.__store) {
       this.__store = new Store(getInitialRouterState(this.latestLocation), {
         onUpdate: () => {
@@ -406,7 +412,7 @@ export class Router<
       ;(this.routesById as any)[notFoundRoute.id] = notFoundRoute
     }
 
-    const recurseRoutes = (childRoutes: AnyRoute[]) => {
+    const recurseRoutes = (childRoutes: Array<AnyRoute>) => {
       childRoutes.forEach((childRoute, i) => {
         childRoute.init({ originalIndex: i })
 
@@ -428,7 +434,7 @@ export class Router<
           }
         }
 
-        const children = childRoute.children as Route[]
+        const children = childRoute.children
 
         if (children?.length) {
           recurseRoutes(children)
@@ -438,15 +444,18 @@ export class Router<
 
     recurseRoutes([this.routeTree])
 
-    const scoredRoutes: {
+    const scoredRoutes: Array<{
       child: AnyRoute
       trimmed: string
       parsed: ReturnType<typeof parsePathname>
       index: number
-      scores: number[]
-    }[] = []
+      scores: Array<number>
+    }> = []
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    const routes = Object.values(this.routesById) as Array<AnyRoute>
 
-    ;(Object.values(this.routesById) as AnyRoute[]).forEach((d, i) => {
+    routes.forEach((d, i) => {
       if (d.isRoot || !d.path) {
         return
       }
@@ -458,16 +467,16 @@ export class Router<
         parsed.shift()
       }
 
-      const scores = parsed.map((d) => {
-        if (d.value === '/') {
+      const scores = parsed.map((segment) => {
+        if (segment.value === '/') {
           return 0.75
         }
 
-        if (d.type === 'param') {
+        if (segment.type === 'param') {
           return 0.5
         }
 
-        if (d.type === 'wildcard') {
+        if (segment.type === 'wildcard') {
           return 0.25
         }
 
@@ -496,7 +505,7 @@ export class Router<
         // Sort by min available parsed value
         for (let i = 0; i < minLength; i++) {
           if (a.parsed[i]!.value !== b.parsed[i]!.value) {
-            return a.parsed[i]!.value! > b.parsed[i]!.value! ? 1 : -1
+            return a.parsed[i]!.value > b.parsed[i]!.value ? 1 : -1
           }
         }
 
@@ -557,13 +566,13 @@ export class Router<
         search: replaceEqualDeep(previousLocation?.search, parsedSearch) as any,
         hash: hash.split('#').reverse()[0] ?? '',
         href: `${pathname}${searchStr}${hash}`,
-        state: replaceEqualDeep(previousLocation?.state, state) as HistoryState,
+        state: replaceEqualDeep(previousLocation?.state, state),
       }
     }
 
     const location = parse(this.history.location)
 
-    let { __tempLocation, __tempKey } = location.state
+    const { __tempLocation, __tempKey } = location.state
 
     if (__tempLocation && (!__tempKey || __tempKey === this.tempLocationKey)) {
       // Sync up the location keys
@@ -582,21 +591,22 @@ export class Router<
   }
 
   resolvePathWithBase = (from: string, path: string) => {
-    return resolvePath(this.basepath!, from, cleanPath(path))
+    return resolvePath(this.basepath, from, cleanPath(path))
   }
 
   get looseRoutesById() {
     return this.routesById as Record<string, AnyRoute>
   }
 
+  // eslint-disable-next-line no-shadow
   matchRoutes = <TRouteTree extends AnyRoute>(
     pathname: string,
     locationSearch: AnySearchSchema,
     opts?: { preload?: boolean; throwOnError?: boolean; debug?: boolean },
-  ): RouteMatch<TRouteTree>[] => {
+  ): Array<RouteMatch<TRouteTree>> => {
     let routeParams: Record<string, string> = {}
 
-    let foundRoute = this.flatRoutes.find((route) => {
+    const foundRoute = this.flatRoutes.find((route) => {
       const matchedParams = matchPathname(
         this.basepath,
         trimPathRight(pathname),
@@ -619,7 +629,7 @@ export class Router<
     let routeCursor: AnyRoute =
       foundRoute || (this.routesById as any)[rootRouteId]
 
-    let matchedRoutes: AnyRoute[] = [routeCursor]
+    const matchedRoutes: Array<AnyRoute> = [routeCursor]
 
     let isGlobalNotFound = false
 
@@ -640,9 +650,9 @@ export class Router<
       }
     }
 
-    while (routeCursor?.parentRoute) {
+    while (routeCursor.parentRoute) {
       routeCursor = routeCursor.parentRoute
-      if (routeCursor) matchedRoutes.unshift(routeCursor)
+      matchedRoutes.unshift(routeCursor)
     }
 
     const globalNotFoundRouteId = (() => {
@@ -689,7 +699,7 @@ export class Router<
       return
     })
 
-    const matches: AnyRouteMatch[] = []
+    const matches: Array<AnyRouteMatch> = []
 
     matchedRoutes.forEach((route, index) => {
       // Take each matched route and resolve + validate its search params
@@ -712,7 +722,7 @@ export class Router<
               ? route.options.validateSearch.parse
               : route.options.validateSearch
 
-          let search = validator?.(parentSearch) ?? {}
+          const search = validator?.(parentSearch) ?? {}
 
           return [
             {
@@ -722,15 +732,15 @@ export class Router<
             undefined,
           ]
         } catch (err: any) {
-          const searchError = new SearchParamError(err.message, {
+          const searchParamError = new SearchParamError(err.message, {
             cause: err,
           })
 
           if (opts?.throwOnError) {
-            throw searchError
+            throw searchParamError
           }
 
-          return [parentSearch, searchError]
+          return [parentSearch, searchParamError]
         }
       })()
 
@@ -761,7 +771,7 @@ export class Router<
       // Waste not, want not. If we already have a match for this route,
       // reuse it. This is important for layout routes, which might stick
       // around between navigation actions that only change leaf routes.
-      let existingMatch = getRouteMatch(this.state, matchId)
+      const existingMatch = getRouteMatch(this.state, matchId)
 
       const cause = this.state.matches.find((d) => d.id === matchId)
         ? 'stay'
@@ -832,7 +842,7 @@ export class Router<
       dest: BuildNextOptions & {
         unmaskOnReload?: boolean
       } = {},
-      matches?: AnyRouteMatch[],
+      matches?: Array<AnyRouteMatch>,
     ): ParsedLocation => {
       // if (dest.href) {
       //   return {
@@ -848,6 +858,7 @@ export class Router<
 
       const relevantMatches = this.state.pendingMatches || this.state.matches
       const fromSearch =
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         relevantMatches[relevantMatches.length - 1]?.search ||
         this.latestLocation.search
 
@@ -856,7 +867,7 @@ export class Router<
         fromSearch,
       )
       const stayingMatches = matches?.filter((d) =>
-        fromMatches?.find((e) => e.routeId === d.routeId),
+        fromMatches.find((e) => e.routeId === d.routeId),
       )
 
       const fromRoute = this.looseRoutesById[last(fromMatches)?.routeId]
@@ -873,14 +884,14 @@ export class Router<
       let nextParams =
         (dest.params ?? true) === true
           ? prevParams
-          : { ...prevParams, ...functionalUpdate(dest.params!, prevParams) }
+          : { ...prevParams, ...functionalUpdate(dest.params, prevParams) }
 
       if (Object.keys(nextParams).length > 0) {
         matches
           ?.map((d) => this.looseRoutesById[d.routeId]!.options.stringifyParams)
           .filter(Boolean)
           .forEach((fn) => {
-            nextParams = { ...nextParams!, ...fn!(nextParams!) }
+            nextParams = { ...nextParams!, ...fn!(nextParams) }
           })
       }
 
@@ -912,11 +923,8 @@ export class Router<
           .filter(Boolean) ?? []
 
       // Pre filters first
-      const preFilteredSearch = preSearchFilters?.length
-        ? preSearchFilters?.reduce(
-            (prev, next) => next(prev) as any,
-            fromSearch,
-          )
+      const preFilteredSearch = preSearchFilters.length
+        ? preSearchFilters.reduce((prev, next) => next(prev), fromSearch)
         : fromSearch
 
       // Then the link/navigate function
@@ -924,13 +932,13 @@ export class Router<
         dest.search === true
           ? preFilteredSearch // Preserve resolvedFrom true
           : dest.search
-            ? functionalUpdate(dest.search, preFilteredSearch) ?? {} // Updater
-            : preSearchFilters?.length
+            ? functionalUpdate(dest.search, preFilteredSearch) // Updater
+            : preSearchFilters.length
               ? preFilteredSearch // Preserve resolvedFrom filters
               : {}
 
       // Then post filters
-      const postFilteredSearch = postSearchFilters?.length
+      const postFilteredSearch = postSearchFilters.length
         ? postSearchFilters.reduce((prev, next) => next(prev), destSearch)
         : destSearch
 
@@ -942,7 +950,7 @@ export class Router<
         dest.hash === true
           ? this.latestLocation.hash
           : dest.hash
-            ? functionalUpdate(dest.hash!, this.latestLocation.hash)
+            ? functionalUpdate(dest.hash, this.latestLocation.hash)
             : undefined
 
       const hashStr = hash ? `#${hash}` : ''
@@ -971,13 +979,13 @@ export class Router<
       dest: BuildNextOptions = {},
       maskedDest?: BuildNextOptions,
     ) => {
-      let next = build(dest)
+      const next = build(dest)
       let maskedNext = maskedDest ? build(maskedDest) : undefined
 
       if (!maskedNext) {
         let params = {}
 
-        let foundMask = this.options.routeMasks?.find((d) => {
+        const foundMask = this.options.routeMasks?.find((d) => {
           const match = matchPathname(this.basepath, next.pathname, {
             to: d.from,
             caseSensitive: false,
@@ -1040,6 +1048,7 @@ export class Router<
     // If the next urls are the same and we're not replacing,
     // do nothing
     if (!isSameUrl) {
+      // eslint-disable-next-line prefer-const
       let { maskedLocation, ...nextHistory } = next
 
       if (maskedLocation) {
@@ -1140,9 +1149,9 @@ export class Router<
   }: {
     checkLatest: () => Promise<void> | undefined
     location: ParsedLocation
-    matches: AnyRouteMatch[]
+    matches: Array<AnyRouteMatch>
     preload?: boolean
-  }): Promise<RouteMatch[]> => {
+  }): Promise<Array<RouteMatch>> => {
     let latestPromise
     let firstBadMatchIndex: number | undefined
 
@@ -1189,6 +1198,7 @@ export class Router<
     }
 
     // Check each match middleware to see if the route can be accessed
+    // eslint-disable-next-line prefer-const
     for (let [index, match] of matches.entries()) {
       const parentMatch = matches[index - 1]
       const route = this.looseRoutesById[match.routeId]!
@@ -1280,10 +1290,11 @@ export class Router<
     }
 
     const validResolvedMatches = matches.slice(0, firstBadMatchIndex)
-    const matchPromises: Promise<any>[] = []
+    const matchPromises: Array<Promise<any>> = []
 
     validResolvedMatches.forEach((match, index) => {
       matchPromises.push(
+        // eslint-disable-next-line no-async-promise-executor
         new Promise<void>(async (resolve, reject) => {
           const parentMatchPromise = matchPromises[index - 1]
           const route = this.looseRoutesById[match.routeId]!
@@ -1409,13 +1420,14 @@ export class Router<
                 meta,
                 headers,
               }
-            } catch (error) {
+            } catch (e) {
+              let error = e
               if ((latestPromise = checkLatest())) return await latestPromise
 
-              handleError(error)
+              handleError(e)
 
               try {
-                route.options.onError?.(error)
+                route.options.onError?.(e)
               } catch (onErrorError) {
                 error = onErrorError
                 handleError(onErrorError)
@@ -1435,20 +1447,18 @@ export class Router<
           // This is where all of the stale-while-revalidate magic happens
           const age = Date.now() - match.updatedAt
 
-          let staleAge = preload
+          const staleAge = preload
             ? route.options.preloadStaleTime ??
               this.options.defaultPreloadStaleTime ??
               30_000 // 30 seconds for preloads by default
             : route.options.staleTime ?? this.options.defaultStaleTime ?? 0
 
-          // Default to reloading the route all the time
-          let shouldReload
-
           const shouldReloadOption = route.options.shouldReload
 
+          // Default to reloading the route all the time
           // Allow shouldReload to get the last say,
           // if provided.
-          shouldReload =
+          const shouldReload =
             typeof shouldReloadOption === 'function'
               ? shouldReloadOption(loaderContext)
               : shouldReloadOption
@@ -1550,10 +1560,11 @@ export class Router<
   }
 
   load = async (): Promise<void> => {
+    // eslint-disable-next-line no-async-promise-executor
     const promise = new Promise<void>(async (resolve, reject) => {
       const next = this.latestLocation
       const prevLocation = this.state.resolvedLocation
-      const pathDidChange = prevLocation!.href !== next.href
+      const pathDidChange = prevLocation.href !== next.href
       let latestPromise: Promise<void> | undefined | null
 
       // Cancel any pending matches
@@ -1566,7 +1577,7 @@ export class Router<
         pathChanged: pathDidChange,
       })
 
-      let pendingMatches!: RouteMatch<any, any>[]
+      let pendingMatches!: Array<RouteMatch<any, any>>
       const previousMatches = this.state.matches
 
       this.__store.batch(() => {
@@ -1591,8 +1602,8 @@ export class Router<
       })
 
       try {
-        let redirect: ResolvedRedirect
-        let notFound: NotFoundError
+        let redirect: ResolvedRedirect | undefined
+        let notFound: NotFoundError | undefined
 
         try {
           // Load the matches
@@ -1695,7 +1706,7 @@ export class Router<
   }
 
   resolveRedirect = (err: AnyRedirect): ResolvedRedirect => {
-    let redirect = err as ResolvedRedirect
+    const redirect = err as ResolvedRedirect
 
     if (!redirect.href) {
       redirect.href = this.buildLocation(redirect as any).href
@@ -1737,8 +1748,8 @@ export class Router<
     TMaskTo extends string = '',
   >(
     opts: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>,
-  ): Promise<AnyRouteMatch[] | undefined> => {
-    let next = this.buildLocation(opts as any)
+  ): Promise<Array<AnyRouteMatch> | undefined> => {
+    const next = this.buildLocation(opts as any)
 
     let matches = this.matchRoutes(next.pathname, next.search, {
       throwOnError: true,
@@ -1750,7 +1761,7 @@ export class Router<
         ...this.state.matches,
         ...(this.state.pendingMatches ?? []),
         ...this.state.cachedMatches,
-      ]?.map((d) => [d.id, true]),
+      ].map((d) => [d.id, true]),
     )
 
     this.__store.batch(() => {
@@ -1809,9 +1820,6 @@ export class Router<
       ? this.latestLocation
       : this.state.resolvedLocation
 
-    if (!baseLocation) {
-      return false
-    }
     const match = matchPathname(this.basepath, baseLocation.pathname, {
       ...opts,
       to: next.pathname,
@@ -1884,7 +1892,7 @@ export class Router<
   /**
    * @deprecated Please extract your own data from scripts injected using the `injectHtml` method
    */
-  hydrateData = <T extends any = unknown>(key: any) => {
+  hydrateData = <T = unknown>(key: any) => {
     warning(
       false,
       `The hydrateData method is deprecated. Please use the extractHtml method to extract your own data.`,
@@ -1939,7 +1947,7 @@ export class Router<
     this.options.hydrate?.(ctx.payload as any)
     const dehydratedState = ctx.router.state
 
-    let matches = this.matchRoutes(
+    const matches = this.matchRoutes(
       this.state.location.pathname,
       this.state.location.search,
     ).map((match) => {
@@ -1952,29 +1960,26 @@ export class Router<
         `Could not find a client-side match for dehydrated match with id: ${match.id}!`,
       )
 
-      if (dehydratedMatch) {
-        const route = this.looseRoutesById[match.routeId]!
+      const route = this.looseRoutesById[match.routeId]!
 
-        const assets =
-          dehydratedMatch.status === 'notFound' ||
-          dehydratedMatch.status === 'redirected'
-            ? {}
-            : {
-                meta: route.options.meta?.({
-                  params: match.params,
-                  loaderData: dehydratedMatch.loaderData,
-                }),
-                links: route.options.links?.(),
-                scripts: route.options.scripts?.(),
-              }
+      const assets =
+        dehydratedMatch.status === 'notFound' ||
+        dehydratedMatch.status === 'redirected'
+          ? {}
+          : {
+              meta: route.options.meta?.({
+                params: match.params,
+                loaderData: dehydratedMatch.loaderData,
+              }),
+              links: route.options.links?.(),
+              scripts: route.options.scripts?.(),
+            }
 
-        return {
-          ...match,
-          ...dehydratedMatch,
-          ...assets,
-        }
+      return {
+        ...match,
+        ...dehydratedMatch,
+        ...assets,
       }
-      return match
     })
 
     this.__store.setState((s) => {
@@ -1986,7 +1991,7 @@ export class Router<
     })
   }
 
-  handleNotFound = (matches: AnyRouteMatch[], err: NotFoundError) => {
+  handleNotFound = (matches: Array<AnyRouteMatch>, err: NotFoundError) => {
     const matchesByRouteId = Object.fromEntries(
       matches.map((match) => [match.routeId, match]),
     ) as Record<string, AnyRouteMatch>
@@ -2004,7 +2009,7 @@ export class Router<
       !this.options.defaultNotFoundComponent &&
       routeCursor.id !== rootRouteId
     ) {
-      routeCursor = routeCursor?.parentRoute
+      routeCursor = routeCursor.parentRoute
 
       invariant(
         routeCursor,
@@ -2012,7 +2017,7 @@ export class Router<
       )
     }
 
-    let match = matchesByRouteId[routeCursor.id]
+    const match = matchesByRouteId[routeCursor.id]
 
     invariant(match, 'Could not find match for route: ' + routeCursor.id)
 
@@ -2041,7 +2046,7 @@ export class Router<
 // proxy arguments from the caller to the imported function, retaining all type
 // information along the way
 export function lazyFn<
-  T extends Record<string, (...args: any[]) => any>,
+  T extends Record<string, (...args: Array<any>) => any>,
   TKey extends keyof T = 'default',
 >(fn: () => Promise<T>, key?: TKey) {
   return async (