@tanstack/router-core 0.0.1-alpha.8 → 0.0.1-beta.1

package/src/router.ts

@@ -25,8 +25,11 @@ import {
 } from './path'
 import { AnyRoute, cascadeLoaderData, createRoute, Route } from './route'
 import {
+  AnyLoaderData,
+  AnyPathParams,
   AnyRouteConfig,
   AnySearchSchema,
+  LoaderContext,
   RouteConfig,
   SearchFilter,
 } from './routeConfig'
@@ -43,6 +46,7 @@ import {
   functionalUpdate,
   last,
   PickAsRequired,
+  PickRequired,
   replaceEqualDeep,
   Timeout,
   Updater,
@@ -81,9 +85,10 @@ export interface RouterOptions<TRouteConfig extends AnyRouteConfig> {
   stringifySearch?: SearchSerializer
   parseSearch?: SearchParser
   filterRoutes?: FilterRoutesFn
-  defaultLinkPreload?: false | 'intent'
-  defaultLinkPreloadMaxAge?: number
-  defaultLinkPreloadDelay?: number
+  defaultPreload?: false | 'intent'
+  defaultPreloadMaxAge?: number
+  defaultPreloadGcMaxAge?: number
+  defaultPreloadDelay?: number
   useErrorBoundary?: boolean
   defaultElement?: GetFrameworkGeneric<'Element'>
   defaultErrorElement?: GetFrameworkGeneric<'Element'>
@@ -98,6 +103,11 @@ export interface RouterOptions<TRouteConfig extends AnyRouteConfig> {
   basepath?: string
   createRouter?: (router: Router<any, any>) => void
   createRoute?: (opts: { route: AnyRoute; router: Router<any, any> }) => void
+  createElement?: (
+    element:
+      | GetFrameworkGeneric<'Element'>
+      | (() => Promise<GetFrameworkGeneric<'Element'>>),
+  ) => Promise<GetFrameworkGeneric<'Element'>>
 }
 
 export interface Action<
@@ -123,6 +133,42 @@ export interface ActionState<
   error?: unknown
 }
 
+export interface Loader<
+  TFullSearchSchema extends AnySearchSchema = {},
+  TAllParams extends AnyPathParams = {},
+  TRouteLoaderData = AnyLoaderData,
+> {
+  fetch: keyof PickRequired<TFullSearchSchema> extends never
+    ? keyof TAllParams extends never
+      ? (loaderContext: { signal?: AbortSignal }) => Promise<TRouteLoaderData>
+      : (loaderContext: {
+          params: TAllParams
+          search?: TFullSearchSchema
+          signal?: AbortSignal
+        }) => Promise<TRouteLoaderData>
+    : keyof TAllParams extends never
+    ? (loaderContext: {
+        search: TFullSearchSchema
+        params: TAllParams
+        signal?: AbortSignal
+      }) => Promise<TRouteLoaderData>
+    : (loaderContext: {
+        search: TFullSearchSchema
+        signal?: AbortSignal
+      }) => Promise<TRouteLoaderData>
+  current?: LoaderState<TFullSearchSchema, TAllParams>
+  latest?: LoaderState<TFullSearchSchema, TAllParams>
+  pending: LoaderState<TFullSearchSchema, TAllParams>[]
+}
+
+export interface LoaderState<
+  TFullSearchSchema = unknown,
+  TAllParams = unknown,
+> {
+  loadedAt: number
+  loaderContext: LoaderContext<TFullSearchSchema, TAllParams>
+}
+
 export interface RouterState {
   status: 'idle' | 'loading'
   location: Location
@@ -132,6 +178,7 @@ export interface RouterState {
   currentAction?: ActionState
   latestAction?: ActionState
   actions: Record<string, Action>
+  loaders: Record<string, Loader>
   pending?: PendingState
   isFetching: boolean
   isPreloading: boolean
@@ -184,6 +231,7 @@ export interface Router<
   TRouteConfig extends AnyRouteConfig = RouteConfig,
   TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>,
 > {
+  history: BrowserHistory | MemoryHistory | HashHistory
   options: PickAsRequired<
     RouterOptions<TRouteConfig>,
     'stringifySearch' | 'parseSearch'
@@ -210,15 +258,7 @@ export interface Router<
   update: <TRouteConfig extends RouteConfig = RouteConfig>(
     opts?: RouterOptions<TRouteConfig>,
   ) => Router<TRouteConfig>
-  buildRouteTree: (
-    routeConfig: RouteConfig,
-  ) => Route<TAllRouteInfo, AnyRouteInfo>
-  parseLocation: (
-    location: History['location'],
-    previousLocation?: Location,
-  ) => Location
-  buildLocation: (dest: BuildNextOptions) => Location
-  commitLocation: (next: Location, replace?: boolean) => Promise<void>
+
   buildNext: (opts: BuildNextOptions) => Location
   cancelMatches: () => void
   loadLocation: (next?: Location) => Promise<void>
@@ -227,9 +267,10 @@ export interface Router<
   getRoute: <TId extends keyof TAllRouteInfo['routeInfoById']>(
     id: TId,
   ) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]>
-  loadRoute: (
+  loadRoute: (navigateOpts: BuildNextOptions) => Promise<RouteMatch[]>
+  preloadRoute: (
     navigateOpts: BuildNextOptions,
-    loaderOpts: { maxAge: number },
+    loaderOpts: { maxAge?: number; gcMaxAge?: number },
   ) => Promise<RouteMatch[]>
   matchRoutes: (
     pathname: string,
@@ -238,16 +279,13 @@ export interface Router<
   loadMatches: (
     resolvedMatches: RouteMatch[],
     loaderOpts?: { withPending?: boolean } & (
-      | { preload: true; maxAge: number }
-      | { preload?: false; maxAge?: never }
+      | { preload: true; maxAge: number; gcMaxAge: number }
+      | { preload?: false; maxAge?: never; gcMaxAge?: never }
     ),
   ) => Promise<void>
   invalidateRoute: (opts: MatchLocation) => void
   reload: () => Promise<void>
   resolvePath: (from: string, path: string) => string
-  _navigate: (
-    location: BuildNextOptions & { replace?: boolean },
-  ) => Promise<void>
   navigate: <
     TFrom extends ValidFromPath<TAllRouteInfo> = '/',
     TTo extends string = '.',
@@ -267,6 +305,20 @@ export interface Router<
   >(
     opts: LinkOptions<TAllRouteInfo, TFrom, TTo>,
   ) => LinkInfo
+  __: {
+    buildRouteTree: (
+      routeConfig: RouteConfig,
+    ) => Route<TAllRouteInfo, AnyRouteInfo>
+    parseLocation: (
+      location: History['location'],
+      previousLocation?: Location,
+    ) => Location
+    buildLocation: (dest: BuildNextOptions) => Location
+    commitLocation: (next: Location, replace?: boolean) => Promise<void>
+    navigate: (
+      location: BuildNextOptions & { replace?: boolean },
+    ) => Promise<void>
+  }
 }
 
 // Detect if we're in the DOM
@@ -289,13 +341,15 @@ export function createRouter<
   const originalOptions = {
     defaultLoaderGcMaxAge: 5 * 60 * 1000,
     defaultLoaderMaxAge: 0,
-    defaultLinkPreloadDelay: 50,
+    defaultPreloadMaxAge: 2000,
+    defaultPreloadDelay: 50,
     ...userOptions,
     stringifySearch: userOptions?.stringifySearch ?? defaultStringifySearch,
     parseSearch: userOptions?.parseSearch ?? defaultParseSearch,
   }
 
   let router: Router<TRouteConfig, TAllRouteInfo> = {
+    history,
     options: originalOptions,
     listeners: [],
     removeActionQueue: [],
@@ -314,6 +368,7 @@ export function createRouter<
       location: null!,
       matches: [],
       actions: {},
+      loaders: {},
       loaderData: {} as any,
       lastUpdated: Date.now(),
       isFetching: false,
@@ -347,7 +402,7 @@ export function createRouter<
     },
 
     mount: () => {
-      const next = router.buildLocation({
+      const next = router.__.buildLocation({
         to: '.',
         search: true,
         hash: true,
@@ -356,14 +411,14 @@ export function createRouter<
       // If the current location isn't updated, trigger a navigation
       // to the current location. Otherwise, load the current location.
       if (next.href !== router.location.href) {
-        router.commitLocation(next, true)
+        router.__.commitLocation(next, true)
       } else {
         router.loadLocation()
       }
 
       const unsub = history.listen((event) => {
         router.loadLocation(
-          router.parseLocation(event.location, router.location),
+          router.__.parseLocation(event.location, router.location),
         )
       })
 
@@ -396,235 +451,12 @@ export function createRouter<
 
       if (routeConfig) {
         router.routesById = {} as any
-        router.routeTree = router.buildRouteTree(routeConfig)
+        router.routeTree = router.__.buildRouteTree(routeConfig)
       }
 
       return router as any
     },
 
-    buildRouteTree: (rootRouteConfig: RouteConfig) => {
-      const recurseRoutes = (
-        routeConfigs: RouteConfig[],
-        parent?: Route<TAllRouteInfo, any>,
-      ): Route<TAllRouteInfo, any>[] => {
-        return routeConfigs.map((routeConfig) => {
-          const routeOptions = routeConfig.options
-          const route = createRoute(routeConfig, routeOptions, parent, router)
-
-          // {
-          //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
-          //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
-          // }
-
-          const existingRoute = (router.routesById as any)[route.routeId]
-
-          if (existingRoute) {
-            if (process.env.NODE_ENV !== 'production') {
-              console.warn(
-                `Duplicate routes found with id: ${String(route.routeId)}`,
-                router.routesById,
-                route,
-              )
-            }
-            throw new Error()
-          }
-
-          ;(router.routesById as any)[route.routeId] = route
-
-          const children = routeConfig.children as RouteConfig[]
-
-          route.childRoutes = children?.length
-            ? recurseRoutes(children, route)
-            : undefined
-
-          return route
-        })
-      }
-
-      const routes = recurseRoutes([rootRouteConfig])
-
-      return routes[0]!
-    },
-
-    parseLocation: (
-      location: History['location'],
-      previousLocation?: Location,
-    ): Location => {
-      const parsedSearch = router.options.parseSearch(location.search)
-
-      return {
-        pathname: location.pathname,
-        searchStr: location.search,
-        search: replaceEqualDeep(previousLocation?.search, parsedSearch),
-        hash: location.hash.split('#').reverse()[0] ?? '',
-        href: `${location.pathname}${location.search}${location.hash}`,
-        state: location.state as LocationState,
-        key: location.key,
-      }
-    },
-
-    buildLocation: (dest: BuildNextOptions = {}): Location => {
-      // const resolvedFrom: Location = {
-      //   ...router.location,
-      const fromPathname = dest.fromCurrent
-        ? router.location.pathname
-        : dest.from ?? router.location.pathname
-
-      let pathname = resolvePath(
-        router.basepath ?? '/',
-        fromPathname,
-        `${dest.to ?? '.'}`,
-      )
-
-      const fromMatches = router.matchRoutes(router.location.pathname, {
-        strictParseParams: true,
-      })
-
-      const toMatches = router.matchRoutes(pathname)
-
-      const prevParams = { ...last(fromMatches)?.params }
-
-      let nextParams =
-        (dest.params ?? true) === true
-          ? prevParams
-          : functionalUpdate(dest.params!, prevParams)
-
-      if (nextParams) {
-        toMatches
-          .map((d) => d.options.stringifyParams)
-          .filter(Boolean)
-          .forEach((fn) => {
-            Object.assign({}, nextParams!, fn!(nextParams!))
-          })
-      }
-
-      pathname = interpolatePath(pathname, nextParams ?? {})
-
-      // Pre filters first
-      const preFilteredSearch = dest.__preSearchFilters?.length
-        ? dest.__preSearchFilters.reduce(
-            (prev, next) => next(prev),
-            router.location.search,
-          )
-        : router.location.search
-
-      // Then the link/navigate function
-      const destSearch =
-        dest.search === true
-          ? preFilteredSearch // Preserve resolvedFrom true
-          : dest.search
-          ? functionalUpdate(dest.search, preFilteredSearch) ?? {} // Updater
-          : dest.__preSearchFilters?.length
-          ? preFilteredSearch // Preserve resolvedFrom filters
-          : {}
-
-      // Then post filters
-      const postFilteredSearch = dest.__postSearchFilters?.length
-        ? dest.__postSearchFilters.reduce(
-            (prev, next) => next(prev),
-            destSearch,
-          )
-        : destSearch
-
-      const search = replaceEqualDeep(
-        router.location.search,
-        postFilteredSearch,
-      )
-
-      const searchStr = router.options.stringifySearch(search)
-      let hash =
-        dest.hash === true
-          ? router.location.hash
-          : functionalUpdate(dest.hash!, router.location.hash)
-      hash = hash ? `#${hash}` : ''
-
-      return {
-        pathname,
-        search,
-        searchStr,
-        state: router.location.state,
-        hash,
-        href: `${pathname}${searchStr}${hash}`,
-        key: dest.key,
-      }
-    },
-
-    commitLocation: (next: Location, replace?: boolean): Promise<void> => {
-      const id = '' + Date.now() + Math.random()
-
-      if (router.navigateTimeout) clearTimeout(router.navigateTimeout)
-
-      let nextAction: 'push' | 'replace' = 'replace'
-
-      if (!replace) {
-        nextAction = 'push'
-      }
-
-      const isSameUrl =
-        router.parseLocation(history.location).href === next.href
-
-      if (isSameUrl && !next.key) {
-        nextAction = 'replace'
-      }
-
-      if (nextAction === 'replace') {
-        history.replace(
-          {
-            pathname: next.pathname,
-            hash: next.hash,
-            search: next.searchStr,
-          },
-          {
-            id,
-          },
-        )
-      } else {
-        history.push(
-          {
-            pathname: next.pathname,
-            hash: next.hash,
-            search: next.searchStr,
-          },
-          {
-            id,
-          },
-        )
-      }
-
-      router.navigationPromise = new Promise((resolve) => {
-        const previousNavigationResolve = router.resolveNavigation
-
-        router.resolveNavigation = () => {
-          previousNavigationResolve()
-          resolve()
-        }
-      })
-
-      return router.navigationPromise
-    },
-
-    buildNext: (opts: BuildNextOptions) => {
-      const next = router.buildLocation(opts)
-
-      const matches = router.matchRoutes(next.pathname)
-
-      const __preSearchFilters = matches
-        .map((match) => match.options.preSearchFilters ?? [])
-        .flat()
-        .filter(Boolean)
-
-      const __postSearchFilters = matches
-        .map((match) => match.options.postSearchFilters ?? [])
-        .flat()
-        .filter(Boolean)
-
-      return router.buildLocation({
-        ...opts,
-        __preSearchFilters,
-        __postSearchFilters,
-      })
-    },
-
     cancelMatches: () => {
       ;[
         ...router.state.matches,
@@ -736,6 +568,7 @@ export function createRouter<
           params: d.params,
           search: d.search,
         })
+        delete router.matchCache[d.matchId]
       })
 
       if (matches.some((d) => d.status === 'loading')) {
@@ -782,17 +615,32 @@ export function createRouter<
       })
     },
 
-    loadRoute: async (
-      navigateOpts: BuildNextOptions = router.location,
-      loaderOpts: { maxAge: number },
-    ) => {
+    loadRoute: async (navigateOpts = router.location) => {
+      const next = router.buildNext(navigateOpts)
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true,
+      })
+      await router.loadMatches(matches)
+      return matches
+    },
+
+    preloadRoute: async (navigateOpts = router.location, loaderOpts) => {
       const next = router.buildNext(navigateOpts)
       const matches = router.matchRoutes(next.pathname, {
         strictParseParams: true,
       })
       await router.loadMatches(matches, {
         preload: true,
-        maxAge: loaderOpts.maxAge,
+        maxAge:
+          loaderOpts.maxAge ??
+          router.options.defaultPreloadMaxAge ??
+          router.options.defaultLoaderMaxAge ??
+          0,
+        gcMaxAge:
+          loaderOpts.gcMaxAge ??
+          router.options.defaultPreloadGcMaxAge ??
+          router.options.defaultLoaderGcMaxAge ??
+          0,
       })
       return matches
     },
@@ -904,38 +752,10 @@ export function createRouter<
     },
 
     loadMatches: async (resolvedMatches, loaderOpts) => {
-      const now = Date.now()
-
       const matchPromises = resolvedMatches.map(async (match) => {
         // Validate the match (loads search params etc)
         match.__.validate()
-
-        // // If the match doesn't have a loader, don't attempt to load it
-        // if (!match.hasLoaders()) {
-        //   return
-        // }
-
-        // If this is a preload, add it to the preload cache
-        if (loaderOpts?.preload && loaderOpts?.maxAge > 0) {
-          // If the match is currently active, don't preload it
-          if (router.state.matches.find((d) => d.matchId === match.matchId)) {
-            return
-          }
-
-          router.matchCache[match.matchId] = {
-            gc: now + loaderOpts.maxAge, // TODO: Should this use the route's maxAge?
-            match,
-          }
-        }
-
-        // If the match is invalid, errored or idle, trigger it to load
-        if (
-          (match.status === 'success' && match.getIsInvalid()) ||
-          match.status === 'error' ||
-          match.status === 'idle'
-        ) {
-          match.load()
-        }
+        match.load(loaderOpts)
 
         if (match.status === 'loading') {
           // If requested, start the pending timers
@@ -968,7 +788,7 @@ export function createRouter<
     },
 
     reload: () =>
-      router._navigate({
+      router.__.navigate({
         fromCurrent: true,
         replace: true,
         search: true,
@@ -1006,11 +826,6 @@ export function createRouter<
       })
     },
 
-    _navigate: (location: BuildNextOptions & { replace?: boolean }) => {
-      const next = router.buildNext(location)
-      return router.commitLocation(next, location.replace)
-    },
-
     navigate: async ({ from, to = '.', search, hash, replace, params }) => {
       // If this link simply reloads the current route,
       // make sure it has a new key so it will trigger a data refresh
@@ -1032,7 +847,7 @@ export function createRouter<
         'Attempting to navigate to external url with router.navigate!',
       )
 
-      return router._navigate({
+      return router.__.navigate({
         from: fromString,
         to: toString,
         search,
@@ -1053,6 +868,7 @@ export function createRouter<
       activeOptions,
       preload,
       preloadMaxAge: userPreloadMaxAge,
+      preloadGcMaxAge: userPreloadGcMaxAge,
       preloadDelay: userPreloadDelay,
       disabled,
     }) => {
@@ -1081,14 +897,9 @@ export function createRouter<
 
       const next = router.buildNext(nextOpts)
 
-      preload = preload ?? router.options.defaultLinkPreload
-      const preloadMaxAge =
-        userPreloadMaxAge ??
-        router.options.defaultLinkPreloadMaxAge ??
-        router.options.defaultLoaderGcMaxAge ??
-        0
+      preload = preload ?? router.options.defaultPreload
       const preloadDelay =
-        userPreloadDelay ?? router.options.defaultLinkPreloadDelay ?? 0
+        userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0
 
       // Compare path/hash for matches
       const pathIsEqual = router.state.location.pathname === next.pathname
@@ -1120,28 +931,34 @@ export function createRouter<
           }
 
           // All is well? Navigate!)
-          router._navigate(nextOpts)
+          router.__.navigate(nextOpts)
         }
       }
 
       // The click handler
       const handleFocus = (e: MouseEvent) => {
-        if (preload && preloadMaxAge > 0) {
-          router.loadRoute(nextOpts, { maxAge: preloadMaxAge })
+        if (preload) {
+          router.preloadRoute(nextOpts, {
+            maxAge: userPreloadMaxAge,
+            gcMaxAge: userPreloadGcMaxAge,
+          })
         }
       }
 
       const handleEnter = (e: MouseEvent) => {
         const target = (e.target || {}) as LinkCurrentTargetElement
 
-        if (preload && preloadMaxAge > 0) {
+        if (preload) {
           if (target.preloadTimeout) {
             return
           }
 
           target.preloadTimeout = setTimeout(() => {
             target.preloadTimeout = null
-            router.loadRoute(nextOpts, { maxAge: preloadMaxAge })
+            router.preloadRoute(nextOpts, {
+              maxAge: userPreloadMaxAge,
+              gcMaxAge: userPreloadGcMaxAge,
+            })
           }, preloadDelay)
         }
       }
@@ -1166,9 +983,238 @@ export function createRouter<
         disabled,
       }
     },
+    buildNext: (opts: BuildNextOptions) => {
+      const next = router.__.buildLocation(opts)
+
+      const matches = router.matchRoutes(next.pathname)
+
+      const __preSearchFilters = matches
+        .map((match) => match.options.preSearchFilters ?? [])
+        .flat()
+        .filter(Boolean)
+
+      const __postSearchFilters = matches
+        .map((match) => match.options.postSearchFilters ?? [])
+        .flat()
+        .filter(Boolean)
+
+      return router.__.buildLocation({
+        ...opts,
+        __preSearchFilters,
+        __postSearchFilters,
+      })
+    },
+
+    __: {
+      buildRouteTree: (rootRouteConfig: RouteConfig) => {
+        const recurseRoutes = (
+          routeConfigs: RouteConfig[],
+          parent?: Route<TAllRouteInfo, any>,
+        ): Route<TAllRouteInfo, any>[] => {
+          return routeConfigs.map((routeConfig) => {
+            const routeOptions = routeConfig.options
+            const route = createRoute(routeConfig, routeOptions, parent, router)
+
+            // {
+            //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
+            //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
+            // }
+
+            const existingRoute = (router.routesById as any)[route.routeId]
+
+            if (existingRoute) {
+              if (process.env.NODE_ENV !== 'production') {
+                console.warn(
+                  `Duplicate routes found with id: ${String(route.routeId)}`,
+                  router.routesById,
+                  route,
+                )
+              }
+              throw new Error()
+            }
+
+            ;(router.routesById as any)[route.routeId] = route
+
+            const children = routeConfig.children as RouteConfig[]
+
+            route.childRoutes = children?.length
+              ? recurseRoutes(children, route)
+              : undefined
+
+            return route
+          })
+        }
+
+        const routes = recurseRoutes([rootRouteConfig])
+
+        return routes[0]!
+      },
+
+      parseLocation: (
+        location: History['location'],
+        previousLocation?: Location,
+      ): Location => {
+        const parsedSearch = router.options.parseSearch(location.search)
+
+        return {
+          pathname: location.pathname,
+          searchStr: location.search,
+          search: replaceEqualDeep(previousLocation?.search, parsedSearch),
+          hash: location.hash.split('#').reverse()[0] ?? '',
+          href: `${location.pathname}${location.search}${location.hash}`,
+          state: location.state as LocationState,
+          key: location.key,
+        }
+      },
+
+      navigate: (location: BuildNextOptions & { replace?: boolean }) => {
+        const next = router.buildNext(location)
+        return router.__.commitLocation(next, location.replace)
+      },
+
+      buildLocation: (dest: BuildNextOptions = {}): Location => {
+        // const resolvedFrom: Location = {
+        //   ...router.location,
+        const fromPathname = dest.fromCurrent
+          ? router.location.pathname
+          : dest.from ?? router.location.pathname
+
+        let pathname = resolvePath(
+          router.basepath ?? '/',
+          fromPathname,
+          `${dest.to ?? '.'}`,
+        )
+
+        const fromMatches = router.matchRoutes(router.location.pathname, {
+          strictParseParams: true,
+        })
+
+        const toMatches = router.matchRoutes(pathname)
+
+        const prevParams = { ...last(fromMatches)?.params }
+
+        let nextParams =
+          (dest.params ?? true) === true
+            ? prevParams
+            : functionalUpdate(dest.params!, prevParams)
+
+        if (nextParams) {
+          toMatches
+            .map((d) => d.options.stringifyParams)
+            .filter(Boolean)
+            .forEach((fn) => {
+              Object.assign({}, nextParams!, fn!(nextParams!))
+            })
+        }
+
+        pathname = interpolatePath(pathname, nextParams ?? {})
+
+        // Pre filters first
+        const preFilteredSearch = dest.__preSearchFilters?.length
+          ? dest.__preSearchFilters.reduce(
+              (prev, next) => next(prev),
+              router.location.search,
+            )
+          : router.location.search
+
+        // Then the link/navigate function
+        const destSearch =
+          dest.search === true
+            ? preFilteredSearch // Preserve resolvedFrom true
+            : dest.search
+            ? functionalUpdate(dest.search, preFilteredSearch) ?? {} // Updater
+            : dest.__preSearchFilters?.length
+            ? preFilteredSearch // Preserve resolvedFrom filters
+            : {}
+
+        // Then post filters
+        const postFilteredSearch = dest.__postSearchFilters?.length
+          ? dest.__postSearchFilters.reduce(
+              (prev, next) => next(prev),
+              destSearch,
+            )
+          : destSearch
+
+        const search = replaceEqualDeep(
+          router.location.search,
+          postFilteredSearch,
+        )
+
+        const searchStr = router.options.stringifySearch(search)
+        let hash =
+          dest.hash === true
+            ? router.location.hash
+            : functionalUpdate(dest.hash!, router.location.hash)
+        hash = hash ? `#${hash}` : ''
+
+        return {
+          pathname,
+          search,
+          searchStr,
+          state: router.location.state,
+          hash,
+          href: `${pathname}${searchStr}${hash}`,
+          key: dest.key,
+        }
+      },
+
+      commitLocation: (next: Location, replace?: boolean): Promise<void> => {
+        const id = '' + Date.now() + Math.random()
+
+        if (router.navigateTimeout) clearTimeout(router.navigateTimeout)
+
+        let nextAction: 'push' | 'replace' = 'replace'
+
+        if (!replace) {
+          nextAction = 'push'
+        }
+
+        const isSameUrl =
+          router.__.parseLocation(history.location).href === next.href
+
+        if (isSameUrl && !next.key) {
+          nextAction = 'replace'
+        }
+
+        if (nextAction === 'replace') {
+          history.replace(
+            {
+              pathname: next.pathname,
+              hash: next.hash,
+              search: next.searchStr,
+            },
+            {
+              id,
+            },
+          )
+        } else {
+          history.push(
+            {
+              pathname: next.pathname,
+              hash: next.hash,
+              search: next.searchStr,
+            },
+            {
+              id,
+            },
+          )
+        }
+
+        router.navigationPromise = new Promise((resolve) => {
+          const previousNavigationResolve = router.resolveNavigation
+
+          router.resolveNavigation = () => {
+            previousNavigationResolve()
+            resolve()
+          }
+        })
+
+        return router.navigationPromise
+      },
+    },
   }
 
-  router.location = router.parseLocation(history.location)
+  router.location = router.__.parseLocation(history.location)
   router.state.location = router.location
 
   router.update(userOptions)