@tanstack/router-core 0.0.1-alpha.3 → 0.0.1-alpha.5

package/src/index.ts

@@ -7,9 +7,10 @@ import {
   History,
   HashHistory,
 } from 'history'
-import React from 'react'
+import invariant from 'tiny-invariant'
 
 export { createHashHistory, createBrowserHistory, createMemoryHistory }
+export { invariant }
 
 import { decode, encode } from './qss'
 
@@ -62,6 +63,7 @@ export interface FrameworkGenerics {
 
 export interface RouteConfig<
   TId extends string = string,
+  TRouteId extends string = string,
   TPath extends string = string,
   TFullPath extends string = string,
   TRouteLoaderData extends AnyLoaderData = AnyLoaderData,
@@ -80,9 +82,11 @@ export interface RouteConfig<
   TKnownChildren = unknown,
 > {
   id: TId
+  routeId: TRouteId
   path: NoInfer<TPath>
   fullPath: TFullPath
   options: RouteOptions<
+    TRouteId,
     TPath,
     TRouteLoaderData,
     TLoaderData,
@@ -104,6 +108,7 @@ export interface RouteConfig<
         createChildRoute: CreateRouteConfigFn<
           false,
           TId,
+          TFullPath,
           TLoaderData,
           TFullSearchSchema,
           TAllParams
@@ -113,6 +118,7 @@ export interface RouteConfig<
         : { error: 'Invalid route detected'; route: TNewChildren },
     ) => RouteConfig<
       TId,
+      TRouteId,
       TPath,
       TFullPath,
       TRouteLoaderData,
@@ -133,10 +139,12 @@ export interface RouteConfig<
 type CreateRouteConfigFn<
   TIsRoot extends boolean = false,
   TParentId extends string = string,
+  TParentPath extends string = string,
   TParentAllLoaderData extends AnyLoaderData = {},
   TParentSearchSchema extends AnySearchSchema = {},
   TParentParams extends AnyPathParams = {},
 > = <
+  TRouteId extends string,
   TPath extends string,
   TRouteLoaderData extends AnyLoaderData,
   TActionPayload,
@@ -152,10 +160,16 @@ type CreateRouteConfigFn<
     ? Record<ParsePathParams<TPath>, string>
     : NoInfer<TParams>,
   TKnownChildren extends RouteConfig[] = RouteConfig[],
+  TResolvedId extends string = string extends TRouteId
+    ? string extends TPath
+      ? string
+      : TPath
+    : TRouteId,
 >(
   options?: TIsRoot extends true
     ? Omit<
         RouteOptions<
+          TRouteId,
           TPath,
           TRouteLoaderData,
           Expand<TParentAllLoaderData & DeepAwaited<NoInfer<TRouteLoaderData>>>,
@@ -171,6 +185,7 @@ type CreateRouteConfigFn<
         'path'
       > & { path?: never }
     : RouteOptions<
+        TRouteId,
         TPath,
         TRouteLoaderData,
         Expand<TParentAllLoaderData & DeepAwaited<NoInfer<TRouteLoaderData>>>,
@@ -186,10 +201,12 @@ type CreateRouteConfigFn<
   children?: TKnownChildren,
   isRoot?: boolean,
   parentId?: string,
+  parentPath?: string,
 ) => RouteConfig<
-  RouteId<TParentId, TPath>,
+  RoutePrefix<TParentId, TResolvedId>,
+  TResolvedId,
   TPath,
-  RouteIdToPath<RouteId<TParentId, TPath>>,
+  string extends TPath ? '' : RoutePath<RoutePrefix<TParentPath, TPath>>,
   TRouteLoaderData,
   Expand<TParentAllLoaderData & DeepAwaited<NoInfer<TRouteLoaderData>>>,
   TActionPayload,
@@ -208,11 +225,10 @@ export const createRouteConfig: CreateRouteConfigFn<true> = (
   children,
   isRoot = true,
   parentId,
+  parentPath,
 ) => {
   if (isRoot) {
     ;(options as any).path = rootRouteId
-  } else {
-    warning(!options.path, 'Routes must have a path property.')
   }
 
   // Strip the root from parentIds
@@ -220,14 +236,16 @@ export const createRouteConfig: CreateRouteConfigFn<true> = (
     parentId = ''
   }
 
-  let path = String(isRoot ? rootRouteId : options.path)
+  let path: undefined | string = isRoot ? rootRouteId : options.path
 
   // If the path is anything other than an index path, trim it up
-  if (path !== '/') {
+  if (path && path !== '/') {
     path = trimPath(path)
   }
 
-  let id = joinPaths([parentId, path])
+  const routeId = path || (options as { id?: string }).id
+
+  let id = joinPaths([parentId, routeId])
 
   if (path === rootRouteId) {
     path = '/'
@@ -237,10 +255,12 @@ export const createRouteConfig: CreateRouteConfigFn<true> = (
     id = joinPaths(['/', id])
   }
 
-  const fullPath = id === rootRouteId ? '/' : trimPathRight(id)
+  const fullPath =
+    id === rootRouteId ? '/' : trimPathRight(joinPaths([parentPath, path]))
 
   return {
     id: id as any,
+    routeId: routeId as any,
     path: path as any,
     fullPath: fullPath as any,
     options: options as any,
@@ -249,10 +269,11 @@ export const createRouteConfig: CreateRouteConfigFn<true> = (
       createRouteConfig(
         options,
         cb((childOptions: any) =>
-          createRouteConfig(childOptions, undefined, false, id),
+          createRouteConfig(childOptions, undefined, false, id, fullPath),
         ),
         false,
         parentId,
+        parentPath,
       ),
   }
 }
@@ -271,6 +292,8 @@ export interface AnyRouteConfig
     any,
     any,
     any,
+    any,
+    any,
     any
   > {}
 
@@ -289,6 +312,7 @@ export interface AnyRouteConfigWithChildren<TChildren>
     any,
     any,
     any,
+    any,
     TChildren
   > {}
 
@@ -297,7 +321,8 @@ export interface AnyAllRouteInfo {
   routeInfo: AnyRouteInfo
   routeInfoById: Record<string, AnyRouteInfo>
   routeInfoByFullPath: Record<string, AnyRouteInfo>
-  fullPath: string
+  routeIds: any
+  routePaths: any
 }
 
 export interface DefaultAllRouteInfo {
@@ -305,7 +330,8 @@ export interface DefaultAllRouteInfo {
   routeInfo: RouteInfo
   routeInfoById: Record<string, RouteInfo>
   routeInfoByFullPath: Record<string, RouteInfo>
-  fullPath: string
+  routeIds: string
+  routePaths: string
 }
 
 export interface AllRouteInfo<TRouteConfig extends AnyRouteConfig = RouteConfig>
@@ -325,20 +351,27 @@ export interface RoutesInfoInner<
     any,
     any,
     any,
+    any,
+    any,
     any
   > = RouteInfo,
+  TRouteInfoById = {
+    [TInfo in TRouteInfo as TInfo['id']]: TInfo
+  },
+  TRouteInfoByFullPath = {
+    [TInfo in TRouteInfo as TInfo['fullPath'] extends RootRouteId
+      ? never
+      : string extends TInfo['fullPath']
+      ? never
+      : TInfo['fullPath']]: TInfo
+  },
 > {
   routeConfig: TRouteConfig
   routeInfo: TRouteInfo
-  routeInfoById: {
-    [TInfo in TRouteInfo as TInfo['id']]: TInfo
-  }
-  routeInfoByFullPath: {
-    [TInfo in TRouteInfo as TInfo['id'] extends RootRouteId
-      ? never
-      : RouteIdToPath<TInfo['id']>]: TInfo
-  }
-  fullPath: RouteIdToPath<TRouteInfo['id']>
+  routeInfoById: TRouteInfoById
+  routeInfoByFullPath: TRouteInfoByFullPath
+  routeIds: keyof TRouteInfoById
+  routePaths: keyof TRouteInfoByFullPath
 }
 
 export interface AnyRoute extends Route<any, any> {}
@@ -356,6 +389,7 @@ export interface AnyRouteInfo
     any,
     any,
     any,
+    any,
     any
   > {}
 
@@ -363,7 +397,7 @@ export interface AnyRouteInfo
 //   [E in T as E[TKey]]: E
 // }
 
-type RouteIdToPath<T extends string> = T extends RootRouteId
+type RoutePath<T extends string> = T extends RootRouteId
   ? '/'
   : TrimPathRight<`${T}`>
 
@@ -397,6 +431,7 @@ export type ValueKeys<O> = Extract<keyof O, PropertyKey>
 
 export type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<
   infer TId,
+  infer TRouteId,
   infer TPath,
   infer TFullPath,
   infer TRouteLoaderData,
@@ -411,10 +446,11 @@ export type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<
   infer TAllParams,
   any
 >
-  ? string extends TId
+  ? string extends TRouteId
     ? never
     : RouteInfo<
         TId,
+        TRouteId,
         TPath,
         TFullPath,
         TRouteLoaderData,
@@ -432,8 +468,9 @@ export type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<
 
 export interface RouteInfo<
   TId extends string = string,
+  TRouteId extends string = string,
   TPath extends string = string,
-  TFullPath extends {} = string,
+  TFullPath extends string = string,
   TRouteLoaderData extends AnyLoaderData = {},
   TLoaderData extends AnyLoaderData = {},
   TActionPayload = unknown,
@@ -449,6 +486,7 @@ export interface RouteInfo<
   TAllParams extends AnyPathParams = {},
 > {
   id: TId
+  routeId: TRouteId
   path: TPath
   fullPath: TFullPath
   routeLoaderData: TRouteLoaderData
@@ -461,6 +499,7 @@ export interface RouteInfo<
   params: TParams
   allParams: TAllParams
   options: RouteOptions<
+    TRouteId,
     TPath,
     TRouteLoaderData,
     TLoaderData,
@@ -484,14 +523,16 @@ type DeepAwaited<T> = T extends Promise<infer A>
 export const rootRouteId = '__root__' as const
 export type RootRouteId = typeof rootRouteId
 
-type RouteId<
+type RoutePrefix<
   TPrefix extends string,
-  TPath extends string,
-> = string extends TPath
+  TId extends string,
+> = string extends TId
   ? RootRouteId
-  : `${TPrefix}/${TPath}` extends '/'
-  ? '/'
-  : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TPath>}`>}`
+  : TId extends string
+  ? `${TPrefix}/${TId}` extends '/'
+    ? '/'
+    : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TId>}`>}`
+  : never
 
 type CleanPath<T extends string> = T extends `${infer L}//${infer R}`
   ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`>
@@ -621,6 +662,7 @@ export type ParentParams<TParentParams> = AnyPathParams extends TParentParams
     }
 
 export type RouteOptions<
+  TRouteId extends string = string,
   TPath extends string = string,
   TRouteLoaderData extends AnyLoaderData = {},
   TLoaderData extends AnyLoaderData = {},
@@ -635,9 +677,15 @@ export type RouteOptions<
     string
   >,
   TAllParams extends AnyPathParams = {},
-> = {
-  // The path to match (relative to the nearest parent `Route` component or root basepath)
-  path: TPath
+> = (
+  | {
+      // The path to match (relative to the nearest parent `Route` component or root basepath)
+      path: TPath
+    }
+  | {
+      id: TRouteId
+    }
+) & {
   // If true, this route will be matched as case-sensitive
   caseSensitive?: boolean
   validateSearch?: SearchSchemaValidator<TSearchSchema, TParentSearchSchema>
@@ -654,20 +702,20 @@ export type RouteOptions<
   // // An array of child routes
   // children?: Route<any, any, any, any>[]
 } & (
-  | {
-      parseParams?: never
-      stringifyParams?: never
-    }
-  | {
-      // Parse params optionally receives path params as strings and returns them in a parsed format (like a number or boolean)
-      parseParams: (
-        rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>,
-      ) => TParams
-      stringifyParams: (
-        params: TParams,
-      ) => Record<ParsePathParams<TPath>, string>
-    }
-) &
+    | {
+        parseParams?: never
+        stringifyParams?: never
+      }
+    | {
+        // Parse params optionally receives path params as strings and returns them in a parsed format (like a number or boolean)
+        parseParams: (
+          rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>,
+        ) => TParams
+        stringifyParams: (
+          params: TParams,
+        ) => Record<ParsePathParams<TPath>, string>
+      }
+  ) &
   RouteLoaders<
     // Route Loaders (see below) can be inline on the route, or resolved async
     TRouteLoaderData,
@@ -779,7 +827,8 @@ export interface RouterState {
   matches: RouteMatch[]
   lastUpdated: number
   loaderData: unknown
-  action?: ActionState
+  currentAction?: ActionState
+  latestAction?: ActionState
   actions: Record<string, Action>
   pending?: PendingState
 }
@@ -900,7 +949,8 @@ export interface Action<
   // TError = unknown,
 > {
   submit: (submission?: TPayload) => Promise<TResponse>
-  latest?: ActionState
+  current?: ActionState<TPayload, TResponse>
+  latest?: ActionState<TPayload, TResponse>
   pending: ActionState<TPayload, TResponse>[]
 }
 
@@ -924,7 +974,7 @@ type RoutesById<TAllRouteInfo extends AnyAllRouteInfo> = {
 }
 
 // type RoutesByPath<TAllRouteInfo extends AnyAllRouteInfo> = {
-//   [K in TAllRouteInfo['fullPath']]: Route<
+//   [K in TAllRouteInfo['routePaths']]: Route<
 //     TAllRouteInfo,
 //     TAllRouteInfo['routeInfoByFullPath'][K]
 //   >
@@ -934,16 +984,16 @@ export type ValidFromPath<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
 > =
   | undefined
-  | (string extends TAllRouteInfo['fullPath']
+  | (string extends TAllRouteInfo['routePaths']
       ? string
-      : TAllRouteInfo['fullPath'])
+      : TAllRouteInfo['routePaths'])
 
 // type ValidToPath<
 //   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
 //   TFrom = undefined,
 // > = TFrom extends undefined
-//   ? TAllRouteInfo['fullPath'] | `...unsafe-relative-path (cast "as any")`
-//   : LooseAutocomplete<'.' | TAllRouteInfo['fullPath']>
+//   ? TAllRouteInfo['routePaths'] | `...unsafe-relative-path (cast "as any")`
+//   : LooseAutocomplete<'.' | TAllRouteInfo['routePaths']>
 
 export interface Router<
   TRouteConfig extends AnyRouteConfig = RouteConfig,
@@ -965,6 +1015,7 @@ export interface Router<
   routeTree: Route<TAllRouteInfo, RouteInfo>
   routesById: RoutesById<TAllRouteInfo>
   navigationPromise: Promise<void>
+  removeActionQueue: { action: Action; actionState: ActionState }[]
   startedLoadingAt: number
   destroy: () => void
   resolveNavigation: () => void
@@ -1051,6 +1102,7 @@ export function createRouter<
   let router: Router<TRouteConfig, TAllRouteInfo> = {
     options: originalOptions,
     listeners: [],
+    removeActionQueue: [],
     // Resolved after construction
     basepath: '',
     routeTree: undefined!,
@@ -1201,7 +1253,7 @@ export function createRouter<
 
       const toMatches = router.matchRoutes(pathname)
 
-      const prevParams = last(fromMatches)?.params
+      const prevParams = { ...last(fromMatches)?.params }
 
       let nextParams =
         (dest.params ?? true) === true
@@ -1213,7 +1265,7 @@ export function createRouter<
           .map((d) => d.options.stringifyParams)
           .filter(Boolean)
           .forEach((fn) => {
-            Object.assign(nextParams!, fn!(nextParams!))
+            Object.assign({}, nextParams!, fn!(nextParams!))
           })
       }
 
@@ -1358,10 +1410,23 @@ export function createRouter<
       router.startedLoadingAt = id
 
       if (next) {
+        // If the location.href has changed
+
         // Ingest the new location
         router.location = next
       }
 
+      // Clear out old actions
+      router.removeActionQueue.forEach(({ action, actionState }) => {
+        if (router.state.currentAction === actionState) {
+          router.state.currentAction = undefined
+        }
+        if (action.current === actionState) {
+          action.current = undefined
+        }
+      })
+      router.removeActionQueue = []
+
       // Cancel any pending matches
       router.cancelMatches()
 
@@ -1370,14 +1435,6 @@ export function createRouter<
         strictParseParams: true,
       })
 
-      unloadedMatches.forEach((match, index) => {
-        const parent = unloadedMatches[index - 1]
-        const child = unloadedMatches[index + 1]
-
-        if (parent) match.__.setParentMatch(parent)
-        if (child) match.__.addChildMatch(child)
-      })
-
       router.state = {
         ...router.state,
         pending: {
@@ -1506,69 +1563,95 @@ export function createRouter<
         ...(router.state.pending?.matches ?? []),
       ]
 
-      const recurse = async (
-        routes: Route<any, any>[],
-        parentMatch?: RouteMatch,
-      ): Promise<void> => {
+      const recurse = async (routes: Route<any, any>[]): Promise<void> => {
+        const parentMatch = last(matches)
         let params = parentMatch?.params ?? {}
 
         const filteredRoutes = router.options.filterRoutes?.(routes) ?? routes
 
-        const route = filteredRoutes?.find((route) => {
-          const fuzzy = !!(route.routePath !== '/' || route.childRoutes?.length)
-          const matchParams = matchPathname(pathname, {
-            to: route.fullPath,
-            fuzzy,
-            caseSensitive:
-              route.options.caseSensitive ?? router.options.caseSensitive,
-          })
+        let foundRoutes: Route[] = []
 
-          if (matchParams) {
-            let parsedParams
+        const findMatchInRoutes = (parentRoutes: Route[], routes: Route[]) => {
+          routes.some((route) => {
+            if (!route.routePath && route.childRoutes?.length) {
+              return findMatchInRoutes(
+                [...foundRoutes, route],
+                route.childRoutes,
+              )
+            }
 
-            try {
-              parsedParams =
-                route.options.parseParams?.(matchParams!) ?? matchParams
-            } catch (err) {
-              if (opts?.strictParseParams) {
-                throw err
+            const fuzzy = !!(
+              route.routePath !== '/' || route.childRoutes?.length
+            )
+
+            const matchParams = matchPathname(pathname, {
+              to: route.fullPath,
+              fuzzy,
+              caseSensitive:
+                route.options.caseSensitive ?? router.options.caseSensitive,
+            })
+
+            if (matchParams) {
+              let parsedParams
+
+              try {
+                parsedParams =
+                  route.options.parseParams?.(matchParams!) ?? matchParams
+              } catch (err) {
+                if (opts?.strictParseParams) {
+                  throw err
+                }
+              }
+
+              params = {
+                ...params,
+                ...parsedParams,
               }
             }
 
-            params = {
-              ...params,
-              ...parsedParams,
+            if (!!matchParams) {
+              foundRoutes = [...parentRoutes, route]
             }
-          }
 
-          return !!matchParams
-        })
+            return !!foundRoutes.length
+          })
+
+          return !!foundRoutes.length
+        }
+
+        findMatchInRoutes([], filteredRoutes)
 
-        if (!route) {
+        if (!foundRoutes.length) {
           return
         }
 
-        const interpolatedPath = interpolatePath(route.routePath, params)
-        const matchId = interpolatePath(route.routeId, params, true)
+        foundRoutes.forEach((foundRoute) => {
+          const interpolatedPath = interpolatePath(foundRoute.routePath, params)
+          const matchId = interpolatePath(foundRoute.routeId, params, true)
 
-        const match =
-          existingMatches.find((d) => d.matchId === matchId) ||
-          router.preloadCache[matchId]?.match ||
-          createRouteMatch(router, route, {
-            matchId,
-            params,
-            pathname: joinPaths([pathname, interpolatedPath]),
-          })
+          const match =
+            existingMatches.find((d) => d.matchId === matchId) ||
+            router.preloadCache[matchId]?.match ||
+            createRouteMatch(router, foundRoute, {
+              matchId,
+              params,
+              pathname: joinPaths([pathname, interpolatedPath]),
+            })
 
-        matches.push(match)
+          matches.push(match)
+        })
+
+        const foundRoute = last(foundRoutes)!
 
-        if (route.childRoutes?.length) {
-          recurse(route.childRoutes, match)
+        if (foundRoute.childRoutes?.length) {
+          recurse(foundRoute.childRoutes)
         }
       }
 
       recurse([router.routeTree])
 
+      cascadeLoaderData(matches)
+
       return matches
     },
 
@@ -1690,14 +1773,10 @@ export function createRouter<
         isExternal = true
       } catch (e) {}
 
-      if (isExternal) {
-        if (process.env.NODE_ENV !== 'production') {
-          throw new Error(
-            'Attempting to navigate to external url with router.navigate!',
-          )
-        }
-        return
-      }
+      invariant(
+        !isExternal,
+        'Attempting to navigate to external url with router.navigate!',
+      )
 
       return router._navigate({
         from: fromString,
@@ -1867,6 +1946,7 @@ export interface Route<
   TRouteInfo extends AnyRouteInfo = RouteInfo,
 > {
   routeId: TRouteInfo['id']
+  routeRouteId: TRouteInfo['routeId']
   routePath: TRouteInfo['path']
   fullPath: TRouteInfo['fullPath']
   parentRoute?: AnyRoute
@@ -1874,23 +1954,21 @@ export interface Route<
   options: RouteOptions
   router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>
   buildLink: <TTo extends string = '.'>(
-    options: // CheckRelativePath<
-    //   TAllRouteInfo,
-    //   TRouteInfo['fullPath'],
-    //   NoInfer<TTo>
-    // > &
-    Omit<LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>,
+    options: Omit<
+      LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>,
+      'from'
+    >,
   ) => LinkInfo
   matchRoute: <
     TTo extends string = '.',
     TResolved extends string = ResolveRelativePath<TRouteInfo['id'], TTo>,
   >(
-    matchLocation: // CheckRelativePath<
-    //   TAllRouteInfo,
-    //   TRouteInfo['fullPath'],
-    //   NoInfer<TTo>
-    // > &
-    Omit<ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>,
+    matchLocation: CheckRelativePath<
+      TAllRouteInfo,
+      TRouteInfo['fullPath'],
+      NoInfer<TTo>
+    > &
+      Omit<ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>,
     opts?: MatchRouteOptions,
   ) => RouteInfoByPath<TAllRouteInfo, TResolved>['allParams']
   navigate: <TTo extends string = '.'>(
@@ -1921,12 +1999,12 @@ export function createRoute<
   //       ]).replace(new RegExp(`^${rootRouteId}`), '')
   // ) as TRouteInfo['id']
 
-  const { id: routeId, path: routePath, fullPath } = routeConfig
+  const { id, routeId, path: routePath, fullPath } = routeConfig
 
   const action =
-    router.state.actions[routeId] ||
+    router.state.actions[id] ||
     (() => {
-      router.state.actions[routeId] = {
+      router.state.actions[id] = {
         pending: [],
         submit: async <T, U>(
           submission: T,
@@ -1944,12 +2022,14 @@ export function createRoute<
             submission,
           }
 
+          action.current = actionState
           action.latest = actionState
           action.pending.push(actionState)
 
           router.state = {
             ...router.state,
-            action: actionState,
+            currentAction: actionState,
+            latestAction: actionState,
           }
 
           router.notify()
@@ -1969,18 +2049,17 @@ export function createRoute<
             actionState.status = 'error'
           } finally {
             action.pending = action.pending.filter((d) => d !== actionState)
-            if (actionState === router.state.action) {
-              router.state.action = undefined
-            }
+            router.removeActionQueue.push({ action, actionState })
             router.notify()
           }
         },
       }
-      return router.state.actions[routeId]!
+      return router.state.actions[id]!
     })()
 
   let route: Route<TAllRouteInfo, TRouteInfo> = {
-    routeId,
+    routeId: id,
+    routeRouteId: routeId,
     routePath,
     fullPath,
     options,
@@ -2099,7 +2178,8 @@ export type ToOptions<
   from?: TFrom
   // // When using relative route paths, this option forces resolution from the current path, instead of the route API's path or `from` path
   // fromCurrent?: boolean
-} & SearchParamOptions<TAllRouteInfo, TFrom, TResolvedTo> &
+} & CheckPath<TAllRouteInfo, NoInfer<TResolvedTo>> &
+  SearchParamOptions<TAllRouteInfo, TFrom, TResolvedTo> &
   PathParamOptions<TAllRouteInfo, TFrom, TResolvedTo>
 
 export type ToPathOption<
@@ -2109,7 +2189,7 @@ export type ToPathOption<
 > =
   | TTo
   | RelativeToPathAutoComplete<
-      TAllRouteInfo['fullPath'],
+      TAllRouteInfo['routePaths'],
       NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
       NoInfer<TTo> & string
     >
@@ -2121,7 +2201,7 @@ export type ToIdOption<
 > =
   | TTo
   | RelativeToPathAutoComplete<
-      TAllRouteInfo['routeInfo']['id'],
+      TAllRouteInfo['routeIds'],
       NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
       NoInfer<TTo> & string
     >
@@ -2151,23 +2231,33 @@ export type CheckRelativePath<
   TTo,
 > = TTo extends string
   ? TFrom extends string
-    ? ResolveRelativePath<TFrom, TTo> extends TAllRouteInfo['fullPath']
+    ? ResolveRelativePath<TFrom, TTo> extends TAllRouteInfo['routePaths']
       ? {}
       : {
           Error: `${TFrom} + ${TTo} resolves to ${ResolveRelativePath<
             TFrom,
             TTo
           >}, which is not a valid route path.`
-          'Valid Route Paths': TAllRouteInfo['fullPath']
+          'Valid Route Paths': TAllRouteInfo['routePaths']
         }
     : {}
   : {}
 
-export type ResolveRelativePath<
-  TFrom,
-  TTo = '.',
-  TRooted = false,
-> = TFrom extends string
+export type CheckPath<TAllRouteInfo extends AnyAllRouteInfo, TPath> = Exclude<
+  TPath,
+  TAllRouteInfo['routePaths']
+> extends never
+  ? {}
+  : CheckPathError<TAllRouteInfo, Exclude<TPath, TAllRouteInfo['routePaths']>>
+
+export type CheckPathError<TAllRouteInfo extends AnyAllRouteInfo, TInvalids> = {
+  Error: `${TInvalids extends string
+    ? TInvalids
+    : never} is not a valid route path.`
+  'Valid Route Paths': TAllRouteInfo['routePaths']
+}
+
+export type ResolveRelativePath<TFrom, TTo = '.'> = TFrom extends string
   ? TTo extends string
     ? TTo extends '.'
       ? TFrom
@@ -2215,21 +2305,19 @@ type SearchParamOptions<
   TTo,
   TFromSchema = RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema'],
   TToSchema = RouteInfoByPath<TAllRouteInfo, TTo>['fullSearchSchema'],
-> =
-  // If the next route search extend or cover the from route, params will be optional
-  StartsWith<TFrom, TTo> extends true
-    ? {
-        search?: SearchReducer<TFromSchema, TToSchema>
-      }
-    : // Optional search params? Allow it
-    keyof PickRequired<TToSchema> extends never
-    ? {
-        search?: SearchReducer<TFromSchema, TToSchema>
-      }
-    : {
-        // Must have required search params, enforce it
-        search: SearchReducer<TFromSchema, TToSchema>
-      }
+> = StartsWith<TFrom, TTo> extends true // If the next route search extend or cover the from route, params will be optional
+  ? {
+      search?: SearchReducer<TFromSchema, TToSchema>
+    }
+  : // Optional search params? Allow it
+  keyof PickRequired<TToSchema> extends never
+  ? {
+      search?: SearchReducer<TFromSchema, TToSchema>
+    }
+  : {
+      // Must have required search params, enforce it
+      search: SearchReducer<TFromSchema, TToSchema>
+    }
 
 type SearchReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo)
 
@@ -2297,8 +2385,8 @@ export interface RouteMatch<
         }) => void)
     abortController: AbortController
     latestId: string
-    setParentMatch: (parentMatch: RouteMatch) => void
-    addChildMatch: (childMatch: RouteMatch) => void
+    // setParentMatch: (parentMatch: RouteMatch) => void
+    // addChildMatch: (childMatch: RouteMatch) => void
     validate: () => void
     startPending: () => void
     cancelPending: () => void
@@ -2373,18 +2461,18 @@ export function createRouteMatch<
         clearTimeout(routeMatch.__.pendingMinTimeout)
         delete routeMatch.__.pendingMinPromise
       },
-      setParentMatch: (parentMatch?: RouteMatch) => {
-        routeMatch.parentMatch = parentMatch
-      },
-      addChildMatch: (childMatch: RouteMatch) => {
-        if (
-          routeMatch.childMatches.find((d) => d.matchId === childMatch.matchId)
-        ) {
-          return
-        }
-
-        routeMatch.childMatches.push(childMatch)
-      },
+      // setParentMatch: (parentMatch?: RouteMatch) => {
+      //   routeMatch.parentMatch = parentMatch
+      // },
+      // addChildMatch: (childMatch: RouteMatch) => {
+      //   if (
+      //     routeMatch.childMatches.find((d) => d.matchId === childMatch.matchId)
+      //   ) {
+      //     return
+      //   }
+
+      //   routeMatch.childMatches.push(childMatch)
+      // },
       validate: () => {
         // Validate the search params and stabilize them
         const parentSearch =
@@ -2513,7 +2601,6 @@ export function createRouteMatch<
                 data,
               )
 
-              cascadeLoaderData(routeMatch)
               routeMatch.error = undefined
               routeMatch.status = 'success'
               routeMatch.updatedAt = Date.now()
@@ -2571,19 +2658,17 @@ export function createRouteMatch<
   return routeMatch
 }
 
-function cascadeLoaderData(routeMatch: RouteMatch<any, any>) {
-  if (routeMatch.parentMatch) {
-    routeMatch.loaderData = replaceEqualDeep(routeMatch.loaderData, {
-      ...routeMatch.parentMatch.loaderData,
-      ...routeMatch.routeLoaderData,
-    })
-  }
+function cascadeLoaderData(matches: RouteMatch<any, any>[]) {
+  matches.forEach((match, index) => {
+    const parent = matches[index - 1]
 
-  if (routeMatch.childMatches.length) {
-    routeMatch.childMatches.forEach((childMatch) => {
-      cascadeLoaderData(childMatch)
-    })
-  }
+    if (parent) {
+      match.loaderData = replaceEqualDeep(match.loaderData, {
+        ...parent.loaderData,
+        ...match.routeLoaderData,
+      })
+    }
+  })
 }
 
 export function matchPathname(