@tanstack/router-core 1.171.16-pre.0 → 1.171.17

package/src/router.ts

@@ -41,7 +41,6 @@ import {
   preloadClientRoute,
   refreshClientRoute,
   replaceRouteChunk,
-  transferMatchResources,
 } from './load-client'
 import {
   composeRewrites,
@@ -58,7 +57,6 @@ import type {
 import type { SearchParser, SearchSerializer } from './searchParams'
 import type { AnyRedirect, ResolvedRedirect } from './redirect'
 import type {
-  ActivePreload,
   LoadTransaction,
   LoaderFlight,
   PendingSession,
@@ -766,7 +764,6 @@ export type LoadFn = (opts?: {
   sync?: boolean
   action?: { type: HistoryAction }
   _signal?: AbortSignal
-  _dedupe?: boolean
 }) => Promise<void>
 
 export type CommitLocationFn = ({
@@ -778,7 +775,6 @@ export type CommitLocationFn = ({
 export type StartTransitionFn = (
   fn: () => void,
   expected: Array<AnyRouteMatch>,
-  urgent?: boolean,
 ) => Promise<boolean>
 
 export interface MatchRoutesFn {
@@ -1027,8 +1023,8 @@ export interface RouterCore<
   _tx?: LoadTransaction
   /** Joinable in-flight loader generations keyed by match ID. */
   _flights?: Map<string, LoaderFlight>
-  /** Whole speculative lanes that an identical navigation may adopt. */
-  _preloads?: Map<string, ActivePreload>
+  /** Active speculative lanes retained for cancellation, invalidation, and cache clearing. */
+  _preloads?: Map<AbortController, Array<AnyRouteMatch>>
   /** Owns cancellable work before a client transaction publishes. */
   _preflight?: AbortController
   /** Transfers one reconstructed SSR prefix into its initial client load. */
@@ -1037,8 +1033,11 @@ export interface RouterCore<
   _pending?: PendingSession
   /** Result of the latest server load, used to render or redirect. */
   _serverResult?: ServerLoadResult
-  /** Framework callback that acknowledges an exact matches publication. */
-  _rendered?: (matches: Array<AnyRouteMatch>) => void
+  /** Framework publication waiting for an exact render acknowledgement. */
+  _rendered?: [
+    offered?: Array<AnyRouteMatch>,
+    settle?: (rendered: boolean) => void,
+  ]
   /** Development-only HMR reload for a route and its descendants. */
   _refreshRoute: (() => Promise<void>) | undefined
   /** Development-only replacement for a route's lazy chunk owner. */
@@ -1769,8 +1768,8 @@ export class RouterCore<
       : undefined
     const lastStateMatchId = lastStateMatch?.id
     const cached = this.lightweightCache.get(location)
-    if (cached && cached[0] === lastStateMatchId) {
-      return cached[1]
+    if (cached && cached[0 /* lastMatchId */] === lastStateMatchId) {
+      return cached[1 /* result */]
     }
 
     const { matchedRoutes, routeParams } = this.getMatchedRoutes(
@@ -2169,7 +2168,7 @@ export class RouterCore<
 
     // Don't commit to history if nothing changed
     if (isSameLocation) {
-      this.load({ _dedupe: true })
+      this.load()
     } else {
       let {
         // eslint-disable-next-line prefer-const
@@ -2451,9 +2450,11 @@ export class RouterCore<
   }
 
   /**
-   * Invalidate the current matches and optionally force them back into a pending state.
+   * Invalidate selected match generations and optionally force current matches
+   * back into a pending state.
    *
-   * - Marks all matches that pass the optional `filter` as `invalid: true`.
+   * - Marks committed and cached matches whose IDs are selected as invalid.
+   * - Retires selected active preloads so older work cannot publish fresh data.
    *
    * The next load decides when to publish pending UI, so invalidation does not
    * mutate the currently rendered status.
@@ -2469,15 +2470,28 @@ export class RouterCore<
   > = (opts) => {
     const committedMatches = this._committed
     const filter = opts?.filter
-    const invalidIds = filter
-      ? new Set(
-          [...committedMatches, ...this._cache.values()]
-            .filter((match) => filter(match as MakeRouteMatchUnion<this>))
-            .map((match) => match.id),
+    const preloads = this._preloads
+    const invalidIds = new Set(
+      [
+        ...committedMatches,
+        ...this._cache.values(),
+        ...[...(preloads?.values() ?? [])].flat(),
+        ...(this._tx?.[3 /* matches */] ?? []),
+      ]
+        .filter(
+          (match) => !filter || filter(match as MakeRouteMatchUnion<this>),
         )
-      : undefined
+        .map((match) => match.id),
+    )
+    const discardedPreloads: Array<AbortController> = []
+    for (const [controller, matches] of preloads ?? []) {
+      if (matches.some((match) => invalidIds.has(match.id))) {
+        preloads!.delete(controller)
+        discardedPreloads.push(controller)
+      }
+    }
     const invalidate = (d: MakeRouteMatch<TRouteTree>) => {
-      if (!invalidIds || invalidIds.has(d.id)) {
+      if (invalidIds.has(d.id)) {
         const route = this.routesById[d.routeId] as AnyRoute
         const next = {
           ...d,
@@ -2496,13 +2510,25 @@ export class RouterCore<
       return d
     }
 
-    const committed = committedMatches.map(invalidate)
-    this._committed = committed
-    const cache = new Map<string, AnyRouteMatch>()
+    this._committed = committedMatches.map(invalidate)
+    // Cache entries are settled successes. Retiring matching active preload
+    // owners makes an in-place stale mark sufficient while preserving data.
     for (const [id, match] of this._cache) {
-      cache.set(id, invalidate(match))
+      if (invalidIds.has(id)) {
+        match.invalid = true
+        if (opts?.forcePending) {
+          match.status = 'pending'
+        }
+      }
+    }
+    // The superseding load must not discover any same-ID generation selected
+    // for replacement. Existing owners release it in their normal order.
+    for (const id of invalidIds) {
+      this._flights?.delete(id)
+    }
+    for (const controller of discardedPreloads) {
+      controller.abort()
     }
-    this._cache = cache
 
     this.shouldViewTransition = false
     return this.load({ sync: opts?.sync })
@@ -2554,37 +2580,54 @@ export class RouterCore<
     const cached = this._cache
     const preloads = this._preloads
     const filter = opts?.filter
-    const retained = new Map<string, AnyRouteMatch>()
     const discarded: Array<AnyRouteMatch> = []
+    const discardedIds: Array<string> = []
     for (const [id, match] of cached) {
-      if (filter && !filter(match as MakeRouteMatchUnion<this>)) {
-        retained.set(id, match)
-      } else {
+      if (!filter || filter(match as MakeRouteMatchUnion<this>)) {
+        discardedIds.push(id)
         discarded.push(match)
       }
     }
-    const retainedPreloads = new Map<string, ActivePreload>()
-    const discardedPreloads: Array<ActivePreload> = []
-    for (const [href, preload] of preloads ?? []) {
-      if (!filter || preload[0].some(filter as any)) {
-        discardedPreloads.push(preload)
-        discarded.push(...preload[0])
-      } else {
-        retainedPreloads.set(href, preload)
+    const abort: Array<AbortController> = []
+    for (const [controller, matches] of preloads ?? []) {
+      if (!filter || matches.some(filter as any)) {
+        abort.push(controller)
+        discarded.push(...matches)
       }
     }
 
-    // Install both replacement authorities before releasing a public loader
+    // Run every public filter before changing authority, then prune both maps
+    // before releasing a public loader
     // signal, whose abort listeners can synchronously reenter the router.
-    this._cache = retained
-    this._preloads = retainedPreloads
-    transferMatchResources(this, discarded)
-    for (const preload of discardedPreloads) {
-      preload[1].abort()
+    for (const id of discardedIds) {
+      cached.delete(id)
+    }
+    for (const controller of abort) {
+      preloads!.delete(controller)
+    }
+    // clearCache is a force-retirement boundary, so a final discarded lease
+    // must not use the normal zero-owner handoff window.
+    for (const match of discarded as Array<
+      AnyRouteMatch & { _flight?: LoaderFlight }
+    >) {
+      const flight = match._flight
+      match._flight = undefined
+      if (flight && !--flight[2 /* leases */]) {
+        if (this._flights?.get(match.id) === flight) {
+          this._flights.delete(match.id)
+        }
+        abort.push(flight[1 /* controller */])
+      }
+    }
+    for (const controller of abort) {
+      controller.abort()
     }
   }
 
-  loadRouteChunk = loadRouteChunk
+  loadRouteChunk: (
+    route: AnyRoute,
+    componentType?: 'errorComponent' | 'notFoundComponent' | false,
+  ) => Promise<void> | undefined = loadRouteChunk
 
   preloadRoute: PreloadRouteFn<
     TRouteTree,