@tanstack/react-router 1.87.0 → 1.87.2

package/dist/cjs/awaited.cjs

@@ -29,30 +29,30 @@ function useAwaited({
 }) {
   var _a, _b;
   const router$1 = useRouter.useRouter();
-  const promise = _promise;
-  defer.defer(promise);
-  if (promise.status === "pending") {
+  const promise = defer.defer(_promise);
+  if (promise[defer.TSR_DEFERRED_PROMISE].status === "pending") {
     throw promise;
   }
-  if (promise.status === "error") {
+  if (promise[defer.TSR_DEFERRED_PROMISE].status === "error") {
     if (typeof document !== "undefined") {
-      if (isServerSideError.isServerSideError(promise.error)) {
-        throw (((_a = router$1.options.errorSerializer) == null ? void 0 : _a.deserialize) ?? isServerSideError.defaultDeserializeError)(promise.error.data);
+      if (isServerSideError.isServerSideError(promise[defer.TSR_DEFERRED_PROMISE].error)) {
+        throw (((_a = router$1.options.errorSerializer) == null ? void 0 : _a.deserialize) ?? isServerSideError.defaultDeserializeError)(promise[defer.TSR_DEFERRED_PROMISE].error.data);
       } else {
         warning(
           false,
           "Encountered a server-side error that doesn't fit the expected shape"
         );
-        throw promise.error;
+        throw promise[defer.TSR_DEFERRED_PROMISE].error;
       }
     } else {
       throw {
-        data: (((_b = router$1.options.errorSerializer) == null ? void 0 : _b.serialize) ?? router.defaultSerializeError)(promise.error),
+        data: (((_b = router$1.options.errorSerializer) == null ? void 0 : _b.serialize) ?? router.defaultSerializeError)(promise[defer.TSR_DEFERRED_PROMISE].error),
         __isServerError: true
       };
     }
   }
-  return [promise.data, promise];
+  console.log("useAwaited", promise[defer.TSR_DEFERRED_PROMISE]);
+  return [promise[defer.TSR_DEFERRED_PROMISE].data, promise];
 }
 function Await(props) {
   const inner = /* @__PURE__ */ jsxRuntime.jsx(AwaitInner, { ...props });
@@ -63,6 +63,7 @@ function Await(props) {
 }
 function AwaitInner(props) {
   const [data] = useAwaited(props);
+  console.log("AwaitInner", data);
   return props.children(data);
 }
 exports.Await = Await;

package/dist/cjs/awaited.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"awaited.cjs","sources":["../../src/awaited.tsx"],"sourcesContent":["import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { useRouter } from './useRouter'\nimport { defaultSerializeError } from './router'\nimport { defer } from './defer'\nimport { defaultDeserializeError, isServerSideError } from './isServerSideError'\nimport type { DeferredPromise } from './defer'\n\nexport type AwaitOptions<T> = {\n  promise: Promise<T>\n}\n\nexport function useAwaited<T>({\n  promise: _promise,\n}: AwaitOptions<T>): [T, DeferredPromise<T>] {\n  const router = useRouter()\n  const promise = _promise as DeferredPromise<T>\n\n  defer(promise)\n\n  if (promise.status === 'pending') {\n    throw promise\n  }\n\n  if (promise.status === 'error') {\n    if (typeof document !== 'undefined') {\n      if (isServerSideError(promise.error)) {\n        throw (\n          router.options.errorSerializer?.deserialize ?? defaultDeserializeError\n        )(promise.error.data as any)\n      } else {\n        warning(\n          false,\n          \"Encountered a server-side error that doesn't fit the expected shape\",\n        )\n        throw promise.error\n      }\n    } else {\n      throw {\n        data: (\n          router.options.errorSerializer?.serialize ?? defaultSerializeError\n        )(promise.error),\n        __isServerError: true,\n      }\n    }\n  }\n\n  return [promise.data as any, promise]\n}\n\nexport function Await<T>(\n  props: AwaitOptions<T> & {\n    fallback?: React.ReactNode\n    children: (result: T) => React.ReactNode\n  },\n) {\n  const inner = <AwaitInner {...props} />\n  if (props.fallback) {\n    return <React.Suspense fallback={props.fallback}>{inner}</React.Suspense>\n  }\n  return inner\n}\n\nfunction AwaitInner<T>(\n  props: AwaitOptions<T> & {\n    fallback?: React.ReactNode\n    children: (result: T) => React.ReactNode\n  },\n): React.JSX.Element {\n  const [data] = useAwaited(props)\n  return props.children(data) as React.JSX.Element\n}\n"],"names":["router","useRouter","defer","isServerSideError","defaultDeserializeError","defaultSerializeError","jsx","React"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAYO,SAAS,WAAc;AAAA,EAC5B,SAAS;AACX,GAA6C;;AAC3C,QAAMA,WAASC,UAAAA,UAAU;AACzB,QAAM,UAAU;AAEhBC,QAAAA,MAAM,OAAO;AAET,MAAA,QAAQ,WAAW,WAAW;AAC1B,UAAA;AAAA,EAAA;AAGJ,MAAA,QAAQ,WAAW,SAAS;AAC1B,QAAA,OAAO,aAAa,aAAa;AAC/B,UAAAC,kBAAA,kBAAkB,QAAQ,KAAK,GAAG;AACpC,iBACEH,cAAO,QAAQ,oBAAfA,mBAAgC,gBAAeI,2CAC/C,QAAQ,MAAM,IAAW;AAAA,MAAA,OACtB;AACL;AAAA,UACE;AAAA,UACA;AAAA,QACF;AACA,cAAM,QAAQ;AAAA,MAAA;AAAA,IAChB,OACK;AACC,YAAA;AAAA,QACJ,SACEJ,cAAO,QAAQ,oBAAfA,mBAAgC,cAAaK,OAAA,uBAC7C,QAAQ,KAAK;AAAA,QACf,iBAAiB;AAAA,MACnB;AAAA,IAAA;AAAA,EACF;AAGK,SAAA,CAAC,QAAQ,MAAa,OAAO;AACtC;AAEO,SAAS,MACd,OAIA;AACA,QAAM,QAAQC,2BAAA,IAAC,YAAY,EAAA,GAAG,MAAO,CAAA;AACrC,MAAI,MAAM,UAAU;AAClB,0CAAQC,iBAAM,UAAN,EAAe,UAAU,MAAM,UAAW,UAAM,OAAA;AAAA,EAAA;AAEnD,SAAA;AACT;AAEA,SAAS,WACP,OAImB;AACnB,QAAM,CAAC,IAAI,IAAI,WAAW,KAAK;AACxB,SAAA,MAAM,SAAS,IAAI;AAC5B;;;"}
+{"version":3,"file":"awaited.cjs","sources":["../../src/awaited.tsx"],"sourcesContent":["import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { useRouter } from './useRouter'\nimport { defaultSerializeError } from './router'\nimport { TSR_DEFERRED_PROMISE, defer } from './defer'\nimport { defaultDeserializeError, isServerSideError } from './isServerSideError'\nimport type { DeferredPromise } from './defer'\n\nexport type AwaitOptions<T> = {\n  promise: Promise<T>\n}\n\nexport function useAwaited<T>({\n  promise: _promise,\n}: AwaitOptions<T>): [T, DeferredPromise<T>] {\n  const router = useRouter()\n  const promise = defer(_promise)\n\n  if (promise[TSR_DEFERRED_PROMISE].status === 'pending') {\n    throw promise\n  }\n\n  if (promise[TSR_DEFERRED_PROMISE].status === 'error') {\n    if (typeof document !== 'undefined') {\n      if (isServerSideError(promise[TSR_DEFERRED_PROMISE].error)) {\n        throw (\n          router.options.errorSerializer?.deserialize ?? defaultDeserializeError\n        )(promise[TSR_DEFERRED_PROMISE].error.data as any)\n      } else {\n        warning(\n          false,\n          \"Encountered a server-side error that doesn't fit the expected shape\",\n        )\n        throw promise[TSR_DEFERRED_PROMISE].error\n      }\n    } else {\n      throw {\n        data: (\n          router.options.errorSerializer?.serialize ?? defaultSerializeError\n        )(promise[TSR_DEFERRED_PROMISE].error),\n        __isServerError: true,\n      }\n    }\n  }\n  console.log('useAwaited', promise[TSR_DEFERRED_PROMISE])\n  return [promise[TSR_DEFERRED_PROMISE].data, promise]\n}\n\nexport function Await<T>(\n  props: AwaitOptions<T> & {\n    fallback?: React.ReactNode\n    children: (result: T) => React.ReactNode\n  },\n) {\n  const inner = <AwaitInner {...props} />\n  if (props.fallback) {\n    return <React.Suspense fallback={props.fallback}>{inner}</React.Suspense>\n  }\n  return inner\n}\n\nfunction AwaitInner<T>(\n  props: AwaitOptions<T> & {\n    fallback?: React.ReactNode\n    children: (result: T) => React.ReactNode\n  },\n): React.JSX.Element {\n  const [data] = useAwaited(props)\n  console.log('AwaitInner', data)\n\n  return props.children(data) as React.JSX.Element\n}\n"],"names":["router","useRouter","defer","TSR_DEFERRED_PROMISE","isServerSideError","defaultDeserializeError","defaultSerializeError","jsx","React"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAYO,SAAS,WAAc;AAAA,EAC5B,SAAS;AACX,GAA6C;;AAC3C,QAAMA,WAASC,UAAAA,UAAU;AACnB,QAAA,UAAUC,YAAM,QAAQ;AAE9B,MAAI,QAAQC,MAAAA,oBAAoB,EAAE,WAAW,WAAW;AAChD,UAAA;AAAA,EAAA;AAGR,MAAI,QAAQA,MAAAA,oBAAoB,EAAE,WAAW,SAAS;AAChD,QAAA,OAAO,aAAa,aAAa;AACnC,UAAIC,kBAAkB,kBAAA,QAAQD,0BAAoB,EAAE,KAAK,GAAG;AAExD,iBAAAH,cAAO,QAAQ,oBAAfA,mBAAgC,gBAAeK,2CAC/C,QAAQF,MAAoB,oBAAA,EAAE,MAAM,IAAW;AAAA,MAAA,OAC5C;AACL;AAAA,UACE;AAAA,UACA;AAAA,QACF;AACM,cAAA,QAAQA,MAAoB,oBAAA,EAAE;AAAA,MAAA;AAAA,IACtC,OACK;AACC,YAAA;AAAA,QACJ,SACEH,cAAO,QAAQ,oBAAfA,mBAAgC,cAAaM,OAAAA,uBAC7C,QAAQH,0BAAoB,EAAE,KAAK;AAAA,QACrC,iBAAiB;AAAA,MACnB;AAAA,IAAA;AAAA,EACF;AAEF,UAAQ,IAAI,cAAc,QAAQA,MAAoB,oBAAA,CAAC;AACvD,SAAO,CAAC,QAAQA,MAAAA,oBAAoB,EAAE,MAAM,OAAO;AACrD;AAEO,SAAS,MACd,OAIA;AACA,QAAM,QAAQI,2BAAA,IAAC,YAAY,EAAA,GAAG,MAAO,CAAA;AACrC,MAAI,MAAM,UAAU;AAClB,0CAAQC,iBAAM,UAAN,EAAe,UAAU,MAAM,UAAW,UAAM,OAAA;AAAA,EAAA;AAEnD,SAAA;AACT;AAEA,SAAS,WACP,OAImB;AACnB,QAAM,CAAC,IAAI,IAAI,WAAW,KAAK;AACvB,UAAA,IAAI,cAAc,IAAI;AAEvB,SAAA,MAAM,SAAS,IAAI;AAC5B;;;"}

package/dist/cjs/defer.cjs

@@ -1,24 +1,26 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const router = require("./router.cjs");
+const TSR_DEFERRED_PROMISE = Symbol.for("TSR_DEFERRED_PROMISE");
 function defer(_promise, options) {
   const promise = _promise;
-  if (!promise.status) {
-    Object.assign(promise, {
-      status: "pending"
-    });
-    promise.then((data) => {
-      promise.status = "success";
-      promise.data = data;
-    }).catch((error) => {
-      promise.status = "error";
-      promise.error = {
-        data: ((options == null ? void 0 : options.serializeError) ?? router.defaultSerializeError)(error),
-        __isServerError: true
-      };
-    });
+  if (promise[TSR_DEFERRED_PROMISE]) {
+    return promise;
   }
+  promise[TSR_DEFERRED_PROMISE] = { status: "pending" };
+  promise.then((data) => {
+    promise[TSR_DEFERRED_PROMISE].status = "success";
+    promise[TSR_DEFERRED_PROMISE].data = data;
+    console.log("defer then", promise[TSR_DEFERRED_PROMISE]);
+  }).catch((error) => {
+    promise[TSR_DEFERRED_PROMISE].status = "error";
+    promise[TSR_DEFERRED_PROMISE].error = {
+      data: ((options == null ? void 0 : options.serializeError) ?? router.defaultSerializeError)(error),
+      __isServerError: true
+    };
+  });
   return promise;
 }
+exports.TSR_DEFERRED_PROMISE = TSR_DEFERRED_PROMISE;
 exports.defer = defer;
 //# sourceMappingURL=defer.cjs.map

package/dist/cjs/defer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"defer.cjs","sources":["../../src/defer.ts"],"sourcesContent":["import { defaultSerializeError } from './router'\n\nexport type DeferredPromiseState<T> = {\n  uid: string\n  resolve?: () => void\n  reject?: () => void\n} & (\n  | {\n      status: 'pending'\n      data?: T\n      error?: unknown\n    }\n  | {\n      status: 'success'\n      data: T\n    }\n  | {\n      status: 'error'\n      data?: T\n      error: unknown\n    }\n)\n\nexport type DeferredPromise<T> = Promise<T> & DeferredPromiseState<T>\n\nexport function defer<T>(\n  _promise: Promise<T>,\n  options?: {\n    serializeError?: typeof defaultSerializeError\n  },\n) {\n  const promise = _promise as DeferredPromise<T>\n\n  if (!(promise as any).status) {\n    Object.assign(promise, {\n      status: 'pending',\n    })\n\n    promise\n      .then((data) => {\n        promise.status = 'success' as any\n        promise.data = data\n      })\n      .catch((error) => {\n        promise.status = 'error' as any\n        ;(promise as any).error = {\n          data: (options?.serializeError ?? defaultSerializeError)(error),\n          __isServerError: true,\n        }\n      })\n  }\n\n  return promise\n}\n"],"names":["defaultSerializeError"],"mappings":";;;AAyBgB,SAAA,MACd,UACA,SAGA;AACA,QAAM,UAAU;AAEZ,MAAA,CAAE,QAAgB,QAAQ;AAC5B,WAAO,OAAO,SAAS;AAAA,MACrB,QAAQ;AAAA,IAAA,CACT;AAGE,YAAA,KAAK,CAAC,SAAS;AACd,cAAQ,SAAS;AACjB,cAAQ,OAAO;AAAA,IAAA,CAChB,EACA,MAAM,CAAC,UAAU;AAChB,cAAQ,SAAS;AACf,cAAgB,QAAQ;AAAA,QACxB,QAAO,mCAAS,mBAAkBA,OAAAA,uBAAuB,KAAK;AAAA,QAC9D,iBAAiB;AAAA,MACnB;AAAA,IAAA,CACD;AAAA,EAAA;AAGE,SAAA;AACT;;"}
+{"version":3,"file":"defer.cjs","sources":["../../src/defer.ts"],"sourcesContent":["import { defaultSerializeError } from './router'\n\nexport const TSR_DEFERRED_PROMISE = Symbol.for('TSR_DEFERRED_PROMISE')\n\nexport type DeferredPromiseState<T> = {\n  [TSR_DEFERRED_PROMISE]:\n    | {\n        status: 'pending'\n        data?: T\n        error?: unknown\n      }\n    | {\n        status: 'success'\n        data: T\n      }\n    | {\n        status: 'error'\n        data?: T\n        error: unknown\n      }\n}\n\nexport type DeferredPromise<T> = Promise<T> & DeferredPromiseState<T>\n\nexport function defer<T>(\n  _promise: Promise<T>,\n  options?: {\n    serializeError?: typeof defaultSerializeError\n  },\n) {\n  const promise = _promise as DeferredPromise<T>\n  // this is already deferred promise\n  if ((promise as any)[TSR_DEFERRED_PROMISE]) {\n    return promise\n  }\n  promise[TSR_DEFERRED_PROMISE] = { status: 'pending' }\n\n  promise\n    .then((data) => {\n      promise[TSR_DEFERRED_PROMISE].status = 'success'\n      promise[TSR_DEFERRED_PROMISE].data = data\n      console.log('defer then', promise[TSR_DEFERRED_PROMISE])\n    })\n    .catch((error) => {\n      promise[TSR_DEFERRED_PROMISE].status = 'error'\n      ;(promise[TSR_DEFERRED_PROMISE] as any).error = {\n        data: (options?.serializeError ?? defaultSerializeError)(error),\n        __isServerError: true,\n      }\n    })\n\n  return promise\n}\n"],"names":["defaultSerializeError"],"mappings":";;;AAEa,MAAA,uBAAuB,OAAO,IAAI,sBAAsB;AAsBrD,SAAA,MACd,UACA,SAGA;AACA,QAAM,UAAU;AAEX,MAAA,QAAgB,oBAAoB,GAAG;AACnC,WAAA;AAAA,EAAA;AAET,UAAQ,oBAAoB,IAAI,EAAE,QAAQ,UAAU;AAGjD,UAAA,KAAK,CAAC,SAAS;AACN,YAAA,oBAAoB,EAAE,SAAS;AAC/B,YAAA,oBAAoB,EAAE,OAAO;AACrC,YAAQ,IAAI,cAAc,QAAQ,oBAAoB,CAAC;AAAA,EAAA,CACxD,EACA,MAAM,CAAC,UAAU;AACR,YAAA,oBAAoB,EAAE,SAAS;AACrC,YAAQ,oBAAoB,EAAU,QAAQ;AAAA,MAC9C,QAAO,mCAAS,mBAAkBA,OAAAA,uBAAuB,KAAK;AAAA,MAC9D,iBAAiB;AAAA,IACnB;AAAA,EAAA,CACD;AAEI,SAAA;AACT;;;"}

package/dist/cjs/defer.d.cts

@@ -1,20 +1,19 @@
 import { defaultSerializeError } from './router.cjs';
+export declare const TSR_DEFERRED_PROMISE: unique symbol;
 export type DeferredPromiseState<T> = {
-    uid: string;
-    resolve?: () => void;
-    reject?: () => void;
-} & ({
-    status: 'pending';
-    data?: T;
-    error?: unknown;
-} | {
-    status: 'success';
-    data: T;
-} | {
-    status: 'error';
-    data?: T;
-    error: unknown;
-});
+    [TSR_DEFERRED_PROMISE]: {
+        status: 'pending';
+        data?: T;
+        error?: unknown;
+    } | {
+        status: 'success';
+        data: T;
+    } | {
+        status: 'error';
+        data?: T;
+        error: unknown;
+    };
+};
 export type DeferredPromise<T> = Promise<T> & DeferredPromiseState<T>;
 export declare function defer<T>(_promise: Promise<T>, options?: {
     serializeError?: typeof defaultSerializeError;

package/dist/cjs/index.cjs

@@ -60,6 +60,7 @@ exports.warning = warning;
 exports.Await = awaited.Await;
 exports.useAwaited = awaited.useAwaited;
 exports.ScriptOnce = ScriptOnce.ScriptOnce;
+exports.TSR_DEFERRED_PROMISE = defer.TSR_DEFERRED_PROMISE;
 exports.defer = defer.defer;
 exports.CatchBoundary = CatchBoundary.CatchBoundary;
 exports.ErrorComponent = CatchBoundary.ErrorComponent;

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -5,7 +5,7 @@ export { default as warning } from 'tiny-warning';
 export { useAwaited, Await } from './awaited.cjs';
 export type { AwaitOptions } from './awaited.cjs';
 export { ScriptOnce } from './ScriptOnce.cjs';
-export { defer } from './defer.cjs';
+export { defer, TSR_DEFERRED_PROMISE } from './defer.cjs';
 export type { DeferredPromiseState, DeferredPromise } from './defer.cjs';
 export { CatchBoundary, ErrorComponent } from './CatchBoundary.cjs';
 export { FileRoute, createFileRoute, FileRouteLoader, LazyRoute, createLazyRoute, createLazyFileRoute, } from './fileRoute.cjs';
@@ -34,7 +34,7 @@ export { RouteApi, getRouteApi, Route, createRoute, RootRoute, rootRouteWithCont
 export type { AnyPathParams, ResolveParams, SearchSchemaInput, AnyContext, RouteContext, PreloadableObj, RoutePathOptions, StaticDataRouteOption, RoutePathOptionsIntersection, RouteOptions, FileBaseRouteOptions, BaseRouteOptions, UpdatableRouteOptions, UpdatableStaticRouteOption, MetaDescriptor, RouteLinkEntry, ParseParamsFn, RouteLoaderFn, LoaderFnContext, SearchFilter, ResolveId, InferFullSearchSchema, InferFullSearchSchemaInput, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, AnyRoute, RouteConstraints, AnyRootRoute, ResolveFullPath, RouteMask, ErrorRouteProps, ErrorComponentProps, NotFoundRouteProps, ReactNode, SyncRouteComponent, AsyncRouteComponent, RouteComponent, ErrorRouteComponent, NotFoundRouteComponent, TrimPath, TrimPathLeft, TrimPathRight, RootRouteOptions, AnyRouteWithContext, ParseSplatParams, SplatParams, StringifyParamsFn, ParamsOptions, FullSearchSchemaOption, RouteContextFn, RouteContextOptions, BeforeLoadFn, BeforeLoadContextOptions, ContextOptions, InferAllParams, InferAllContext, LooseReturnType, LooseAsyncReturnType, ContextReturnType, ContextAsyncReturnType, RouteContextParameter, BeforeLoadContextParameter, ResolveAllContext, ResolveLoaderData, ResolveAllParamsFromParent, ResolveRouteContext, } from './route.cjs';
 export type { ParseRoute, RoutesById, RouteById, RouteIds, RoutesByPath, RouteByPath, RoutePaths, FullSearchSchema, AllParams, AllLoaderData, FullSearchSchemaInput, AllContext, } from './routeInfo.cjs';
 export { componentTypes, createRouter, Router, lazyFn, SearchParamError, PathParamError, getInitialRouterState, defaultSerializeError, } from './router.cjs';
-export type { Register, AnyRouter, RegisteredRouter, HydrationCtx, RouterContextOptions, TrailingSlashOption, RouterOptions, RouterErrorSerializer, RouterState, ListenerFn, BuildNextOptions, DehydratedRouterState, DehydratedRouteMatch, DehydratedRouter, RouterConstructorOptions, RouterEvents, RouterEvent, RouterListener, AnyRouterWithContext, ExtractedEntry, StreamState, } from './router.cjs';
+export type { Register, AnyRouter, RegisteredRouter, HydrationCtx, RouterContextOptions, TrailingSlashOption, RouterOptions, RouterErrorSerializer, RouterState, ListenerFn, BuildNextOptions, DehydratedRouterState, DehydratedRouteMatch, DehydratedRouter, RouterConstructorOptions, RouterEvents, RouterEvent, RouterListener, AnyRouterWithContext, ExtractedEntry, ExtractedStream, ExtractedPromise, StreamState, } from './router.cjs';
 export { RouterProvider, RouterContextProvider } from './RouterProvider.cjs';
 export type { RouterProps, CommitLocationOptions, MatchLocation, NavigateFn, BuildLocationFn, InjectedHtmlEntry, } from './RouterProvider.cjs';
 export { useScrollRestoration, useElementScrollRestoration, ScrollRestoration, } from './scroll-restoration.cjs';

package/dist/cjs/router.cjs

@@ -879,6 +879,7 @@ class Router {
                 const route = this.looseRoutesById[routeId];
                 const pendingMs = route.options.pendingMs ?? this.options.defaultPendingMs;
                 const shouldPending = !!(onReady && !this.isServer && !resolvePreload(matchId) && (route.options.loader || route.options.beforeLoad) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? this.options.defaultPendingComponent));
+                let executeBeforeLoad = true;
                 if (
                   // If we are in the middle of a load, either of these will be present
                   // (not to be confused with `loadPromise`, which is always defined)
@@ -893,7 +894,9 @@ class Router {
                     }, pendingMs);
                   }
                   await existingMatch.beforeLoadPromise;
-                } else {
+                  executeBeforeLoad = this.getMatch(matchId).status !== "success";
+                }
+                if (executeBeforeLoad) {
                   try {
                     updateMatch(matchId, (prev) => ({
                       ...prev,