@tanstack/react-router 1.87.0 → 1.87.2

package/dist/cjs/router.d.cts

@@ -1,4 +1,5 @@
 import { Store, NoInfer } from '@tanstack/react-store';
+import { DeferredPromiseState } from './defer.cjs';
 import { HistoryState, RouterHistory } from '@tanstack/history';
 import { Manifest } from './manifest.cjs';
 import { AnyContext, AnyRoute, AnyRouteWithContext, ErrorRouteComponent, NotFoundRouteComponent, RootRoute, RouteComponent, RouteMask } from './route.cjs';
@@ -44,15 +45,22 @@ export type HydrationCtx = {
     payload: Record<string, any>;
 };
 export type InferRouterContext<TRouteTree extends AnyRoute> = TRouteTree extends RootRoute<any, infer TRouterContext extends AnyContext, any, any, any, any, any, any> ? TRouterContext : AnyContext;
-export type ExtractedEntry = {
+export interface ExtractedBaseEntry {
     dataType: '__beforeLoadContext' | 'loaderData';
-    type: 'promise' | 'stream';
+    type: string;
     path: Array<string>;
-    value: any;
     id: number;
-    streamState?: StreamState;
     matchIndex: number;
-};
+}
+export interface ExtractedStream extends ExtractedBaseEntry {
+    type: 'stream';
+    streamState: StreamState;
+}
+export interface ExtractedPromise extends ExtractedBaseEntry {
+    type: 'promise';
+    promiseState: DeferredPromiseState<any>;
+}
+export type ExtractedEntry = ExtractedStream | ExtractedPromise;
 export type StreamState = {
     promises: Array<ControlledPromise<string | null>>;
 };

package/dist/esm/awaited.js

@@ -3,37 +3,37 @@ import * as React from "react";
 import warning from "tiny-warning";
 import { useRouter } from "./useRouter.js";
 import { defaultSerializeError } from "./router.js";
-import { defer } from "./defer.js";
+import { defer, TSR_DEFERRED_PROMISE } from "./defer.js";
 import { isServerSideError, defaultDeserializeError } from "./isServerSideError.js";
 function useAwaited({
   promise: _promise
 }) {
   var _a, _b;
   const router = useRouter();
-  const promise = _promise;
-  defer(promise);
-  if (promise.status === "pending") {
+  const promise = defer(_promise);
+  if (promise[TSR_DEFERRED_PROMISE].status === "pending") {
     throw promise;
   }
-  if (promise.status === "error") {
+  if (promise[TSR_DEFERRED_PROMISE].status === "error") {
     if (typeof document !== "undefined") {
-      if (isServerSideError(promise.error)) {
-        throw (((_a = router.options.errorSerializer) == null ? void 0 : _a.deserialize) ?? defaultDeserializeError)(promise.error.data);
+      if (isServerSideError(promise[TSR_DEFERRED_PROMISE].error)) {
+        throw (((_a = router.options.errorSerializer) == null ? void 0 : _a.deserialize) ?? defaultDeserializeError)(promise[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[TSR_DEFERRED_PROMISE].error;
       }
     } else {
       throw {
-        data: (((_b = router.options.errorSerializer) == null ? void 0 : _b.serialize) ?? defaultSerializeError)(promise.error),
+        data: (((_b = router.options.errorSerializer) == null ? void 0 : _b.serialize) ?? defaultSerializeError)(promise[TSR_DEFERRED_PROMISE].error),
         __isServerError: true
       };
     }
   }
-  return [promise.data, promise];
+  console.log("useAwaited", promise[TSR_DEFERRED_PROMISE]);
+  return [promise[TSR_DEFERRED_PROMISE].data, promise];
 }
 function Await(props) {
   const inner = /* @__PURE__ */ jsx(AwaitInner, { ...props });
@@ -44,6 +44,7 @@ function Await(props) {
 }
 function AwaitInner(props) {
   const [data] = useAwaited(props);
+  console.log("AwaitInner", data);
   return props.children(data);
 }
 export {

package/dist/esm/awaited.js.map

@@ -1 +1 @@
-{"version":3,"file":"awaited.js","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":[],"mappings":";;;;;;;AAYO,SAAS,WAAc;AAAA,EAC5B,SAAS;AACX,GAA6C;;AAC3C,QAAM,SAAS,UAAU;AACzB,QAAM,UAAU;AAEhB,QAAM,OAAO;AAET,MAAA,QAAQ,WAAW,WAAW;AAC1B,UAAA;AAAA,EAAA;AAGJ,MAAA,QAAQ,WAAW,SAAS;AAC1B,QAAA,OAAO,aAAa,aAAa;AAC/B,UAAA,kBAAkB,QAAQ,KAAK,GAAG;AACpC,iBACE,YAAO,QAAQ,oBAAf,mBAAgC,gBAAe,yBAC/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,SACE,YAAO,QAAQ,oBAAf,mBAAgC,cAAa,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,QAAQ,oBAAC,YAAY,EAAA,GAAG,MAAO,CAAA;AACrC,MAAI,MAAM,UAAU;AAClB,+BAAQ,MAAM,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.js","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":[],"mappings":";;;;;;;AAYO,SAAS,WAAc;AAAA,EAC5B,SAAS;AACX,GAA6C;;AAC3C,QAAM,SAAS,UAAU;AACnB,QAAA,UAAU,MAAM,QAAQ;AAE9B,MAAI,QAAQ,oBAAoB,EAAE,WAAW,WAAW;AAChD,UAAA;AAAA,EAAA;AAGR,MAAI,QAAQ,oBAAoB,EAAE,WAAW,SAAS;AAChD,QAAA,OAAO,aAAa,aAAa;AACnC,UAAI,kBAAkB,QAAQ,oBAAoB,EAAE,KAAK,GAAG;AAExD,iBAAA,YAAO,QAAQ,oBAAf,mBAAgC,gBAAe,yBAC/C,QAAQ,oBAAoB,EAAE,MAAM,IAAW;AAAA,MAAA,OAC5C;AACL;AAAA,UACE;AAAA,UACA;AAAA,QACF;AACM,cAAA,QAAQ,oBAAoB,EAAE;AAAA,MAAA;AAAA,IACtC,OACK;AACC,YAAA;AAAA,QACJ,SACE,YAAO,QAAQ,oBAAf,mBAAgC,cAAa,uBAC7C,QAAQ,oBAAoB,EAAE,KAAK;AAAA,QACrC,iBAAiB;AAAA,MACnB;AAAA,IAAA;AAAA,EACF;AAEF,UAAQ,IAAI,cAAc,QAAQ,oBAAoB,CAAC;AACvD,SAAO,CAAC,QAAQ,oBAAoB,EAAE,MAAM,OAAO;AACrD;AAEO,SAAS,MACd,OAIA;AACA,QAAM,QAAQ,oBAAC,YAAY,EAAA,GAAG,MAAO,CAAA;AACrC,MAAI,MAAM,UAAU;AAClB,+BAAQ,MAAM,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/esm/defer.d.ts

@@ -1,20 +1,19 @@
 import { defaultSerializeError } from './router.js';
+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/esm/defer.js

@@ -1,24 +1,26 @@
 import { defaultSerializeError } from "./router.js";
+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) ?? 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) ?? defaultSerializeError)(error),
+      __isServerError: true
+    };
+  });
   return promise;
 }
 export {
+  TSR_DEFERRED_PROMISE,
   defer
 };
 //# sourceMappingURL=defer.js.map

package/dist/esm/defer.js.map

@@ -1 +1 @@
-{"version":3,"file":"defer.js","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":[],"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,mBAAkB,uBAAuB,KAAK;AAAA,QAC9D,iBAAiB;AAAA,MACnB;AAAA,IAAA,CACD;AAAA,EAAA;AAGE,SAAA;AACT;"}
+{"version":3,"file":"defer.js","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":[],"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,mBAAkB,uBAAuB,KAAK;AAAA,MAC9D,iBAAiB;AAAA,IACnB;AAAA,EAAA,CACD;AAEI,SAAA;AACT;"}

package/dist/esm/index.d.ts

@@ -5,7 +5,7 @@ export { default as warning } from 'tiny-warning';
 export { useAwaited, Await } from './awaited.js';
 export type { AwaitOptions } from './awaited.js';
 export { ScriptOnce } from './ScriptOnce.js';
-export { defer } from './defer.js';
+export { defer, TSR_DEFERRED_PROMISE } from './defer.js';
 export type { DeferredPromiseState, DeferredPromise } from './defer.js';
 export { CatchBoundary, ErrorComponent } from './CatchBoundary.js';
 export { FileRoute, createFileRoute, FileRouteLoader, LazyRoute, createLazyRoute, createLazyFileRoute, } from './fileRoute.js';
@@ -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.js';
 export type { ParseRoute, RoutesById, RouteById, RouteIds, RoutesByPath, RouteByPath, RoutePaths, FullSearchSchema, AllParams, AllLoaderData, FullSearchSchemaInput, AllContext, } from './routeInfo.js';
 export { componentTypes, createRouter, Router, lazyFn, SearchParamError, PathParamError, getInitialRouterState, defaultSerializeError, } from './router.js';
-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.js';
+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.js';
 export { RouterProvider, RouterContextProvider } from './RouterProvider.js';
 export type { RouterProps, CommitLocationOptions, MatchLocation, NavigateFn, BuildLocationFn, InjectedHtmlEntry, } from './RouterProvider.js';
 export { useScrollRestoration, useElementScrollRestoration, ScrollRestoration, } from './scroll-restoration.js';

package/dist/esm/index.js

@@ -3,7 +3,7 @@ import { default as default2 } from "tiny-invariant";
 import { default as default3 } from "tiny-warning";
 import { Await, useAwaited } from "./awaited.js";
 import { ScriptOnce } from "./ScriptOnce.js";
-import { defer } from "./defer.js";
+import { TSR_DEFERRED_PROMISE, defer } from "./defer.js";
 import { CatchBoundary, ErrorComponent } from "./CatchBoundary.js";
 import { FileRoute, FileRouteLoader, LazyRoute, createFileRoute, createLazyFileRoute, createLazyRoute } from "./fileRoute.js";
 import { lazyRouteComponent } from "./lazyRouteComponent.js";
@@ -64,6 +64,7 @@ export {
   ScriptOnce,
   ScrollRestoration,
   SearchParamError,
+  TSR_DEFERRED_PROMISE,
   cleanPath,
   componentTypes,
   createBrowserHistory,

package/dist/esm/router.d.ts

@@ -1,4 +1,5 @@
 import { Store, NoInfer } from '@tanstack/react-store';
+import { DeferredPromiseState } from './defer.js';
 import { HistoryState, RouterHistory } from '@tanstack/history';
 import { Manifest } from './manifest.js';
 import { AnyContext, AnyRoute, AnyRouteWithContext, ErrorRouteComponent, NotFoundRouteComponent, RootRoute, RouteComponent, RouteMask } from './route.js';
@@ -44,15 +45,22 @@ export type HydrationCtx = {
     payload: Record<string, any>;
 };
 export type InferRouterContext<TRouteTree extends AnyRoute> = TRouteTree extends RootRoute<any, infer TRouterContext extends AnyContext, any, any, any, any, any, any> ? TRouterContext : AnyContext;
-export type ExtractedEntry = {
+export interface ExtractedBaseEntry {
     dataType: '__beforeLoadContext' | 'loaderData';
-    type: 'promise' | 'stream';
+    type: string;
     path: Array<string>;
-    value: any;
     id: number;
-    streamState?: StreamState;
     matchIndex: number;
-};
+}
+export interface ExtractedStream extends ExtractedBaseEntry {
+    type: 'stream';
+    streamState: StreamState;
+}
+export interface ExtractedPromise extends ExtractedBaseEntry {
+    type: 'promise';
+    promiseState: DeferredPromiseState<any>;
+}
+export type ExtractedEntry = ExtractedStream | ExtractedPromise;
 export type StreamState = {
     promises: Array<ControlledPromise<string | null>>;
 };

package/dist/esm/router.js

@@ -877,6 +877,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)
@@ -891,7 +892,9 @@ class Router {
                     }, pendingMs);
                   }
                   await existingMatch.beforeLoadPromise;
-                } else {
+                  executeBeforeLoad = this.getMatch(matchId).status !== "success";
+                }
+                if (executeBeforeLoad) {
                   try {
                     updateMatch(matchId, (prev) => ({
                       ...prev,