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

package/dist/cjs/load-client.d.cts

@@ -7,7 +7,7 @@ import { AnyRoute } from './route.cjs';
 import { AnyRedirect } from './redirect.cjs';
 import { AnyRouter } from './router.cjs';
 export declare function replaceRouteChunk(route: AnyRoute, lazyFn: AnyRoute['lazyFn']): void;
-export declare function loadRouteChunk(route: AnyRoute, componentType?: 'errorComponent' | 'notFoundComponent' | false): Promise<void> | undefined;
+export declare function loadRouteChunk(route: AnyRoute, componentType?: 'errorComponent' | 'notFoundComponent' | false, onPendingReady?: () => void): Promise<void> | undefined;
 /** Return the structural lane through the first terminal render boundary. */
 export declare function _getRenderedMatches(matches: Array<AnyRouteMatch>): Array<AnyRouteMatch>;
 /** Return the lane whose document assets belong to the current presentation. */
@@ -37,7 +37,7 @@ declare const ERROR = 1;
 declare const NOT_FOUND = 2;
 declare const REDIRECTED = 3;
 declare const CANCELED = 4;
-type LoaderOutcome = [typeof SUCCESS, data: unknown] | [typeof ERROR, error: unknown] | [typeof NOT_FOUND, error: NotFoundError] | [typeof REDIRECTED, redirect: AnyRedirect] | [typeof CANCELED];
+type LoaderOutcome = [kind: typeof SUCCESS, data: unknown] | [kind: typeof ERROR, error: unknown] | [kind: typeof NOT_FOUND, error: NotFoundError] | [kind: typeof REDIRECTED, redirect: AnyRedirect] | [kind: typeof CANCELED];
 type IndexedOutcome = [index: number, outcome: LoaderOutcome, boundary?: number];
 export type LoaderFlight = [
     outcome: Promise<LoaderOutcome>,
@@ -58,27 +58,6 @@ declare const matchPhase: unique symbol;
 type SettledMatch = WorkMatch & {
     readonly [matchPhase]: 'settled';
 };
-export type LaneInputs = [
-    routeTree: AnyRoute,
-    context: unknown,
-    additionalContext: unknown,
-    state: object,
-    search: object,
-    maskedLocation: [
-        href: string,
-        state: object,
-        search: object,
-        unmaskOnReload: boolean | undefined
-    ] | undefined
-];
-export type ActivePreload = [
-    matches: Array<AnyRouteMatch>,
-    controller: AbortController,
-    result: Promise<LaneResult>,
-    semanticOwner: Array<AnyRouteMatch>,
-    inputs: LaneInputs,
-    redirects: number
-];
 export type LoadTransaction = [
     controller: AbortController,
     redirects: number,
@@ -88,12 +67,14 @@ export type LoadTransaction = [
     done: Promise<void>,
     /**
      * Dev-only HMR refresh mode. Presence is the mode flag; a refresh always
-     * carries the presentation it started from, while the hydration handoff is
-     * genuinely optional — the tuple makes a half-armed refresh unrepresentable.
+     * carries the presentation it started from and its optional hydration
+     * handoff. While a publication awaits acknowledgement, its rollback lives
+     * with the transaction that owns the publication.
      */
     refresh?: [
         presentation: Array<AnyRouteMatch>,
-        handoff: NonNullable<AnyRouter['_handoff']> | undefined
+        handoff: NonNullable<AnyRouter['_handoff']> | undefined,
+        rollback?: () => boolean
     ]
 ];
 export type PendingSession = [
@@ -106,34 +87,24 @@ export type PendingSession = [
     component?: unknown
 ];
 type CoordinatorRouter = AnyRouter & {
-    /** Whole speculative lanes that a matching navigation may adopt. */
-    _preloads?: Map<string, ActivePreload>;
+    /** Active speculative lanes retained for cancellation, invalidation, and cache clearing. */
+    _preloads?: Map<AbortController, Array<AnyRouteMatch>>;
     _refreshNextLoad?: boolean;
-    _rollbackRefresh?: () => void;
     _cancelTransition?: () => void;
 };
 type BackgroundLoaderTask = [
     index: number,
     outcome: Promise<LoaderOutcome>,
-    ready: Promise<IndexedOutcome | undefined>,
+    chunkFailure: Promise<IndexedOutcome | undefined>,
     candidate: WorkMatch
 ];
-type ControlOutcome = [typeof REDIRECTED, redirect: AnyRedirect] | [typeof CANCELED];
-type LaneResult = ProjectedLane | ControlOutcome;
 export declare function waitFor<T>(value: T | PromiseLike<T>, signal: AbortSignal): Promise<T>;
 export declare function getRoute(router: AnyRouter, match: WorkMatch): AnyRoute;
 export declare function navigateFrom(router: AnyRouter, location: ParsedLocation): (opts: any) => Promise<void>;
-export declare function laneInputs(router: AnyRouter, location: ParsedLocation): LaneInputs;
-/**
- * Not passing in a `next` ownership recipient
- * is equivalent to discarding the match resources
- */
-export declare function transferMatchResources(router: AnyRouter, previous: Array<AnyRouteMatch>, next?: Array<AnyRouteMatch>): void;
 export declare function cacheLoaderMatch(router: CoordinatorRouter, match: SettledMatch, planned: AnyRouteMatch | undefined): void;
 export declare function projectLane(router: AnyRouter, lane: ReducedLane, signal: AbortSignal, start?: number, end?: number): Promise<ProjectedLane>;
 export declare function loadClientRoute(router: CoordinatorRouter, opts?: {
     sync?: boolean;
-    _dedupe?: boolean;
 }): Promise<void>;
 export declare function refreshClientRoute(router: CoordinatorRouter): Promise<void>;
 export declare function preloadClientRoute(router: CoordinatorRouter, opts: any, redirects?: number): Promise<Array<AnyRouteMatch> | undefined>;

package/dist/cjs/router.cjs

@@ -387,7 +387,7 @@ var RouterCore = class {
 				previousCommitPromise?.resolve();
 			};
 			this._commitPromise = commitPromise;
-			if (isSameLocation) this.load({ _dedupe: true });
+			if (isSameLocation) this.load();
 			else {
 				let { maskedLocation, hashScrollIntoView, ...nextHistory } = next;
 				if (maskedLocation) {
@@ -518,9 +518,20 @@ var RouterCore = class {
 		this.invalidate = (opts) => {
 			const committedMatches = this._committed;
 			const filter = opts?.filter;
-			const invalidIds = filter ? new Set([...committedMatches, ...this._cache.values()].filter((match) => filter(match)).map((match) => match.id)) : void 0;
+			const preloads = this._preloads;
+			const invalidIds = new Set([
+				...committedMatches,
+				...this._cache.values(),
+				...[...preloads?.values() ?? []].flat(),
+				...this._tx?.[3] ?? []
+			].filter((match) => !filter || filter(match)).map((match) => match.id));
+			const discardedPreloads = [];
+			for (const [controller, matches] of preloads ?? []) if (matches.some((match) => invalidIds.has(match.id))) {
+				preloads.delete(controller);
+				discardedPreloads.push(controller);
+			}
 			const invalidate = (d) => {
-				if (!invalidIds || invalidIds.has(d.id)) {
+				if (invalidIds.has(d.id)) {
 					const route = this.routesById[d.routeId];
 					const next = {
 						...d,
@@ -535,11 +546,13 @@ var RouterCore = class {
 				}
 				return d;
 			};
-			const committed = committedMatches.map(invalidate);
-			this._committed = committed;
-			const cache = /* @__PURE__ */ new Map();
-			for (const [id, match] of this._cache) cache.set(id, invalidate(match));
-			this._cache = cache;
+			this._committed = committedMatches.map(invalidate);
+			for (const [id, match] of this._cache) if (invalidIds.has(id)) {
+				match.invalid = true;
+				if (opts?.forcePending) match.status = "pending";
+			}
+			for (const id of invalidIds) this._flights?.delete(id);
+			for (const controller of discardedPreloads) controller.abort();
 			this.shouldViewTransition = false;
 			return this.load({ sync: opts?.sync });
 		};
@@ -565,20 +578,28 @@ var RouterCore = class {
 			const cached = this._cache;
 			const preloads = this._preloads;
 			const filter = opts?.filter;
-			const retained = /* @__PURE__ */ new Map();
 			const discarded = [];
-			for (const [id, match] of cached) if (filter && !filter(match)) retained.set(id, match);
-			else discarded.push(match);
-			const retainedPreloads = /* @__PURE__ */ new Map();
-			const discardedPreloads = [];
-			for (const [href, preload] of preloads ?? []) if (!filter || preload[0].some(filter)) {
-				discardedPreloads.push(preload);
-				discarded.push(...preload[0]);
-			} else retainedPreloads.set(href, preload);
-			this._cache = retained;
-			this._preloads = retainedPreloads;
-			require_load_client.transferMatchResources(this, discarded);
-			for (const preload of discardedPreloads) preload[1].abort();
+			const discardedIds = [];
+			for (const [id, match] of cached) if (!filter || filter(match)) {
+				discardedIds.push(id);
+				discarded.push(match);
+			}
+			const abort = [];
+			for (const [controller, matches] of preloads ?? []) if (!filter || matches.some(filter)) {
+				abort.push(controller);
+				discarded.push(...matches);
+			}
+			for (const id of discardedIds) cached.delete(id);
+			for (const controller of abort) preloads.delete(controller);
+			for (const match of discarded) {
+				const flight = match._flight;
+				match._flight = void 0;
+				if (flight && !--flight[2]) {
+					if (this._flights?.get(match.id) === flight) this._flights.delete(match.id);
+					abort.push(flight[1]);
+				}
+			}
+			for (const controller of abort) controller.abort();
 		};
 		this.loadRouteChunk = require_load_client.loadRouteChunk;
 		this.preloadRoute = (opts) => require_load_client.preloadClientRoute(this, opts);
@@ -931,7 +952,6 @@ function extractStrictParams(route, accumulatedParams) {
 exports.PathParamError = PathParamError;
 exports.RouterCore = RouterCore;
 exports.SearchParamError = SearchParamError;
-exports._getUserHistoryState = _getUserHistoryState;
 exports.defaultSerializeError = defaultSerializeError;
 exports.getInitialRouterState = getInitialRouterState;
 exports.getLocationChangeInfo = getLocationChangeInfo;