@tanstack/router-core 1.168.10 → 1.168.11

package/src/router.ts

@@ -1420,7 +1420,7 @@ export class RouterCore<
     // Snapshot of active match state keyed by routeId, used to stabilise
     // params/search across navigations.
     const previousActiveMatchesByRouteId = new Map<string, AnyRouteMatch>()
-    for (const store of this.stores.activeMatchStoresById.values()) {
+    for (const store of this.stores.matchStores.values()) {
       if (store.routeId) {
         previousActiveMatchesByRouteId.set(store.routeId, store.get())
       }
@@ -1717,8 +1717,7 @@ export class RouterCore<
     // Determine params: reuse from state if possible, otherwise parse
     const lastStateMatchId = last(this.stores.matchesId.get())
     const lastStateMatch =
-      lastStateMatchId &&
-      this.stores.activeMatchStoresById.get(lastStateMatchId)?.get()
+      lastStateMatchId && this.stores.matchStores.get(lastStateMatchId)?.get()
     const canReuseParams =
       lastStateMatch &&
       lastStateMatch.routeId === lastRoute.id &&
@@ -1767,16 +1766,16 @@ export class RouterCore<
   }
 
   cancelMatches = () => {
-    this.stores.pendingMatchesId.get().forEach((matchId) => {
+    this.stores.pendingIds.get().forEach((matchId) => {
       this.cancelMatch(matchId)
     })
 
     this.stores.matchesId.get().forEach((matchId) => {
-      if (this.stores.pendingMatchStoresById.has(matchId)) {
+      if (this.stores.pendingMatchStores.has(matchId)) {
         return
       }
 
-      const match = this.stores.activeMatchStoresById.get(matchId)?.get()
+      const match = this.stores.matchStores.get(matchId)?.get()
       if (!match) {
         return
       }
@@ -2356,7 +2355,7 @@ export class RouterCore<
     // Match the routes
     const pendingMatches = this.matchRoutes(this.latestLocation)
 
-    const nextCachedMatches = this.stores.cachedMatchesSnapshot
+    const nextCachedMatches = this.stores.cachedMatches
       .get()
       .filter((d) => !pendingMatches.some((e) => e.id === d.id))
 
@@ -2366,9 +2365,9 @@ export class RouterCore<
       this.stores.statusCode.set(200)
       this.stores.isLoading.set(true)
       this.stores.location.set(this.latestLocation)
-      this.stores.setPendingMatches(pendingMatches)
+      this.stores.setPending(pendingMatches)
       // If a cached match moved to pending matches, remove it from cached matches
-      this.stores.setCachedMatches(nextCachedMatches)
+      this.stores.setCached(nextCachedMatches)
     })
   }
 
@@ -2404,7 +2403,7 @@ export class RouterCore<
             router: this,
             sync: opts?.sync,
             forceStaleReload: previousLocation.href === next.href,
-            matches: this.stores.pendingMatchesSnapshot.get(),
+            matches: this.stores.pendingMatches.get(),
             location: next,
             updateMatch: this.updateMatch,
             // eslint-disable-next-line @typescript-eslint/require-await
@@ -2428,27 +2427,25 @@ export class RouterCore<
                   let hookStayingMatches: Array<AnyRouteMatch> | null = null
 
                   this.batch(() => {
-                    const pendingMatches =
-                      this.stores.pendingMatchesSnapshot.get()
+                    const pendingMatches = this.stores.pendingMatches.get()
                     const mountPending = pendingMatches.length
-                    const currentMatches =
-                      this.stores.activeMatchesSnapshot.get()
+                    const currentMatches = this.stores.matches.get()
 
                     exitingMatches = mountPending
                       ? currentMatches.filter(
                           (match) =>
-                            !this.stores.pendingMatchStoresById.has(match.id),
+                            !this.stores.pendingMatchStores.has(match.id),
                         )
                       : null
 
                     // Lifecycle-hook identity: routeId only (route presence in tree)
                     // Build routeId sets from pools to avoid derived stores.
                     const pendingRouteIds = new Set<string>()
-                    for (const s of this.stores.pendingMatchStoresById.values()) {
+                    for (const s of this.stores.pendingMatchStores.values()) {
                       if (s.routeId) pendingRouteIds.add(s.routeId)
                     }
                     const activeRouteIds = new Set<string>()
-                    for (const s of this.stores.activeMatchStoresById.values()) {
+                    for (const s of this.stores.matchStores.values()) {
                       if (s.routeId) activeRouteIds.add(s.routeId)
                     }
 
@@ -2477,10 +2474,10 @@ export class RouterCore<
                      * or reloads re-run their loaders instead of reusing the failed/not-found data.
                      */
                     if (mountPending) {
-                      this.stores.setActiveMatches(pendingMatches)
-                      this.stores.setPendingMatches([])
-                      this.stores.setCachedMatches([
-                        ...this.stores.cachedMatchesSnapshot.get(),
+                      this.stores.setMatches(pendingMatches)
+                      this.stores.setPending([])
+                      this.stores.setCached([
+                        ...this.stores.cachedMatches.get(),
                         ...exitingMatches!.filter(
                           (d) =>
                             d.status !== 'error' &&
@@ -2527,9 +2524,7 @@ export class RouterCore<
             ? redirect.status
             : notFound
               ? 404
-              : this.stores.activeMatchesSnapshot
-                    .get()
-                    .some((d) => d.status === 'error')
+              : this.stores.matches.get().some((d) => d.status === 'error')
                 ? 500
                 : 200
 
@@ -2563,9 +2558,7 @@ export class RouterCore<
     let newStatusCode: number | undefined = undefined
     if (this.hasNotFoundMatch()) {
       newStatusCode = 404
-    } else if (
-      this.stores.activeMatchesSnapshot.get().some((d) => d.status === 'error')
-    ) {
+    } else if (this.stores.matches.get().some((d) => d.status === 'error')) {
       newStatusCode = 500
     }
     if (newStatusCode !== undefined) {
@@ -2628,25 +2621,25 @@ export class RouterCore<
 
   updateMatch: UpdateMatchFn = (id, updater) => {
     this.startTransition(() => {
-      const pendingMatch = this.stores.pendingMatchStoresById.get(id)
+      const pendingMatch = this.stores.pendingMatchStores.get(id)
       if (pendingMatch) {
         pendingMatch.set(updater)
         return
       }
 
-      const activeMatch = this.stores.activeMatchStoresById.get(id)
+      const activeMatch = this.stores.matchStores.get(id)
       if (activeMatch) {
         activeMatch.set(updater)
         return
       }
 
-      const cachedMatch = this.stores.cachedMatchStoresById.get(id)
+      const cachedMatch = this.stores.cachedMatchStores.get(id)
       if (cachedMatch) {
         const next = updater(cachedMatch.get())
         if (next.status === 'redirected') {
-          const deleted = this.stores.cachedMatchStoresById.delete(id)
+          const deleted = this.stores.cachedMatchStores.delete(id)
           if (deleted) {
-            this.stores.cachedMatchesId.set((prev) =>
+            this.stores.cachedIds.set((prev) =>
               prev.filter((matchId) => matchId !== id),
             )
           }
@@ -2659,9 +2652,9 @@ export class RouterCore<
 
   getMatch: GetMatchFn = (matchId: string): AnyRouteMatch | undefined => {
     return (
-      this.stores.cachedMatchStoresById.get(matchId)?.get() ??
-      this.stores.pendingMatchStoresById.get(matchId)?.get() ??
-      this.stores.activeMatchStoresById.get(matchId)?.get()
+      this.stores.cachedMatchStores.get(matchId)?.get() ??
+      this.stores.pendingMatchStores.get(matchId)?.get() ??
+      this.stores.matchStores.get(matchId)?.get()
     )
   }
 
@@ -2698,15 +2691,9 @@ export class RouterCore<
     }
 
     this.batch(() => {
-      this.stores.setActiveMatches(
-        this.stores.activeMatchesSnapshot.get().map(invalidate),
-      )
-      this.stores.setCachedMatches(
-        this.stores.cachedMatchesSnapshot.get().map(invalidate),
-      )
-      this.stores.setPendingMatches(
-        this.stores.pendingMatchesSnapshot.get().map(invalidate),
-      )
+      this.stores.setMatches(this.stores.matches.get().map(invalidate))
+      this.stores.setCached(this.stores.cachedMatches.get().map(invalidate))
+      this.stores.setPending(this.stores.pendingMatches.get().map(invalidate))
     })
 
     this.shouldViewTransition = false
@@ -2764,13 +2751,13 @@ export class RouterCore<
   clearCache: ClearCacheFn<this> = (opts) => {
     const filter = opts?.filter
     if (filter !== undefined) {
-      this.stores.setCachedMatches(
-        this.stores.cachedMatchesSnapshot
+      this.stores.setCached(
+        this.stores.cachedMatches
           .get()
           .filter((m) => !filter(m as MakeRouteMatchUnion<this>)),
       )
     } else {
-      this.stores.setCachedMatches([])
+      this.stores.setCached([])
     }
   }
 
@@ -2819,12 +2806,12 @@ export class RouterCore<
 
     const activeMatchIds = new Set([
       ...this.stores.matchesId.get(),
-      ...this.stores.pendingMatchesId.get(),
+      ...this.stores.pendingIds.get(),
     ])
 
     const loadedMatchIds = new Set([
       ...activeMatchIds,
-      ...this.stores.cachedMatchesId.get(),
+      ...this.stores.cachedIds.get(),
     ])
 
     // If the matches are already loaded, we need to add them to the cached matches.
@@ -2832,8 +2819,8 @@ export class RouterCore<
       (match) => !loadedMatchIds.has(match.id),
     )
     if (matchesToCache.length) {
-      const cachedMatches = this.stores.cachedMatchesSnapshot.get()
-      this.stores.setCachedMatches([...cachedMatches, ...matchesToCache])
+      const cachedMatches = this.stores.cachedMatches.get()
+      this.stores.setCached([...cachedMatches, ...matchesToCache])
     }
 
     try {
@@ -2933,7 +2920,7 @@ export class RouterCore<
   serverSsr?: ServerSsr
 
   hasNotFoundMatch = () => {
-    return this.stores.activeMatchesSnapshot
+    return this.stores.matches
       .get()
       .some((d) => d.status === 'notFound' || d.globalNotFound)
   }

package/src/ssr/createRequestHandler.ts

@@ -78,7 +78,7 @@ export function createRequestHandler<TRouter extends AnyRouter>({
 }
 
 function getRequestHeaders(opts: { router: AnyRouter }): Headers {
-  const matchHeaders = opts.router.stores.activeMatchesSnapshot
+  const matchHeaders = opts.router.stores.matches
     .get()
     .map<AnyHeaders>((match) => match.headers)
 

package/src/ssr/ssr-client.ts

@@ -162,7 +162,7 @@ export async function hydrate(router: AnyRouter): Promise<any> {
     }
   })
 
-  router.stores.setActiveMatches(matches)
+  router.stores.setMatches(matches)
 
   // Allow the user to handle custom hydration data
   await router.options.hydrate?.(dehydratedData)
@@ -170,7 +170,7 @@ export async function hydrate(router: AnyRouter): Promise<any> {
   // now that all necessary data is hydrated:
   // 1) fully reconstruct the route context
   // 2) execute `head()` and `scripts()` for each match
-  const activeMatches = router.stores.activeMatchesSnapshot.get()
+  const activeMatches = router.stores.matches.get()
   const location = router.stores.location.get()
   await Promise.all(
     activeMatches.map(async (match) => {

package/src/ssr/ssr-server.ts

@@ -228,7 +228,7 @@ export function attachRouterServerSsrUtils({
 
         invariant()
       }
-      let matchesToDehydrate = router.stores.activeMatchesSnapshot.get()
+      let matchesToDehydrate = router.stores.matches.get()
       if (router.isShell()) {
         // In SPA mode we only want to dehydrate the root match
         matchesToDehydrate = matchesToDehydrate.slice(0, 1)

package/src/stores.ts

@@ -81,24 +81,24 @@ export interface RouterStores<in out TRouteTree extends AnyRoute> {
   statusCode: RouterWritableStore<number>
   redirect: RouterWritableStore<AnyRedirect | undefined>
   matchesId: RouterWritableStore<Array<string>>
-  pendingMatchesId: RouterWritableStore<Array<string>>
+  pendingIds: RouterWritableStore<Array<string>>
   /** @internal */
-  cachedMatchesId: RouterWritableStore<Array<string>>
-  activeMatchesSnapshot: ReadableStore<Array<AnyRouteMatch>>
-  pendingMatchesSnapshot: ReadableStore<Array<AnyRouteMatch>>
-  cachedMatchesSnapshot: ReadableStore<Array<AnyRouteMatch>>
-  firstMatchId: ReadableStore<string | undefined>
-  hasPendingMatches: ReadableStore<boolean>
-  matchRouteReactivity: ReadableStore<{
+  cachedIds: RouterWritableStore<Array<string>>
+  matches: ReadableStore<Array<AnyRouteMatch>>
+  pendingMatches: ReadableStore<Array<AnyRouteMatch>>
+  cachedMatches: ReadableStore<Array<AnyRouteMatch>>
+  firstId: ReadableStore<string | undefined>
+  hasPending: ReadableStore<boolean>
+  matchRouteDeps: ReadableStore<{
     locationHref: string
     resolvedLocationHref: string | undefined
     status: RouterState<TRouteTree>['status']
   }>
   __store: RouterReadableStore<RouterState<TRouteTree>>
 
-  activeMatchStoresById: Map<string, MatchStore>
-  pendingMatchStoresById: Map<string, MatchStore>
-  cachedMatchStoresById: Map<string, MatchStore>
+  matchStores: Map<string, MatchStore>
+  pendingMatchStores: Map<string, MatchStore>
+  cachedMatchStores: Map<string, MatchStore>
 
   /**
    * Get a computed store that resolves a routeId to its current match state.
@@ -106,13 +106,13 @@ export interface RouterStores<in out TRouteTree extends AnyRoute> {
    * The computed depends on matchesId + the individual match store, so
    * subscribers are only notified when the resolved match state changes.
    */
-  getMatchStoreByRouteId: (
+  getRouteMatchStore: (
     routeId: string,
   ) => RouterReadableStore<AnyRouteMatch | undefined>
 
-  setActiveMatches: (nextMatches: Array<AnyRouteMatch>) => void
-  setPendingMatches: (nextMatches: Array<AnyRouteMatch>) => void
-  setCachedMatches: (nextMatches: Array<AnyRouteMatch>) => void
+  setMatches: (nextMatches: Array<AnyRouteMatch>) => void
+  setPending: (nextMatches: Array<AnyRouteMatch>) => void
+  setCached: (nextMatches: Array<AnyRouteMatch>) => void
 }
 
 export function createRouterStores<TRouteTree extends AnyRoute>(
@@ -122,9 +122,9 @@ export function createRouterStores<TRouteTree extends AnyRoute>(
   const { createMutableStore, createReadonlyStore, batch, init } = config
 
   // non reactive utilities
-  const activeMatchStoresById = new Map<string, MatchStore>()
-  const pendingMatchStoresById = new Map<string, MatchStore>()
-  const cachedMatchStoresById = new Map<string, MatchStore>()
+  const matchStores = new Map<string, MatchStore>()
+  const pendingMatchStores = new Map<string, MatchStore>()
+  const cachedMatchStores = new Map<string, MatchStore>()
 
   // atoms
   const status = createMutableStore(initialState.status)
@@ -136,27 +136,27 @@ export function createRouterStores<TRouteTree extends AnyRoute>(
   const statusCode = createMutableStore(initialState.statusCode)
   const redirect = createMutableStore(initialState.redirect)
   const matchesId = createMutableStore<Array<string>>([])
-  const pendingMatchesId = createMutableStore<Array<string>>([])
-  const cachedMatchesId = createMutableStore<Array<string>>([])
+  const pendingIds = createMutableStore<Array<string>>([])
+  const cachedIds = createMutableStore<Array<string>>([])
 
   // 1st order derived stores
-  const activeMatchesSnapshot = createReadonlyStore(() =>
-    readPoolMatches(activeMatchStoresById, matchesId.get()),
+  const matches = createReadonlyStore(() =>
+    readPoolMatches(matchStores, matchesId.get()),
   )
-  const pendingMatchesSnapshot = createReadonlyStore(() =>
-    readPoolMatches(pendingMatchStoresById, pendingMatchesId.get()),
+  const pendingMatches = createReadonlyStore(() =>
+    readPoolMatches(pendingMatchStores, pendingIds.get()),
   )
-  const cachedMatchesSnapshot = createReadonlyStore(() =>
-    readPoolMatches(cachedMatchStoresById, cachedMatchesId.get()),
+  const cachedMatches = createReadonlyStore(() =>
+    readPoolMatches(cachedMatchStores, cachedIds.get()),
   )
-  const firstMatchId = createReadonlyStore(() => matchesId.get()[0])
-  const hasPendingMatches = createReadonlyStore(() =>
+  const firstId = createReadonlyStore(() => matchesId.get()[0])
+  const hasPending = createReadonlyStore(() =>
     matchesId.get().some((matchId) => {
-      const store = activeMatchStoresById.get(matchId)
+      const store = matchStores.get(matchId)
       return store?.get().status === 'pending'
     }),
   )
-  const matchRouteReactivity = createReadonlyStore(() => ({
+  const matchRouteDeps = createReadonlyStore(() => ({
     locationHref: location.get().href,
     resolvedLocationHref: resolvedLocation.get()?.href,
     status: status.get(),
@@ -168,7 +168,7 @@ export function createRouterStores<TRouteTree extends AnyRoute>(
     loadedAt: loadedAt.get(),
     isLoading: isLoading.get(),
     isTransitioning: isTransitioning.get(),
-    matches: activeMatchesSnapshot.get(),
+    matches: matches.get(),
     location: location.get(),
     resolvedLocation: resolvedLocation.get(),
     statusCode: statusCode.get(),
@@ -188,7 +188,7 @@ export function createRouterStores<TRouteTree extends AnyRoute>(
     RouterReadableStore<AnyRouteMatch | undefined>
   >(64)
 
-  function getMatchStoreByRouteId(
+  function getRouteMatchStore(
     routeId: string,
   ): RouterReadableStore<AnyRouteMatch | undefined> {
     let cached = matchStoreByRouteIdCache.get(routeId)
@@ -198,7 +198,7 @@ export function createRouterStores<TRouteTree extends AnyRoute>(
         // When matchesId changes (navigation), this computed re-evaluates.
         const ids = matchesId.get()
         for (const id of ids) {
-          const matchStore = activeMatchStoresById.get(id)
+          const matchStore = matchStores.get(id)
           if (matchStore && matchStore.routeId === routeId) {
             // Reading matchStore.get() tracks it as a dependency.
             // When the match store's state changes, this re-evaluates.
@@ -223,64 +223,64 @@ export function createRouterStores<TRouteTree extends AnyRoute>(
     statusCode,
     redirect,
     matchesId,
-    pendingMatchesId,
-    cachedMatchesId,
+    pendingIds,
+    cachedIds,
 
     // derived
-    activeMatchesSnapshot,
-    pendingMatchesSnapshot,
-    cachedMatchesSnapshot,
-    firstMatchId,
-    hasPendingMatches,
-    matchRouteReactivity,
+    matches,
+    pendingMatches,
+    cachedMatches,
+    firstId,
+    hasPending,
+    matchRouteDeps,
 
     // non-reactive state
-    activeMatchStoresById,
-    pendingMatchStoresById,
-    cachedMatchStoresById,
+    matchStores,
+    pendingMatchStores,
+    cachedMatchStores,
 
     // compatibility "big" state
     __store,
 
     // per-key computed stores
-    getMatchStoreByRouteId,
+    getRouteMatchStore,
 
     // methods
-    setActiveMatches,
-    setPendingMatches,
-    setCachedMatches,
+    setMatches,
+    setPending,
+    setCached,
   }
 
   // initialize the active matches
-  setActiveMatches(initialState.matches as Array<AnyRouteMatch>)
+  setMatches(initialState.matches as Array<AnyRouteMatch>)
   init?.(store)
 
   // setters to update non-reactive utilities in sync with the reactive stores
-  function setActiveMatches(nextMatches: Array<AnyRouteMatch>) {
+  function setMatches(nextMatches: Array<AnyRouteMatch>) {
     reconcileMatchPool(
       nextMatches,
-      activeMatchStoresById,
+      matchStores,
       matchesId,
       createMutableStore,
       batch,
     )
   }
 
-  function setPendingMatches(nextMatches: Array<AnyRouteMatch>) {
+  function setPending(nextMatches: Array<AnyRouteMatch>) {
     reconcileMatchPool(
       nextMatches,
-      pendingMatchStoresById,
-      pendingMatchesId,
+      pendingMatchStores,
+      pendingIds,
       createMutableStore,
       batch,
     )
   }
 
-  function setCachedMatches(nextMatches: Array<AnyRouteMatch>) {
+  function setCached(nextMatches: Array<AnyRouteMatch>) {
     reconcileMatchPool(
       nextMatches,
-      cachedMatchStoresById,
-      cachedMatchesId,
+      cachedMatchStores,
+      cachedIds,
       createMutableStore,
       batch,
     )