@tanstack/react-router 1.162.2 → 1.162.5

package/dist/cjs/RouterProvider.cjs

@@ -18,8 +18,7 @@ function RouterContextProvider({
       }
     });
   }
-  const routerContext$1 = routerContext.getRouterContext();
-  const provider = /* @__PURE__ */ jsxRuntime.jsx(routerContext$1.Provider, { value: router, children });
+  const provider = /* @__PURE__ */ jsxRuntime.jsx(routerContext.routerContext.Provider, { value: router, children });
   if (router.options.Wrap) {
     return /* @__PURE__ */ jsxRuntime.jsx(router.options.Wrap, { children: provider });
   }

package/dist/cjs/RouterProvider.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"RouterProvider.cjs","sources":["../../src/RouterProvider.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Matches } from './Matches'\nimport { getRouterContext } from './routerContext'\nimport type {\n  AnyRouter,\n  RegisteredRouter,\n  RouterOptions,\n} from '@tanstack/router-core'\n\n/**\n * Low-level provider that places the router into React context and optionally\n * updates router options from props. Most apps should use `RouterProvider`.\n */\nexport function RouterContextProvider<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n>({\n  router,\n  children,\n  ...rest\n}: RouterProps<TRouter, TDehydrated> & {\n  children: React.ReactNode\n}) {\n  if (Object.keys(rest).length > 0) {\n    // Allow the router to update options on the router instance\n    router.update({\n      ...router.options,\n      ...rest,\n      context: {\n        ...router.options.context,\n        ...rest.context,\n      },\n    })\n  }\n\n  const routerContext = getRouterContext()\n\n  const provider = (\n    <routerContext.Provider value={router as AnyRouter}>\n      {children}\n    </routerContext.Provider>\n  )\n\n  if (router.options.Wrap) {\n    return <router.options.Wrap>{provider}</router.options.Wrap>\n  }\n\n  return provider\n}\n\n/**\n * Top-level component that renders the active route matches and provides the\n * router to the React tree via context.\n *\n * Accepts the same options as `createRouter` via props to update the router\n * instance after creation.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction\n */\nexport function RouterProvider<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n>({ router, ...rest }: RouterProps<TRouter, TDehydrated>) {\n  return (\n    <RouterContextProvider router={router} {...rest}>\n      <Matches />\n    </RouterContextProvider>\n  )\n}\n\nexport type RouterProps<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n> = Omit<\n  RouterOptions<\n    TRouter['routeTree'],\n    NonNullable<TRouter['options']['trailingSlash']>,\n    NonNullable<TRouter['options']['defaultStructuralSharing']>,\n    TRouter['history'],\n    TDehydrated\n  >,\n  'context'\n> & {\n  router: TRouter\n  context?: Partial<\n    RouterOptions<\n      TRouter['routeTree'],\n      NonNullable<TRouter['options']['trailingSlash']>,\n      NonNullable<TRouter['options']['defaultStructuralSharing']>,\n      TRouter['history'],\n      TDehydrated\n    >['context']\n  >\n}\n"],"names":["routerContext","getRouterContext","jsx","Matches"],"mappings":";;;;;AAaO,SAAS,sBAGd;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,GAEG;AACD,MAAI,OAAO,KAAK,IAAI,EAAE,SAAS,GAAG;AAEhC,WAAO,OAAO;AAAA,MACZ,GAAG,OAAO;AAAA,MACV,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAG,OAAO,QAAQ;AAAA,QAClB,GAAG,KAAK;AAAA,MAAA;AAAA,IACV,CACD;AAAA,EACH;AAEA,QAAMA,kBAAgBC,cAAAA,iBAAA;AAEtB,QAAM,WACJC,2BAAAA,IAACF,gBAAc,UAAd,EAAuB,OAAO,QAC5B,UACH;AAGF,MAAI,OAAO,QAAQ,MAAM;AACvB,WAAOE,2BAAAA,IAAC,OAAO,QAAQ,MAAf,EAAqB,UAAA,UAAS;AAAA,EACxC;AAEA,SAAO;AACT;AAWO,SAAS,eAGd,EAAE,QAAQ,GAAG,QAA2C;AACxD,wCACG,uBAAA,EAAsB,QAAiB,GAAG,MACzC,UAAAA,+BAACC,QAAAA,WAAQ,GACX;AAEJ;;;"}
+{"version":3,"file":"RouterProvider.cjs","sources":["../../src/RouterProvider.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Matches } from './Matches'\nimport { routerContext } from './routerContext'\nimport type {\n  AnyRouter,\n  RegisteredRouter,\n  RouterOptions,\n} from '@tanstack/router-core'\n\n/**\n * Low-level provider that places the router into React context and optionally\n * updates router options from props. Most apps should use `RouterProvider`.\n */\nexport function RouterContextProvider<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n>({\n  router,\n  children,\n  ...rest\n}: RouterProps<TRouter, TDehydrated> & {\n  children: React.ReactNode\n}) {\n  if (Object.keys(rest).length > 0) {\n    // Allow the router to update options on the router instance\n    router.update({\n      ...router.options,\n      ...rest,\n      context: {\n        ...router.options.context,\n        ...rest.context,\n      },\n    })\n  }\n\n  const provider = (\n    <routerContext.Provider value={router as AnyRouter}>\n      {children}\n    </routerContext.Provider>\n  )\n\n  if (router.options.Wrap) {\n    return <router.options.Wrap>{provider}</router.options.Wrap>\n  }\n\n  return provider\n}\n\n/**\n * Top-level component that renders the active route matches and provides the\n * router to the React tree via context.\n *\n * Accepts the same options as `createRouter` via props to update the router\n * instance after creation.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction\n */\nexport function RouterProvider<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n>({ router, ...rest }: RouterProps<TRouter, TDehydrated>) {\n  return (\n    <RouterContextProvider router={router} {...rest}>\n      <Matches />\n    </RouterContextProvider>\n  )\n}\n\nexport type RouterProps<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n> = Omit<\n  RouterOptions<\n    TRouter['routeTree'],\n    NonNullable<TRouter['options']['trailingSlash']>,\n    NonNullable<TRouter['options']['defaultStructuralSharing']>,\n    TRouter['history'],\n    TDehydrated\n  >,\n  'context'\n> & {\n  router: TRouter\n  context?: Partial<\n    RouterOptions<\n      TRouter['routeTree'],\n      NonNullable<TRouter['options']['trailingSlash']>,\n      NonNullable<TRouter['options']['defaultStructuralSharing']>,\n      TRouter['history'],\n      TDehydrated\n    >['context']\n  >\n}\n"],"names":["jsx","routerContext","Matches"],"mappings":";;;;;AAaO,SAAS,sBAGd;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,GAEG;AACD,MAAI,OAAO,KAAK,IAAI,EAAE,SAAS,GAAG;AAEhC,WAAO,OAAO;AAAA,MACZ,GAAG,OAAO;AAAA,MACV,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAG,OAAO,QAAQ;AAAA,QAClB,GAAG,KAAK;AAAA,MAAA;AAAA,IACV,CACD;AAAA,EACH;AAEA,QAAM,WACJA,2BAAAA,IAACC,4BAAc,UAAd,EAAuB,OAAO,QAC5B,UACH;AAGF,MAAI,OAAO,QAAQ,MAAM;AACvB,WAAOD,2BAAAA,IAAC,OAAO,QAAQ,MAAf,EAAqB,UAAA,UAAS;AAAA,EACxC;AAEA,SAAO;AACT;AAWO,SAAS,eAGd,EAAE,QAAQ,GAAG,QAA2C;AACxD,wCACG,uBAAA,EAAsB,QAAiB,GAAG,MACzC,UAAAA,+BAACE,QAAAA,WAAQ,GACX;AAEJ;;;"}

package/dist/cjs/index.cjs

@@ -9,7 +9,6 @@ const fileRoute = require("./fileRoute.cjs");
 const lazyRouteComponent = require("./lazyRouteComponent.cjs");
 const link = require("./link.cjs");
 const Matches = require("./Matches.cjs");
-const matchContext = require("./matchContext.cjs");
 const Match = require("./Match.cjs");
 const useMatch = require("./useMatch.cjs");
 const useLoaderDeps = require("./useLoaderDeps.cjs");
@@ -22,13 +21,11 @@ const useBlocker = require("./useBlocker.cjs");
 const useNavigate = require("./useNavigate.cjs");
 const useParams = require("./useParams.cjs");
 const useSearch = require("./useSearch.cjs");
-const routerContext = require("./routerContext.cjs");
 const useRouteContext = require("./useRouteContext.cjs");
 const useRouter = require("./useRouter.cjs");
 const useRouterState = require("./useRouterState.cjs");
 const useLocation = require("./useLocation.cjs");
 const useCanGoBack = require("./useCanGoBack.cjs");
-const utils = require("./utils.cjs");
 const notFound = require("./not-found.cjs");
 const ScriptOnce = require("./ScriptOnce.cjs");
 const Asset = require("./Asset.cjs");
@@ -39,26 +36,14 @@ Object.defineProperty(exports, "DEFAULT_PROTOCOL_ALLOWLIST", {
   enumerable: true,
   get: () => routerCore.DEFAULT_PROTOCOL_ALLOWLIST
 });
-Object.defineProperty(exports, "PathParamError", {
-  enumerable: true,
-  get: () => routerCore.PathParamError
-});
 Object.defineProperty(exports, "SearchParamError", {
   enumerable: true,
   get: () => routerCore.SearchParamError
 });
-Object.defineProperty(exports, "TSR_DEFERRED_PROMISE", {
-  enumerable: true,
-  get: () => routerCore.TSR_DEFERRED_PROMISE
-});
 Object.defineProperty(exports, "cleanPath", {
   enumerable: true,
   get: () => routerCore.cleanPath
 });
-Object.defineProperty(exports, "componentTypes", {
-  enumerable: true,
-  get: () => routerCore.componentTypes
-});
 Object.defineProperty(exports, "composeRewrites", {
   enumerable: true,
   get: () => routerCore.composeRewrites
@@ -83,10 +68,6 @@ Object.defineProperty(exports, "defaultParseSearch", {
   enumerable: true,
   get: () => routerCore.defaultParseSearch
 });
-Object.defineProperty(exports, "defaultSerializeError", {
-  enumerable: true,
-  get: () => routerCore.defaultSerializeError
-});
 Object.defineProperty(exports, "defaultStringifySearch", {
   enumerable: true,
   get: () => routerCore.defaultStringifySearch
@@ -99,10 +80,6 @@ Object.defineProperty(exports, "functionalUpdate", {
   enumerable: true,
   get: () => routerCore.functionalUpdate
 });
-Object.defineProperty(exports, "getInitialRouterState", {
-  enumerable: true,
-  get: () => routerCore.getInitialRouterState
-});
 Object.defineProperty(exports, "interpolatePath", {
   enumerable: true,
   get: () => routerCore.interpolatePath
@@ -222,7 +199,6 @@ exports.useChildMatches = Matches.useChildMatches;
 exports.useMatchRoute = Matches.useMatchRoute;
 exports.useMatches = Matches.useMatches;
 exports.useParentMatches = Matches.useParentMatches;
-exports.matchContext = matchContext.matchContext;
 exports.Match = Match.Match;
 exports.Outlet = Match.Outlet;
 exports.useMatch = useMatch.useMatch;
@@ -250,14 +226,11 @@ exports.Navigate = useNavigate.Navigate;
 exports.useNavigate = useNavigate.useNavigate;
 exports.useParams = useParams.useParams;
 exports.useSearch = useSearch.useSearch;
-exports.getRouterContext = routerContext.getRouterContext;
 exports.useRouteContext = useRouteContext.useRouteContext;
 exports.useRouter = useRouter.useRouter;
 exports.useRouterState = useRouterState.useRouterState;
 exports.useLocation = useLocation.useLocation;
 exports.useCanGoBack = useCanGoBack.useCanGoBack;
-exports.useLayoutEffect = utils.useLayoutEffect;
-exports.useStableCallback = utils.useStableCallback;
 exports.CatchNotFound = notFound.CatchNotFound;
 exports.DefaultGlobalNotFound = notFound.DefaultGlobalNotFound;
 exports.ScriptOnce = ScriptOnce.ScriptOnce;

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

@@ -1,4 +1,4 @@
-export { defer, TSR_DEFERRED_PROMISE, isMatch, joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, resolvePath, interpolatePath, rootRouteId, defaultSerializeError, defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith, functionalUpdate, replaceEqualDeep, isPlainObject, isPlainArray, deepEqual, createControlledPromise, retainSearchParams, stripSearchParams, createSerializationAdapter, } from '@tanstack/router-core';
+export { defer, isMatch, joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, resolvePath, interpolatePath, rootRouteId, defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith, functionalUpdate, replaceEqualDeep, isPlainObject, isPlainArray, deepEqual, createControlledPromise, retainSearchParams, stripSearchParams, createSerializationAdapter, } from '@tanstack/router-core';
 export type { AnyRoute, DeferredPromiseState, DeferredPromise, ParsedLocation, RemoveTrailingSlashes, RemoveLeadingSlashes, ActiveOptions, ResolveRelativePath, RootRouteId, AnyPathParams, ResolveParams, ResolveOptionalParams, ResolveRequiredParams, SearchSchemaInput, AnyContext, RouteContext, PreloadableObj, RoutePathOptions, StaticDataRouteOption, RoutePathOptionsIntersection, UpdatableStaticRouteOption, MetaDescriptor, RouteLinkEntry, ParseParamsFn, SearchFilter, ResolveId, InferFullSearchSchema, InferFullSearchSchemaInput, ErrorRouteProps, ErrorComponentProps, NotFoundRouteProps, TrimPath, TrimPathLeft, TrimPathRight, StringifyParamsFn, ParamsOptions, InferAllParams, InferAllContext, LooseReturnType, LooseAsyncReturnType, ContextReturnType, ContextAsyncReturnType, ResolveLoaderData, ResolveRouteContext, SearchSerializer, SearchParser, TrailingSlashOption, Manifest, RouterManagedTag, ControlledPromise, Constrain, Expand, MergeAll, Assign, IntersectAssign, ResolveValidatorInput, ResolveValidatorOutput, Register, AnyValidator, DefaultValidator, ValidatorFn, AnySchema, AnyValidatorAdapter, AnyValidatorFn, AnyValidatorObj, ResolveValidatorInputFn, ResolveValidatorOutputFn, ResolveSearchValidatorInput, ResolveSearchValidatorInputFn, Validator, ValidatorAdapter, ValidatorObj, FileRoutesByPath, RouteById, RootRouteOptions, CreateFileRoute, SerializationAdapter, AnySerializationAdapter, SerializableExtensions, } from '@tanstack/router-core';
 export { createHistory, createBrowserHistory, createHashHistory, createMemoryHistory, } from '@tanstack/history';
 export type { BlockerFn, HistoryLocation, RouterHistory, ParsedPath, HistoryState, } from '@tanstack/history';
@@ -14,7 +14,6 @@ export type { InferDescendantToPaths, RelativeToPath, RelativeToParentPath, Rela
 export type { UseLinkPropsOptions, ActiveLinkOptions, LinkProps, LinkComponent, LinkComponentProps, CreateLinkProps, } from './link.cjs';
 export { Matches, useMatchRoute, MatchRoute, useMatches, useParentMatches, useChildMatches, } from './Matches.cjs';
 export type { UseMatchRouteOptions, MakeMatchRouteOptions } from './Matches.cjs';
-export { matchContext } from './matchContext.cjs';
 export { Match, Outlet } from './Match.cjs';
 export { useMatch } from './useMatch.cjs';
 export { useLoaderDeps } from './useLoaderDeps.cjs';
@@ -23,7 +22,7 @@ export { redirect, isRedirect, createRouterConfig, DEFAULT_PROTOCOL_ALLOWLIST, }
 export { RouteApi, getRouteApi, Route, createRoute, RootRoute, rootRouteWithContext, createRootRoute, createRootRouteWithContext, createRouteMask, NotFoundRoute, } from './route.cjs';
 export type { AnyRootRoute, AsyncRouteComponent, RouteComponent, ErrorRouteComponent, NotFoundRouteComponent, DefaultRouteTypes, RouteTypes, } from './route.cjs';
 export { createRouter, Router } from './router.cjs';
-export { componentTypes, lazyFn, SearchParamError, PathParamError, getInitialRouterState, } from '@tanstack/router-core';
+export { lazyFn, SearchParamError } from '@tanstack/router-core';
 export { RouterProvider, RouterContextProvider } from './RouterProvider.cjs';
 export type { RouterProps } from './RouterProvider.cjs';
 export { useElementScrollRestoration, ScrollRestoration, } from './ScrollRestoration.cjs';
@@ -32,14 +31,11 @@ export { useBlocker, Block } from './useBlocker.cjs';
 export { useNavigate, Navigate } from './useNavigate.cjs';
 export { useParams } from './useParams.cjs';
 export { useSearch } from './useSearch.cjs';
-export { getRouterContext, } from './routerContext.cjs';
 export { useRouteContext } from './useRouteContext.cjs';
 export { useRouter } from './useRouter.cjs';
 export { useRouterState } from './useRouterState.cjs';
 export { useLocation } from './useLocation.cjs';
 export { useCanGoBack } from './useCanGoBack.cjs';
-export { useLayoutEffect, // SSR
-useStableCallback, } from './utils.cjs';
 export { CatchNotFound, DefaultGlobalNotFound } from './not-found.cjs';
 export { notFound, isNotFound } from '@tanstack/router-core';
 export type { NotFoundError } from '@tanstack/router-core';

package/dist/cjs/index.dev.cjs

@@ -9,7 +9,6 @@ const fileRoute = require("./fileRoute.cjs");
 const lazyRouteComponent = require("./lazyRouteComponent.cjs");
 const link = require("./link.cjs");
 const Matches = require("./Matches.cjs");
-const matchContext = require("./matchContext.cjs");
 const Match = require("./Match.cjs");
 const useMatch = require("./useMatch.cjs");
 const useLoaderDeps = require("./useLoaderDeps.cjs");
@@ -22,13 +21,11 @@ const useBlocker = require("./useBlocker.cjs");
 const useNavigate = require("./useNavigate.cjs");
 const useParams = require("./useParams.cjs");
 const useSearch = require("./useSearch.cjs");
-const routerContext = require("./routerContext.cjs");
 const useRouteContext = require("./useRouteContext.cjs");
 const useRouter = require("./useRouter.cjs");
 const useRouterState = require("./useRouterState.cjs");
 const useLocation = require("./useLocation.cjs");
 const useCanGoBack = require("./useCanGoBack.cjs");
-const utils = require("./utils.cjs");
 const notFound = require("./not-found.cjs");
 const ScriptOnce = require("./ScriptOnce.cjs");
 const Asset = require("./Asset.cjs");
@@ -39,26 +36,14 @@ Object.defineProperty(exports, "DEFAULT_PROTOCOL_ALLOWLIST", {
   enumerable: true,
   get: () => routerCore.DEFAULT_PROTOCOL_ALLOWLIST
 });
-Object.defineProperty(exports, "PathParamError", {
-  enumerable: true,
-  get: () => routerCore.PathParamError
-});
 Object.defineProperty(exports, "SearchParamError", {
   enumerable: true,
   get: () => routerCore.SearchParamError
 });
-Object.defineProperty(exports, "TSR_DEFERRED_PROMISE", {
-  enumerable: true,
-  get: () => routerCore.TSR_DEFERRED_PROMISE
-});
 Object.defineProperty(exports, "cleanPath", {
   enumerable: true,
   get: () => routerCore.cleanPath
 });
-Object.defineProperty(exports, "componentTypes", {
-  enumerable: true,
-  get: () => routerCore.componentTypes
-});
 Object.defineProperty(exports, "composeRewrites", {
   enumerable: true,
   get: () => routerCore.composeRewrites
@@ -83,10 +68,6 @@ Object.defineProperty(exports, "defaultParseSearch", {
   enumerable: true,
   get: () => routerCore.defaultParseSearch
 });
-Object.defineProperty(exports, "defaultSerializeError", {
-  enumerable: true,
-  get: () => routerCore.defaultSerializeError
-});
 Object.defineProperty(exports, "defaultStringifySearch", {
   enumerable: true,
   get: () => routerCore.defaultStringifySearch
@@ -99,10 +80,6 @@ Object.defineProperty(exports, "functionalUpdate", {
   enumerable: true,
   get: () => routerCore.functionalUpdate
 });
-Object.defineProperty(exports, "getInitialRouterState", {
-  enumerable: true,
-  get: () => routerCore.getInitialRouterState
-});
 Object.defineProperty(exports, "interpolatePath", {
   enumerable: true,
   get: () => routerCore.interpolatePath
@@ -222,7 +199,6 @@ exports.useChildMatches = Matches.useChildMatches;
 exports.useMatchRoute = Matches.useMatchRoute;
 exports.useMatches = Matches.useMatches;
 exports.useParentMatches = Matches.useParentMatches;
-exports.matchContext = matchContext.matchContext;
 exports.Match = Match.Match;
 exports.Outlet = Match.Outlet;
 exports.useMatch = useMatch.useMatch;
@@ -250,14 +226,11 @@ exports.Navigate = useNavigate.Navigate;
 exports.useNavigate = useNavigate.useNavigate;
 exports.useParams = useParams.useParams;
 exports.useSearch = useSearch.useSearch;
-exports.getRouterContext = routerContext.getRouterContext;
 exports.useRouteContext = useRouteContext.useRouteContext;
 exports.useRouter = useRouter.useRouter;
 exports.useRouterState = useRouterState.useRouterState;
 exports.useLocation = useLocation.useLocation;
 exports.useCanGoBack = useCanGoBack.useCanGoBack;
-exports.useLayoutEffect = utils.useLayoutEffect;
-exports.useStableCallback = utils.useStableCallback;
 exports.CatchNotFound = notFound.CatchNotFound;
 exports.DefaultGlobalNotFound = notFound.DefaultGlobalNotFound;
 exports.ScriptOnce = ScriptOnce.ScriptOnce;

package/dist/cjs/index.dev.cjs.map

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

package/dist/cjs/routerContext.cjs

@@ -19,15 +19,5 @@ function _interopNamespaceDefault(e) {
 }
 const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
 const routerContext = React__namespace.createContext(null);
-function getRouterContext() {
-  if (typeof document === "undefined") {
-    return routerContext;
-  }
-  if (window.__TSR_ROUTER_CONTEXT__) {
-    return window.__TSR_ROUTER_CONTEXT__;
-  }
-  window.__TSR_ROUTER_CONTEXT__ = routerContext;
-  return routerContext;
-}
-exports.getRouterContext = getRouterContext;
+exports.routerContext = routerContext;
 //# sourceMappingURL=routerContext.cjs.map

package/dist/cjs/routerContext.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"routerContext.cjs","sources":["../../src/routerContext.tsx"],"sourcesContent":["import * as React from 'react'\nimport type { AnyRouter } from '@tanstack/router-core'\n\ndeclare global {\n  interface Window {\n    __TSR_ROUTER_CONTEXT__?: React.Context<AnyRouter>\n  }\n}\n\nconst routerContext = React.createContext<AnyRouter>(null!)\n\nexport function getRouterContext() {\n  if (typeof document === 'undefined') {\n    return routerContext\n  }\n\n  if (window.__TSR_ROUTER_CONTEXT__) {\n    return window.__TSR_ROUTER_CONTEXT__\n  }\n\n  window.__TSR_ROUTER_CONTEXT__ = routerContext as any\n\n  return routerContext\n}\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;AASA,MAAM,gBAAgBA,iBAAM,cAAyB,IAAK;AAEnD,SAAS,mBAAmB;AACjC,MAAI,OAAO,aAAa,aAAa;AACnC,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,wBAAwB;AACjC,WAAO,OAAO;AAAA,EAChB;AAEA,SAAO,yBAAyB;AAEhC,SAAO;AACT;;"}
+{"version":3,"file":"routerContext.cjs","sources":["../../src/routerContext.tsx"],"sourcesContent":["import * as React from 'react'\nimport type { AnyRouter } from '@tanstack/router-core'\n\nexport const routerContext = React.createContext<AnyRouter>(null!)\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;AAGO,MAAM,gBAAgBA,iBAAM,cAAyB,IAAK;;"}

package/dist/cjs/routerContext.d.cts

@@ -1,8 +1,3 @@
 import { AnyRouter } from '@tanstack/router-core';
 import * as React from 'react';
-declare global {
-    interface Window {
-        __TSR_ROUTER_CONTEXT__?: React.Context<AnyRouter>;
-    }
-}
-export declare function getRouterContext(): React.Context<AnyRouter>;
+export declare const routerContext: React.Context<AnyRouter>;

package/dist/cjs/useRouter.cjs

@@ -21,7 +21,7 @@ function _interopNamespaceDefault(e) {
 }
 const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
 function useRouter(opts) {
-  const value = React__namespace.useContext(routerContext.getRouterContext());
+  const value = React__namespace.useContext(routerContext.routerContext);
   warning(
     !((opts?.warn ?? true) && !value),
     "useRouter must be used inside a <RouterProvider> component!"

package/dist/cjs/useRouter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useRouter.cjs","sources":["../../src/useRouter.tsx"],"sourcesContent":["import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { getRouterContext } from './routerContext'\nimport type { AnyRouter, RegisteredRouter } from '@tanstack/router-core'\n\n/**\n * Access the current TanStack Router instance from React context.\n * Must be used within a `RouterProvider`.\n *\n * Options:\n * - `warn`: Log a warning if no router context is found (default: true).\n *\n * @returns The registered router instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useRouterHook\n */\nexport function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {\n  warn?: boolean\n}): TRouter {\n  const value = React.useContext(getRouterContext())\n  warning(\n    !((opts?.warn ?? true) && !value),\n    'useRouter must be used inside a <RouterProvider> component!',\n  )\n  return value as any\n}\n"],"names":["React","getRouterContext"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAeO,SAAS,UAAwD,MAE5D;AACV,QAAM,QAAQA,iBAAM,WAAWC,cAAAA,iBAAA,CAAkB;AACjD;AAAA,IACE,GAAG,MAAM,QAAQ,SAAS,CAAC;AAAA,IAC3B;AAAA,EAAA;AAEF,SAAO;AACT;;"}
+{"version":3,"file":"useRouter.cjs","sources":["../../src/useRouter.tsx"],"sourcesContent":["import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { routerContext } from './routerContext'\nimport type { AnyRouter, RegisteredRouter } from '@tanstack/router-core'\n\n/**\n * Access the current TanStack Router instance from React context.\n * Must be used within a `RouterProvider`.\n *\n * Options:\n * - `warn`: Log a warning if no router context is found (default: true).\n *\n * @returns The registered router instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useRouterHook\n */\nexport function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {\n  warn?: boolean\n}): TRouter {\n  const value = React.useContext(routerContext)\n  warning(\n    !((opts?.warn ?? true) && !value),\n    'useRouter must be used inside a <RouterProvider> component!',\n  )\n  return value as any\n}\n"],"names":["React","routerContext"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAeO,SAAS,UAAwD,MAE5D;AACV,QAAM,QAAQA,iBAAM,WAAWC,2BAAa;AAC5C;AAAA,IACE,GAAG,MAAM,QAAQ,SAAS,CAAC;AAAA,IAC3B;AAAA,EAAA;AAEF,SAAO;AACT;;"}

package/dist/cjs/utils.cjs

@@ -20,12 +20,6 @@ function _interopNamespaceDefault(e) {
 const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
 const REACT_USE = "use";
 const reactUse = React__namespace[REACT_USE];
-function useStableCallback(fn) {
-  const fnRef = React__namespace.useRef(fn);
-  fnRef.current = fn;
-  const ref = React__namespace.useRef((...args) => fnRef.current(...args));
-  return ref.current;
-}
 const useLayoutEffect = typeof window !== "undefined" ? React__namespace.useLayoutEffect : React__namespace.useEffect;
 function usePrevious(value) {
   const ref = React__namespace.useRef({
@@ -65,5 +59,4 @@ exports.useForwardedRef = useForwardedRef;
 exports.useIntersectionObserver = useIntersectionObserver;
 exports.useLayoutEffect = useLayoutEffect;
 exports.usePrevious = usePrevious;
-exports.useStableCallback = useStableCallback;
 //# sourceMappingURL=utils.cjs.map

package/dist/cjs/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","sources":["../../src/utils.ts"],"sourcesContent":["import * as React from 'react'\n\n// Safe version of React.use() that will not cause compilation errors against\n// React 18 with Webpack, which statically analyzes imports and fails when it\n// sees React.use referenced (since 'use' is not exported from React 18).\n// This uses a dynamic string lookup to avoid the static analysis.\nconst REACT_USE = 'use'\n\n/**\n * React.use if available (React 19+), undefined otherwise.\n * Use dynamic lookup to avoid Webpack compilation errors with React 18.\n */\nexport const reactUse:\n  | (<T>(usable: Promise<T> | React.Context<T>) => T)\n  | undefined = (React as any)[REACT_USE]\n\nexport function useStableCallback<T extends (...args: Array<any>) => any>(\n  fn: T,\n): T {\n  const fnRef = React.useRef(fn)\n  fnRef.current = fn\n\n  const ref = React.useRef((...args: Array<any>) => fnRef.current(...args))\n  return ref.current as T\n}\n\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious<T>(value: T): T | null {\n  // initialise the ref with previous and current values\n  const ref = React.useRef<{ value: T; prev: T | null }>({\n    value: value,\n    prev: null,\n  })\n\n  const current = ref.current.value\n\n  // if the value passed into hook doesn't match what we store as \"current\"\n  // move the \"current\" to the \"previous\"\n  // and store the passed value as \"current\"\n  if (value !== current) {\n    ref.current = {\n      value: value,\n      prev: current,\n    }\n  }\n\n  // return the previous value only\n  return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef<HTMLDivElement>(null)\n * useIntersectionObserver(\n *  ref,\n *  (entry) => { doSomething(entry) },\n *  { rootMargin: '10px' },\n *  { disabled: false }\n * )\n * return <div ref={ref} />\n * ```\n */\nexport function useIntersectionObserver<T extends Element>(\n  ref: React.RefObject<T | null>,\n  callback: (entry: IntersectionObserverEntry | undefined) => void,\n  intersectionObserverOptions: IntersectionObserverInit = {},\n  options: { disabled?: boolean } = {},\n) {\n  React.useEffect(() => {\n    if (\n      !ref.current ||\n      options.disabled ||\n      typeof IntersectionObserver !== 'function'\n    ) {\n      return\n    }\n\n    const observer = new IntersectionObserver(([entry]) => {\n      callback(entry)\n    }, intersectionObserverOptions)\n\n    observer.observe(ref.current)\n\n    return () => {\n      observer.disconnect()\n    }\n  }, [callback, intersectionObserverOptions, options.disabled, ref])\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n *  const innerRef = useForwardedRef(ref)\n *  return <div ref={innerRef} />\n * })\n * ```\n */\nexport function useForwardedRef<T>(ref?: React.ForwardedRef<T>) {\n  const innerRef = React.useRef<T>(null)\n  React.useImperativeHandle(ref, () => innerRef.current!, [])\n  return innerRef\n}\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;AAMA,MAAM,YAAY;AAMX,MAAM,WAEIA,iBAAc,SAAS;AAEjC,SAAS,kBACd,IACG;AACH,QAAM,QAAQA,iBAAM,OAAO,EAAE;AAC7B,QAAM,UAAU;AAEhB,QAAM,MAAMA,iBAAM,OAAO,IAAI,SAAqB,MAAM,QAAQ,GAAG,IAAI,CAAC;AACxE,SAAO,IAAI;AACb;AAEO,MAAM,kBACX,OAAO,WAAW,cAAcA,iBAAM,kBAAkBA,iBAAM;AAKzD,SAAS,YAAe,OAAoB;AAEjD,QAAM,MAAMA,iBAAM,OAAqC;AAAA,IACrD;AAAA,IACA,MAAM;AAAA,EAAA,CACP;AAED,QAAM,UAAU,IAAI,QAAQ;AAK5B,MAAI,UAAU,SAAS;AACrB,QAAI,UAAU;AAAA,MACZ;AAAA,MACA,MAAM;AAAA,IAAA;AAAA,EAEV;AAGA,SAAO,IAAI,QAAQ;AACrB;AA2BO,SAAS,wBACd,KACA,UACA,8BAAwD,CAAA,GACxD,UAAkC,IAClC;AACAA,mBAAM,UAAU,MAAM;AACpB,QACE,CAAC,IAAI,WACL,QAAQ,YACR,OAAO,yBAAyB,YAChC;AACA;AAAA,IACF;AAEA,UAAM,WAAW,IAAI,qBAAqB,CAAC,CAAC,KAAK,MAAM;AACrD,eAAS,KAAK;AAAA,IAChB,GAAG,2BAA2B;AAE9B,aAAS,QAAQ,IAAI,OAAO;AAE5B,WAAO,MAAM;AACX,eAAS,WAAA;AAAA,IACX;AAAA,EACF,GAAG,CAAC,UAAU,6BAA6B,QAAQ,UAAU,GAAG,CAAC;AACnE;AAeO,SAAS,gBAAmB,KAA6B;AAC9D,QAAM,WAAWA,iBAAM,OAAU,IAAI;AACrCA,mBAAM,oBAAoB,KAAK,MAAM,SAAS,SAAU,CAAA,CAAE;AAC1D,SAAO;AACT;;;;;;;"}
+{"version":3,"file":"utils.cjs","sources":["../../src/utils.ts"],"sourcesContent":["import * as React from 'react'\n\n// Safe version of React.use() that will not cause compilation errors against\n// React 18 with Webpack, which statically analyzes imports and fails when it\n// sees React.use referenced (since 'use' is not exported from React 18).\n// This uses a dynamic string lookup to avoid the static analysis.\nconst REACT_USE = 'use'\n\n/**\n * React.use if available (React 19+), undefined otherwise.\n * Use dynamic lookup to avoid Webpack compilation errors with React 18.\n */\nexport const reactUse:\n  | (<T>(usable: Promise<T> | React.Context<T>) => T)\n  | undefined = (React as any)[REACT_USE]\n\nexport function useStableCallback<T extends (...args: Array<any>) => any>(\n  fn: T,\n): T {\n  const fnRef = React.useRef(fn)\n  fnRef.current = fn\n\n  const ref = React.useRef((...args: Array<any>) => fnRef.current(...args))\n  return ref.current as T\n}\n\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious<T>(value: T): T | null {\n  // initialise the ref with previous and current values\n  const ref = React.useRef<{ value: T; prev: T | null }>({\n    value: value,\n    prev: null,\n  })\n\n  const current = ref.current.value\n\n  // if the value passed into hook doesn't match what we store as \"current\"\n  // move the \"current\" to the \"previous\"\n  // and store the passed value as \"current\"\n  if (value !== current) {\n    ref.current = {\n      value: value,\n      prev: current,\n    }\n  }\n\n  // return the previous value only\n  return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef<HTMLDivElement>(null)\n * useIntersectionObserver(\n *  ref,\n *  (entry) => { doSomething(entry) },\n *  { rootMargin: '10px' },\n *  { disabled: false }\n * )\n * return <div ref={ref} />\n * ```\n */\nexport function useIntersectionObserver<T extends Element>(\n  ref: React.RefObject<T | null>,\n  callback: (entry: IntersectionObserverEntry | undefined) => void,\n  intersectionObserverOptions: IntersectionObserverInit = {},\n  options: { disabled?: boolean } = {},\n) {\n  React.useEffect(() => {\n    if (\n      !ref.current ||\n      options.disabled ||\n      typeof IntersectionObserver !== 'function'\n    ) {\n      return\n    }\n\n    const observer = new IntersectionObserver(([entry]) => {\n      callback(entry)\n    }, intersectionObserverOptions)\n\n    observer.observe(ref.current)\n\n    return () => {\n      observer.disconnect()\n    }\n  }, [callback, intersectionObserverOptions, options.disabled, ref])\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n *  const innerRef = useForwardedRef(ref)\n *  return <div ref={innerRef} />\n * })\n * ```\n */\nexport function useForwardedRef<T>(ref?: React.ForwardedRef<T>) {\n  const innerRef = React.useRef<T>(null)\n  React.useImperativeHandle(ref, () => innerRef.current!, [])\n  return innerRef\n}\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;AAMA,MAAM,YAAY;AAMX,MAAM,WAEIA,iBAAc,SAAS;AAYjC,MAAM,kBACX,OAAO,WAAW,cAAcA,iBAAM,kBAAkBA,iBAAM;AAKzD,SAAS,YAAe,OAAoB;AAEjD,QAAM,MAAMA,iBAAM,OAAqC;AAAA,IACrD;AAAA,IACA,MAAM;AAAA,EAAA,CACP;AAED,QAAM,UAAU,IAAI,QAAQ;AAK5B,MAAI,UAAU,SAAS;AACrB,QAAI,UAAU;AAAA,MACZ;AAAA,MACA,MAAM;AAAA,IAAA;AAAA,EAEV;AAGA,SAAO,IAAI,QAAQ;AACrB;AA2BO,SAAS,wBACd,KACA,UACA,8BAAwD,CAAA,GACxD,UAAkC,IAClC;AACAA,mBAAM,UAAU,MAAM;AACpB,QACE,CAAC,IAAI,WACL,QAAQ,YACR,OAAO,yBAAyB,YAChC;AACA;AAAA,IACF;AAEA,UAAM,WAAW,IAAI,qBAAqB,CAAC,CAAC,KAAK,MAAM;AACrD,eAAS,KAAK;AAAA,IAChB,GAAG,2BAA2B;AAE9B,aAAS,QAAQ,IAAI,OAAO;AAE5B,WAAO,MAAM;AACX,eAAS,WAAA;AAAA,IACX;AAAA,EACF,GAAG,CAAC,UAAU,6BAA6B,QAAQ,UAAU,GAAG,CAAC;AACnE;AAeO,SAAS,gBAAmB,KAA6B;AAC9D,QAAM,WAAWA,iBAAM,OAAU,IAAI;AACrCA,mBAAM,oBAAoB,KAAK,MAAM,SAAS,SAAU,CAAA,CAAE;AAC1D,SAAO;AACT;;;;;;"}

package/dist/esm/RouterProvider.js

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { Matches } from "./Matches.js";
-import { getRouterContext } from "./routerContext.js";
+import { routerContext } from "./routerContext.js";
 function RouterContextProvider({
   router,
   children,
@@ -16,7 +16,6 @@ function RouterContextProvider({
       }
     });
   }
-  const routerContext = getRouterContext();
   const provider = /* @__PURE__ */ jsx(routerContext.Provider, { value: router, children });
   if (router.options.Wrap) {
     return /* @__PURE__ */ jsx(router.options.Wrap, { children: provider });

package/dist/esm/RouterProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"RouterProvider.js","sources":["../../src/RouterProvider.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Matches } from './Matches'\nimport { getRouterContext } from './routerContext'\nimport type {\n  AnyRouter,\n  RegisteredRouter,\n  RouterOptions,\n} from '@tanstack/router-core'\n\n/**\n * Low-level provider that places the router into React context and optionally\n * updates router options from props. Most apps should use `RouterProvider`.\n */\nexport function RouterContextProvider<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n>({\n  router,\n  children,\n  ...rest\n}: RouterProps<TRouter, TDehydrated> & {\n  children: React.ReactNode\n}) {\n  if (Object.keys(rest).length > 0) {\n    // Allow the router to update options on the router instance\n    router.update({\n      ...router.options,\n      ...rest,\n      context: {\n        ...router.options.context,\n        ...rest.context,\n      },\n    })\n  }\n\n  const routerContext = getRouterContext()\n\n  const provider = (\n    <routerContext.Provider value={router as AnyRouter}>\n      {children}\n    </routerContext.Provider>\n  )\n\n  if (router.options.Wrap) {\n    return <router.options.Wrap>{provider}</router.options.Wrap>\n  }\n\n  return provider\n}\n\n/**\n * Top-level component that renders the active route matches and provides the\n * router to the React tree via context.\n *\n * Accepts the same options as `createRouter` via props to update the router\n * instance after creation.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction\n */\nexport function RouterProvider<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n>({ router, ...rest }: RouterProps<TRouter, TDehydrated>) {\n  return (\n    <RouterContextProvider router={router} {...rest}>\n      <Matches />\n    </RouterContextProvider>\n  )\n}\n\nexport type RouterProps<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n> = Omit<\n  RouterOptions<\n    TRouter['routeTree'],\n    NonNullable<TRouter['options']['trailingSlash']>,\n    NonNullable<TRouter['options']['defaultStructuralSharing']>,\n    TRouter['history'],\n    TDehydrated\n  >,\n  'context'\n> & {\n  router: TRouter\n  context?: Partial<\n    RouterOptions<\n      TRouter['routeTree'],\n      NonNullable<TRouter['options']['trailingSlash']>,\n      NonNullable<TRouter['options']['defaultStructuralSharing']>,\n      TRouter['history'],\n      TDehydrated\n    >['context']\n  >\n}\n"],"names":[],"mappings":";;;AAaO,SAAS,sBAGd;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,GAEG;AACD,MAAI,OAAO,KAAK,IAAI,EAAE,SAAS,GAAG;AAEhC,WAAO,OAAO;AAAA,MACZ,GAAG,OAAO;AAAA,MACV,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAG,OAAO,QAAQ;AAAA,QAClB,GAAG,KAAK;AAAA,MAAA;AAAA,IACV,CACD;AAAA,EACH;AAEA,QAAM,gBAAgB,iBAAA;AAEtB,QAAM,WACJ,oBAAC,cAAc,UAAd,EAAuB,OAAO,QAC5B,UACH;AAGF,MAAI,OAAO,QAAQ,MAAM;AACvB,WAAO,oBAAC,OAAO,QAAQ,MAAf,EAAqB,UAAA,UAAS;AAAA,EACxC;AAEA,SAAO;AACT;AAWO,SAAS,eAGd,EAAE,QAAQ,GAAG,QAA2C;AACxD,6BACG,uBAAA,EAAsB,QAAiB,GAAG,MACzC,UAAA,oBAAC,WAAQ,GACX;AAEJ;"}
+{"version":3,"file":"RouterProvider.js","sources":["../../src/RouterProvider.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Matches } from './Matches'\nimport { routerContext } from './routerContext'\nimport type {\n  AnyRouter,\n  RegisteredRouter,\n  RouterOptions,\n} from '@tanstack/router-core'\n\n/**\n * Low-level provider that places the router into React context and optionally\n * updates router options from props. Most apps should use `RouterProvider`.\n */\nexport function RouterContextProvider<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n>({\n  router,\n  children,\n  ...rest\n}: RouterProps<TRouter, TDehydrated> & {\n  children: React.ReactNode\n}) {\n  if (Object.keys(rest).length > 0) {\n    // Allow the router to update options on the router instance\n    router.update({\n      ...router.options,\n      ...rest,\n      context: {\n        ...router.options.context,\n        ...rest.context,\n      },\n    })\n  }\n\n  const provider = (\n    <routerContext.Provider value={router as AnyRouter}>\n      {children}\n    </routerContext.Provider>\n  )\n\n  if (router.options.Wrap) {\n    return <router.options.Wrap>{provider}</router.options.Wrap>\n  }\n\n  return provider\n}\n\n/**\n * Top-level component that renders the active route matches and provides the\n * router to the React tree via context.\n *\n * Accepts the same options as `createRouter` via props to update the router\n * instance after creation.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction\n */\nexport function RouterProvider<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n>({ router, ...rest }: RouterProps<TRouter, TDehydrated>) {\n  return (\n    <RouterContextProvider router={router} {...rest}>\n      <Matches />\n    </RouterContextProvider>\n  )\n}\n\nexport type RouterProps<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDehydrated extends Record<string, any> = Record<string, any>,\n> = Omit<\n  RouterOptions<\n    TRouter['routeTree'],\n    NonNullable<TRouter['options']['trailingSlash']>,\n    NonNullable<TRouter['options']['defaultStructuralSharing']>,\n    TRouter['history'],\n    TDehydrated\n  >,\n  'context'\n> & {\n  router: TRouter\n  context?: Partial<\n    RouterOptions<\n      TRouter['routeTree'],\n      NonNullable<TRouter['options']['trailingSlash']>,\n      NonNullable<TRouter['options']['defaultStructuralSharing']>,\n      TRouter['history'],\n      TDehydrated\n    >['context']\n  >\n}\n"],"names":[],"mappings":";;;AAaO,SAAS,sBAGd;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,GAEG;AACD,MAAI,OAAO,KAAK,IAAI,EAAE,SAAS,GAAG;AAEhC,WAAO,OAAO;AAAA,MACZ,GAAG,OAAO;AAAA,MACV,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAG,OAAO,QAAQ;AAAA,QAClB,GAAG,KAAK;AAAA,MAAA;AAAA,IACV,CACD;AAAA,EACH;AAEA,QAAM,WACJ,oBAAC,cAAc,UAAd,EAAuB,OAAO,QAC5B,UACH;AAGF,MAAI,OAAO,QAAQ,MAAM;AACvB,WAAO,oBAAC,OAAO,QAAQ,MAAf,EAAqB,UAAA,UAAS;AAAA,EACxC;AAEA,SAAO;AACT;AAWO,SAAS,eAGd,EAAE,QAAQ,GAAG,QAA2C;AACxD,6BACG,uBAAA,EAAsB,QAAiB,GAAG,MACzC,UAAA,oBAAC,WAAQ,GACX;AAEJ;"}

package/dist/esm/index.d.ts

@@ -1,4 +1,4 @@
-export { defer, TSR_DEFERRED_PROMISE, isMatch, joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, resolvePath, interpolatePath, rootRouteId, defaultSerializeError, defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith, functionalUpdate, replaceEqualDeep, isPlainObject, isPlainArray, deepEqual, createControlledPromise, retainSearchParams, stripSearchParams, createSerializationAdapter, } from '@tanstack/router-core';
+export { defer, isMatch, joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, resolvePath, interpolatePath, rootRouteId, defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith, functionalUpdate, replaceEqualDeep, isPlainObject, isPlainArray, deepEqual, createControlledPromise, retainSearchParams, stripSearchParams, createSerializationAdapter, } from '@tanstack/router-core';
 export type { AnyRoute, DeferredPromiseState, DeferredPromise, ParsedLocation, RemoveTrailingSlashes, RemoveLeadingSlashes, ActiveOptions, ResolveRelativePath, RootRouteId, AnyPathParams, ResolveParams, ResolveOptionalParams, ResolveRequiredParams, SearchSchemaInput, AnyContext, RouteContext, PreloadableObj, RoutePathOptions, StaticDataRouteOption, RoutePathOptionsIntersection, UpdatableStaticRouteOption, MetaDescriptor, RouteLinkEntry, ParseParamsFn, SearchFilter, ResolveId, InferFullSearchSchema, InferFullSearchSchemaInput, ErrorRouteProps, ErrorComponentProps, NotFoundRouteProps, TrimPath, TrimPathLeft, TrimPathRight, StringifyParamsFn, ParamsOptions, InferAllParams, InferAllContext, LooseReturnType, LooseAsyncReturnType, ContextReturnType, ContextAsyncReturnType, ResolveLoaderData, ResolveRouteContext, SearchSerializer, SearchParser, TrailingSlashOption, Manifest, RouterManagedTag, ControlledPromise, Constrain, Expand, MergeAll, Assign, IntersectAssign, ResolveValidatorInput, ResolveValidatorOutput, Register, AnyValidator, DefaultValidator, ValidatorFn, AnySchema, AnyValidatorAdapter, AnyValidatorFn, AnyValidatorObj, ResolveValidatorInputFn, ResolveValidatorOutputFn, ResolveSearchValidatorInput, ResolveSearchValidatorInputFn, Validator, ValidatorAdapter, ValidatorObj, FileRoutesByPath, RouteById, RootRouteOptions, CreateFileRoute, SerializationAdapter, AnySerializationAdapter, SerializableExtensions, } from '@tanstack/router-core';
 export { createHistory, createBrowserHistory, createHashHistory, createMemoryHistory, } from '@tanstack/history';
 export type { BlockerFn, HistoryLocation, RouterHistory, ParsedPath, HistoryState, } from '@tanstack/history';
@@ -14,7 +14,6 @@ export type { InferDescendantToPaths, RelativeToPath, RelativeToParentPath, Rela
 export type { UseLinkPropsOptions, ActiveLinkOptions, LinkProps, LinkComponent, LinkComponentProps, CreateLinkProps, } from './link.js';
 export { Matches, useMatchRoute, MatchRoute, useMatches, useParentMatches, useChildMatches, } from './Matches.js';
 export type { UseMatchRouteOptions, MakeMatchRouteOptions } from './Matches.js';
-export { matchContext } from './matchContext.js';
 export { Match, Outlet } from './Match.js';
 export { useMatch } from './useMatch.js';
 export { useLoaderDeps } from './useLoaderDeps.js';
@@ -23,7 +22,7 @@ export { redirect, isRedirect, createRouterConfig, DEFAULT_PROTOCOL_ALLOWLIST, }
 export { RouteApi, getRouteApi, Route, createRoute, RootRoute, rootRouteWithContext, createRootRoute, createRootRouteWithContext, createRouteMask, NotFoundRoute, } from './route.js';
 export type { AnyRootRoute, AsyncRouteComponent, RouteComponent, ErrorRouteComponent, NotFoundRouteComponent, DefaultRouteTypes, RouteTypes, } from './route.js';
 export { createRouter, Router } from './router.js';
-export { componentTypes, lazyFn, SearchParamError, PathParamError, getInitialRouterState, } from '@tanstack/router-core';
+export { lazyFn, SearchParamError } from '@tanstack/router-core';
 export { RouterProvider, RouterContextProvider } from './RouterProvider.js';
 export type { RouterProps } from './RouterProvider.js';
 export { useElementScrollRestoration, ScrollRestoration, } from './ScrollRestoration.js';
@@ -32,14 +31,11 @@ export { useBlocker, Block } from './useBlocker.js';
 export { useNavigate, Navigate } from './useNavigate.js';
 export { useParams } from './useParams.js';
 export { useSearch } from './useSearch.js';
-export { getRouterContext, } from './routerContext.js';
 export { useRouteContext } from './useRouteContext.js';
 export { useRouter } from './useRouter.js';
 export { useRouterState } from './useRouterState.js';
 export { useLocation } from './useLocation.js';
 export { useCanGoBack } from './useCanGoBack.js';
-export { useLayoutEffect, // SSR
-useStableCallback, } from './utils.js';
 export { CatchNotFound, DefaultGlobalNotFound } from './not-found.js';
 export { notFound, isNotFound } from '@tanstack/router-core';
 export type { NotFoundError } from '@tanstack/router-core';

package/dist/esm/index.dev.js

@@ -1,4 +1,4 @@
-import { DEFAULT_PROTOCOL_ALLOWLIST, PathParamError, SearchParamError, TSR_DEFERRED_PROMISE, cleanPath, componentTypes, composeRewrites, createControlledPromise, createRouterConfig, createSerializationAdapter, deepEqual, defaultParseSearch, defaultSerializeError, defaultStringifySearch, defer, functionalUpdate, getInitialRouterState, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, lazyFn, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight } from "@tanstack/router-core";
+import { DEFAULT_PROTOCOL_ALLOWLIST, SearchParamError, cleanPath, composeRewrites, createControlledPromise, createRouterConfig, createSerializationAdapter, deepEqual, defaultParseSearch, defaultStringifySearch, defer, functionalUpdate, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, lazyFn, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight } from "@tanstack/router-core";
 import { createBrowserHistory, createHashHistory, createHistory, createMemoryHistory } from "@tanstack/history";
 import { Await, useAwaited } from "./awaited.js";
 import { CatchBoundary, ErrorComponent } from "./CatchBoundary.js";
@@ -7,7 +7,6 @@ import { FileRoute, FileRouteLoader, LazyRoute, createFileRoute, createLazyFileR
 import { lazyRouteComponent } from "./lazyRouteComponent.js";
 import { Link, createLink, linkOptions, useLinkProps } from "./link.js";
 import { MatchRoute, Matches, useChildMatches, useMatchRoute, useMatches, useParentMatches } from "./Matches.js";
-import { matchContext } from "./matchContext.js";
 import { Match, Outlet } from "./Match.js";
 import { useMatch } from "./useMatch.js";
 import { useLoaderDeps } from "./useLoaderDeps.js";
@@ -20,13 +19,11 @@ import { Block, useBlocker } from "./useBlocker.js";
 import { Navigate, useNavigate } from "./useNavigate.js";
 import { useParams } from "./useParams.js";
 import { useSearch } from "./useSearch.js";
-import { getRouterContext } from "./routerContext.js";
 import { useRouteContext } from "./useRouteContext.js";
 import { useRouter } from "./useRouter.js";
 import { useRouterState } from "./useRouterState.js";
 import { useLocation } from "./useLocation.js";
 import { useCanGoBack } from "./useCanGoBack.js";
-import { useLayoutEffect, useStableCallback } from "./utils.js";
 import { CatchNotFound, DefaultGlobalNotFound } from "./not-found.js";
 import { ScriptOnce } from "./ScriptOnce.js";
 import { Asset } from "./Asset.js";
@@ -54,7 +51,6 @@ export {
   Navigate,
   NotFoundRoute,
   Outlet,
-  PathParamError,
   RootRoute,
   Route,
   RouteApi,
@@ -65,9 +61,7 @@ export {
   Scripts,
   ScrollRestoration,
   SearchParamError,
-  TSR_DEFERRED_PROMISE,
   cleanPath,
-  componentTypes,
   composeRewrites,
   createBrowserHistory,
   createControlledPromise,
@@ -87,13 +81,10 @@ export {
   createSerializationAdapter,
   deepEqual,
   defaultParseSearch,
-  defaultSerializeError,
   defaultStringifySearch,
   defer,
   functionalUpdate,
-  getInitialRouterState,
   getRouteApi,
-  getRouterContext,
   interpolatePath,
   isMatch,
   isNotFound,
@@ -104,7 +95,6 @@ export {
   lazyFn,
   lazyRouteComponent,
   linkOptions,
-  matchContext,
   notFound,
   parseSearchWith,
   redirect,
@@ -124,7 +114,6 @@ export {
   useChildMatches,
   useElementScrollRestoration,
   useHydrated,
-  useLayoutEffect,
   useLinkProps,
   useLoaderData,
   useLoaderDeps,
@@ -139,7 +128,6 @@ export {
   useRouter,
   useRouterState,
   useSearch,
-  useStableCallback,
   useTags
 };
 //# sourceMappingURL=index.dev.js.map

package/dist/esm/index.dev.js.map

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

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { DEFAULT_PROTOCOL_ALLOWLIST, PathParamError, SearchParamError, TSR_DEFERRED_PROMISE, cleanPath, componentTypes, composeRewrites, createControlledPromise, createRouterConfig, createSerializationAdapter, deepEqual, defaultParseSearch, defaultSerializeError, defaultStringifySearch, defer, functionalUpdate, getInitialRouterState, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, lazyFn, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight } from "@tanstack/router-core";
+import { DEFAULT_PROTOCOL_ALLOWLIST, SearchParamError, cleanPath, composeRewrites, createControlledPromise, createRouterConfig, createSerializationAdapter, deepEqual, defaultParseSearch, defaultStringifySearch, defer, functionalUpdate, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, lazyFn, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight } from "@tanstack/router-core";
 import { createBrowserHistory, createHashHistory, createHistory, createMemoryHistory } from "@tanstack/history";
 import { Await, useAwaited } from "./awaited.js";
 import { CatchBoundary, ErrorComponent } from "./CatchBoundary.js";
@@ -7,7 +7,6 @@ import { FileRoute, FileRouteLoader, LazyRoute, createFileRoute, createLazyFileR
 import { lazyRouteComponent } from "./lazyRouteComponent.js";
 import { Link, createLink, linkOptions, useLinkProps } from "./link.js";
 import { MatchRoute, Matches, useChildMatches, useMatchRoute, useMatches, useParentMatches } from "./Matches.js";
-import { matchContext } from "./matchContext.js";
 import { Match, Outlet } from "./Match.js";
 import { useMatch } from "./useMatch.js";
 import { useLoaderDeps } from "./useLoaderDeps.js";
@@ -20,13 +19,11 @@ import { Block, useBlocker } from "./useBlocker.js";
 import { Navigate, useNavigate } from "./useNavigate.js";
 import { useParams } from "./useParams.js";
 import { useSearch } from "./useSearch.js";
-import { getRouterContext } from "./routerContext.js";
 import { useRouteContext } from "./useRouteContext.js";
 import { useRouter } from "./useRouter.js";
 import { useRouterState } from "./useRouterState.js";
 import { useLocation } from "./useLocation.js";
 import { useCanGoBack } from "./useCanGoBack.js";
-import { useLayoutEffect, useStableCallback } from "./utils.js";
 import { CatchNotFound, DefaultGlobalNotFound } from "./not-found.js";
 import { ScriptOnce } from "./ScriptOnce.js";
 import { Asset } from "./Asset.js";
@@ -54,7 +51,6 @@ export {
   Navigate,
   NotFoundRoute,
   Outlet,
-  PathParamError,
   RootRoute,
   Route,
   RouteApi,
@@ -65,9 +61,7 @@ export {
   Scripts,
   ScrollRestoration,
   SearchParamError,
-  TSR_DEFERRED_PROMISE,
   cleanPath,
-  componentTypes,
   composeRewrites,
   createBrowserHistory,
   createControlledPromise,
@@ -87,13 +81,10 @@ export {
   createSerializationAdapter,
   deepEqual,
   defaultParseSearch,
-  defaultSerializeError,
   defaultStringifySearch,
   defer,
   functionalUpdate,
-  getInitialRouterState,
   getRouteApi,
-  getRouterContext,
   interpolatePath,
   isMatch,
   isNotFound,
@@ -104,7 +95,6 @@ export {
   lazyFn,
   lazyRouteComponent,
   linkOptions,
-  matchContext,
   notFound,
   parseSearchWith,
   redirect,
@@ -124,7 +114,6 @@ export {
   useChildMatches,
   useElementScrollRestoration,
   useHydrated,
-  useLayoutEffect,
   useLinkProps,
   useLoaderData,
   useLoaderDeps,
@@ -139,7 +128,6 @@ export {
   useRouter,
   useRouterState,
   useSearch,
-  useStableCallback,
   useTags
 };
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

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

package/dist/esm/routerContext.d.ts

@@ -1,8 +1,3 @@
 import { AnyRouter } from '@tanstack/router-core';
 import * as React from 'react';
-declare global {
-    interface Window {
-        __TSR_ROUTER_CONTEXT__?: React.Context<AnyRouter>;
-    }
-}
-export declare function getRouterContext(): React.Context<AnyRouter>;
+export declare const routerContext: React.Context<AnyRouter>;

package/dist/esm/routerContext.js

@@ -1,16 +1,6 @@
 import * as React from "react";
 const routerContext = React.createContext(null);
-function getRouterContext() {
-  if (typeof document === "undefined") {
-    return routerContext;
-  }
-  if (window.__TSR_ROUTER_CONTEXT__) {
-    return window.__TSR_ROUTER_CONTEXT__;
-  }
-  window.__TSR_ROUTER_CONTEXT__ = routerContext;
-  return routerContext;
-}
 export {
-  getRouterContext
+  routerContext
 };
 //# sourceMappingURL=routerContext.js.map

package/dist/esm/routerContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"routerContext.js","sources":["../../src/routerContext.tsx"],"sourcesContent":["import * as React from 'react'\nimport type { AnyRouter } from '@tanstack/router-core'\n\ndeclare global {\n  interface Window {\n    __TSR_ROUTER_CONTEXT__?: React.Context<AnyRouter>\n  }\n}\n\nconst routerContext = React.createContext<AnyRouter>(null!)\n\nexport function getRouterContext() {\n  if (typeof document === 'undefined') {\n    return routerContext\n  }\n\n  if (window.__TSR_ROUTER_CONTEXT__) {\n    return window.__TSR_ROUTER_CONTEXT__\n  }\n\n  window.__TSR_ROUTER_CONTEXT__ = routerContext as any\n\n  return routerContext\n}\n"],"names":[],"mappings":";AASA,MAAM,gBAAgB,MAAM,cAAyB,IAAK;AAEnD,SAAS,mBAAmB;AACjC,MAAI,OAAO,aAAa,aAAa;AACnC,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,wBAAwB;AACjC,WAAO,OAAO;AAAA,EAChB;AAEA,SAAO,yBAAyB;AAEhC,SAAO;AACT;"}
+{"version":3,"file":"routerContext.js","sources":["../../src/routerContext.tsx"],"sourcesContent":["import * as React from 'react'\nimport type { AnyRouter } from '@tanstack/router-core'\n\nexport const routerContext = React.createContext<AnyRouter>(null!)\n"],"names":[],"mappings":";AAGO,MAAM,gBAAgB,MAAM,cAAyB,IAAK;"}

package/dist/esm/useRouter.js

@@ -1,8 +1,8 @@
 import * as React from "react";
 import warning from "tiny-warning";
-import { getRouterContext } from "./routerContext.js";
+import { routerContext } from "./routerContext.js";
 function useRouter(opts) {
-  const value = React.useContext(getRouterContext());
+  const value = React.useContext(routerContext);
   warning(
     !((opts?.warn ?? true) && !value),
     "useRouter must be used inside a <RouterProvider> component!"

package/dist/esm/useRouter.js.map

@@ -1 +1 @@
-{"version":3,"file":"useRouter.js","sources":["../../src/useRouter.tsx"],"sourcesContent":["import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { getRouterContext } from './routerContext'\nimport type { AnyRouter, RegisteredRouter } from '@tanstack/router-core'\n\n/**\n * Access the current TanStack Router instance from React context.\n * Must be used within a `RouterProvider`.\n *\n * Options:\n * - `warn`: Log a warning if no router context is found (default: true).\n *\n * @returns The registered router instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useRouterHook\n */\nexport function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {\n  warn?: boolean\n}): TRouter {\n  const value = React.useContext(getRouterContext())\n  warning(\n    !((opts?.warn ?? true) && !value),\n    'useRouter must be used inside a <RouterProvider> component!',\n  )\n  return value as any\n}\n"],"names":[],"mappings":";;;AAeO,SAAS,UAAwD,MAE5D;AACV,QAAM,QAAQ,MAAM,WAAW,iBAAA,CAAkB;AACjD;AAAA,IACE,GAAG,MAAM,QAAQ,SAAS,CAAC;AAAA,IAC3B;AAAA,EAAA;AAEF,SAAO;AACT;"}
+{"version":3,"file":"useRouter.js","sources":["../../src/useRouter.tsx"],"sourcesContent":["import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { routerContext } from './routerContext'\nimport type { AnyRouter, RegisteredRouter } from '@tanstack/router-core'\n\n/**\n * Access the current TanStack Router instance from React context.\n * Must be used within a `RouterProvider`.\n *\n * Options:\n * - `warn`: Log a warning if no router context is found (default: true).\n *\n * @returns The registered router instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useRouterHook\n */\nexport function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {\n  warn?: boolean\n}): TRouter {\n  const value = React.useContext(routerContext)\n  warning(\n    !((opts?.warn ?? true) && !value),\n    'useRouter must be used inside a <RouterProvider> component!',\n  )\n  return value as any\n}\n"],"names":[],"mappings":";;;AAeO,SAAS,UAAwD,MAE5D;AACV,QAAM,QAAQ,MAAM,WAAW,aAAa;AAC5C;AAAA,IACE,GAAG,MAAM,QAAQ,SAAS,CAAC;AAAA,IAC3B;AAAA,EAAA;AAEF,SAAO;AACT;"}

package/dist/esm/utils.js

@@ -1,12 +1,6 @@
 import * as React from "react";
 const REACT_USE = "use";
 const reactUse = React[REACT_USE];
-function useStableCallback(fn) {
-  const fnRef = React.useRef(fn);
-  fnRef.current = fn;
-  const ref = React.useRef((...args) => fnRef.current(...args));
-  return ref.current;
-}
 const useLayoutEffect = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect;
 function usePrevious(value) {
   const ref = React.useRef({
@@ -46,7 +40,6 @@ export {
   useForwardedRef,
   useIntersectionObserver,
   useLayoutEffect,
-  usePrevious,
-  useStableCallback
+  usePrevious
 };
 //# sourceMappingURL=utils.js.map

package/dist/esm/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["import * as React from 'react'\n\n// Safe version of React.use() that will not cause compilation errors against\n// React 18 with Webpack, which statically analyzes imports and fails when it\n// sees React.use referenced (since 'use' is not exported from React 18).\n// This uses a dynamic string lookup to avoid the static analysis.\nconst REACT_USE = 'use'\n\n/**\n * React.use if available (React 19+), undefined otherwise.\n * Use dynamic lookup to avoid Webpack compilation errors with React 18.\n */\nexport const reactUse:\n  | (<T>(usable: Promise<T> | React.Context<T>) => T)\n  | undefined = (React as any)[REACT_USE]\n\nexport function useStableCallback<T extends (...args: Array<any>) => any>(\n  fn: T,\n): T {\n  const fnRef = React.useRef(fn)\n  fnRef.current = fn\n\n  const ref = React.useRef((...args: Array<any>) => fnRef.current(...args))\n  return ref.current as T\n}\n\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious<T>(value: T): T | null {\n  // initialise the ref with previous and current values\n  const ref = React.useRef<{ value: T; prev: T | null }>({\n    value: value,\n    prev: null,\n  })\n\n  const current = ref.current.value\n\n  // if the value passed into hook doesn't match what we store as \"current\"\n  // move the \"current\" to the \"previous\"\n  // and store the passed value as \"current\"\n  if (value !== current) {\n    ref.current = {\n      value: value,\n      prev: current,\n    }\n  }\n\n  // return the previous value only\n  return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef<HTMLDivElement>(null)\n * useIntersectionObserver(\n *  ref,\n *  (entry) => { doSomething(entry) },\n *  { rootMargin: '10px' },\n *  { disabled: false }\n * )\n * return <div ref={ref} />\n * ```\n */\nexport function useIntersectionObserver<T extends Element>(\n  ref: React.RefObject<T | null>,\n  callback: (entry: IntersectionObserverEntry | undefined) => void,\n  intersectionObserverOptions: IntersectionObserverInit = {},\n  options: { disabled?: boolean } = {},\n) {\n  React.useEffect(() => {\n    if (\n      !ref.current ||\n      options.disabled ||\n      typeof IntersectionObserver !== 'function'\n    ) {\n      return\n    }\n\n    const observer = new IntersectionObserver(([entry]) => {\n      callback(entry)\n    }, intersectionObserverOptions)\n\n    observer.observe(ref.current)\n\n    return () => {\n      observer.disconnect()\n    }\n  }, [callback, intersectionObserverOptions, options.disabled, ref])\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n *  const innerRef = useForwardedRef(ref)\n *  return <div ref={innerRef} />\n * })\n * ```\n */\nexport function useForwardedRef<T>(ref?: React.ForwardedRef<T>) {\n  const innerRef = React.useRef<T>(null)\n  React.useImperativeHandle(ref, () => innerRef.current!, [])\n  return innerRef\n}\n"],"names":[],"mappings":";AAMA,MAAM,YAAY;AAMX,MAAM,WAEI,MAAc,SAAS;AAEjC,SAAS,kBACd,IACG;AACH,QAAM,QAAQ,MAAM,OAAO,EAAE;AAC7B,QAAM,UAAU;AAEhB,QAAM,MAAM,MAAM,OAAO,IAAI,SAAqB,MAAM,QAAQ,GAAG,IAAI,CAAC;AACxE,SAAO,IAAI;AACb;AAEO,MAAM,kBACX,OAAO,WAAW,cAAc,MAAM,kBAAkB,MAAM;AAKzD,SAAS,YAAe,OAAoB;AAEjD,QAAM,MAAM,MAAM,OAAqC;AAAA,IACrD;AAAA,IACA,MAAM;AAAA,EAAA,CACP;AAED,QAAM,UAAU,IAAI,QAAQ;AAK5B,MAAI,UAAU,SAAS;AACrB,QAAI,UAAU;AAAA,MACZ;AAAA,MACA,MAAM;AAAA,IAAA;AAAA,EAEV;AAGA,SAAO,IAAI,QAAQ;AACrB;AA2BO,SAAS,wBACd,KACA,UACA,8BAAwD,CAAA,GACxD,UAAkC,IAClC;AACA,QAAM,UAAU,MAAM;AACpB,QACE,CAAC,IAAI,WACL,QAAQ,YACR,OAAO,yBAAyB,YAChC;AACA;AAAA,IACF;AAEA,UAAM,WAAW,IAAI,qBAAqB,CAAC,CAAC,KAAK,MAAM;AACrD,eAAS,KAAK;AAAA,IAChB,GAAG,2BAA2B;AAE9B,aAAS,QAAQ,IAAI,OAAO;AAE5B,WAAO,MAAM;AACX,eAAS,WAAA;AAAA,IACX;AAAA,EACF,GAAG,CAAC,UAAU,6BAA6B,QAAQ,UAAU,GAAG,CAAC;AACnE;AAeO,SAAS,gBAAmB,KAA6B;AAC9D,QAAM,WAAW,MAAM,OAAU,IAAI;AACrC,QAAM,oBAAoB,KAAK,MAAM,SAAS,SAAU,CAAA,CAAE;AAC1D,SAAO;AACT;"}
+{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["import * as React from 'react'\n\n// Safe version of React.use() that will not cause compilation errors against\n// React 18 with Webpack, which statically analyzes imports and fails when it\n// sees React.use referenced (since 'use' is not exported from React 18).\n// This uses a dynamic string lookup to avoid the static analysis.\nconst REACT_USE = 'use'\n\n/**\n * React.use if available (React 19+), undefined otherwise.\n * Use dynamic lookup to avoid Webpack compilation errors with React 18.\n */\nexport const reactUse:\n  | (<T>(usable: Promise<T> | React.Context<T>) => T)\n  | undefined = (React as any)[REACT_USE]\n\nexport function useStableCallback<T extends (...args: Array<any>) => any>(\n  fn: T,\n): T {\n  const fnRef = React.useRef(fn)\n  fnRef.current = fn\n\n  const ref = React.useRef((...args: Array<any>) => fnRef.current(...args))\n  return ref.current as T\n}\n\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious<T>(value: T): T | null {\n  // initialise the ref with previous and current values\n  const ref = React.useRef<{ value: T; prev: T | null }>({\n    value: value,\n    prev: null,\n  })\n\n  const current = ref.current.value\n\n  // if the value passed into hook doesn't match what we store as \"current\"\n  // move the \"current\" to the \"previous\"\n  // and store the passed value as \"current\"\n  if (value !== current) {\n    ref.current = {\n      value: value,\n      prev: current,\n    }\n  }\n\n  // return the previous value only\n  return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef<HTMLDivElement>(null)\n * useIntersectionObserver(\n *  ref,\n *  (entry) => { doSomething(entry) },\n *  { rootMargin: '10px' },\n *  { disabled: false }\n * )\n * return <div ref={ref} />\n * ```\n */\nexport function useIntersectionObserver<T extends Element>(\n  ref: React.RefObject<T | null>,\n  callback: (entry: IntersectionObserverEntry | undefined) => void,\n  intersectionObserverOptions: IntersectionObserverInit = {},\n  options: { disabled?: boolean } = {},\n) {\n  React.useEffect(() => {\n    if (\n      !ref.current ||\n      options.disabled ||\n      typeof IntersectionObserver !== 'function'\n    ) {\n      return\n    }\n\n    const observer = new IntersectionObserver(([entry]) => {\n      callback(entry)\n    }, intersectionObserverOptions)\n\n    observer.observe(ref.current)\n\n    return () => {\n      observer.disconnect()\n    }\n  }, [callback, intersectionObserverOptions, options.disabled, ref])\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n *  const innerRef = useForwardedRef(ref)\n *  return <div ref={innerRef} />\n * })\n * ```\n */\nexport function useForwardedRef<T>(ref?: React.ForwardedRef<T>) {\n  const innerRef = React.useRef<T>(null)\n  React.useImperativeHandle(ref, () => innerRef.current!, [])\n  return innerRef\n}\n"],"names":[],"mappings":";AAMA,MAAM,YAAY;AAMX,MAAM,WAEI,MAAc,SAAS;AAYjC,MAAM,kBACX,OAAO,WAAW,cAAc,MAAM,kBAAkB,MAAM;AAKzD,SAAS,YAAe,OAAoB;AAEjD,QAAM,MAAM,MAAM,OAAqC;AAAA,IACrD;AAAA,IACA,MAAM;AAAA,EAAA,CACP;AAED,QAAM,UAAU,IAAI,QAAQ;AAK5B,MAAI,UAAU,SAAS;AACrB,QAAI,UAAU;AAAA,MACZ;AAAA,MACA,MAAM;AAAA,IAAA;AAAA,EAEV;AAGA,SAAO,IAAI,QAAQ;AACrB;AA2BO,SAAS,wBACd,KACA,UACA,8BAAwD,CAAA,GACxD,UAAkC,IAClC;AACA,QAAM,UAAU,MAAM;AACpB,QACE,CAAC,IAAI,WACL,QAAQ,YACR,OAAO,yBAAyB,YAChC;AACA;AAAA,IACF;AAEA,UAAM,WAAW,IAAI,qBAAqB,CAAC,CAAC,KAAK,MAAM;AACrD,eAAS,KAAK;AAAA,IAChB,GAAG,2BAA2B;AAE9B,aAAS,QAAQ,IAAI,OAAO;AAE5B,WAAO,MAAM;AACX,eAAS,WAAA;AAAA,IACX;AAAA,EACF,GAAG,CAAC,UAAU,6BAA6B,QAAQ,UAAU,GAAG,CAAC;AACnE;AAeO,SAAS,gBAAmB,KAA6B;AAC9D,QAAM,WAAW,MAAM,OAAU,IAAI;AACrC,QAAM,oBAAoB,KAAK,MAAM,SAAS,SAAU,CAAA,CAAE;AAC1D,SAAO;AACT;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/react-router",
-  "version": "1.162.2",
+  "version": "1.162.5",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -82,7 +82,7 @@
     "tiny-invariant": "^1.3.3",
     "tiny-warning": "^1.0.3",
     "@tanstack/history": "1.161.4",
-    "@tanstack/router-core": "1.162.2"
+    "@tanstack/router-core": "1.162.5"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.6.3",

package/src/RouterProvider.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react'
 import { Matches } from './Matches'
-import { getRouterContext } from './routerContext'
+import { routerContext } from './routerContext'
 import type {
   AnyRouter,
   RegisteredRouter,
@@ -33,8 +33,6 @@ export function RouterContextProvider<
     })
   }
 
-  const routerContext = getRouterContext()
-
   const provider = (
     <routerContext.Provider value={router as AnyRouter}>
       {children}

package/src/index.tsx

@@ -1,6 +1,5 @@
 export {
   defer,
-  TSR_DEFERRED_PROMISE,
   isMatch,
   joinPaths,
   cleanPath,
@@ -10,7 +9,6 @@ export {
   resolvePath,
   interpolatePath,
   rootRouteId,
-  defaultSerializeError,
   defaultParseSearch,
   defaultStringifySearch,
   parseSearchWith,
@@ -236,7 +234,6 @@ export {
 
 export type { UseMatchRouteOptions, MakeMatchRouteOptions } from './Matches'
 
-export { matchContext } from './matchContext'
 export { Match, Outlet } from './Match'
 
 export { useMatch } from './useMatch'
@@ -274,13 +271,7 @@ export type {
 
 export { createRouter, Router } from './router'
 
-export {
-  componentTypes,
-  lazyFn,
-  SearchParamError,
-  PathParamError,
-  getInitialRouterState,
-} from '@tanstack/router-core'
+export { lazyFn, SearchParamError } from '@tanstack/router-core'
 
 export { RouterProvider, RouterContextProvider } from './RouterProvider'
 export type { RouterProps } from './RouterProvider'
@@ -298,21 +289,12 @@ export { useNavigate, Navigate } from './useNavigate'
 export { useParams } from './useParams'
 export { useSearch } from './useSearch'
 
-export {
-  getRouterContext, // SSR
-} from './routerContext'
-
 export { useRouteContext } from './useRouteContext'
 export { useRouter } from './useRouter'
 export { useRouterState } from './useRouterState'
 export { useLocation } from './useLocation'
 export { useCanGoBack } from './useCanGoBack'
 
-export {
-  useLayoutEffect, // SSR
-  useStableCallback,
-} from './utils'
-
 export { CatchNotFound, DefaultGlobalNotFound } from './not-found'
 export { notFound, isNotFound } from '@tanstack/router-core'
 export type { NotFoundError } from '@tanstack/router-core'

package/src/routerContext.tsx

@@ -1,24 +1,4 @@
 import * as React from 'react'
 import type { AnyRouter } from '@tanstack/router-core'
 
-declare global {
-  interface Window {
-    __TSR_ROUTER_CONTEXT__?: React.Context<AnyRouter>
-  }
-}
-
-const routerContext = React.createContext<AnyRouter>(null!)
-
-export function getRouterContext() {
-  if (typeof document === 'undefined') {
-    return routerContext
-  }
-
-  if (window.__TSR_ROUTER_CONTEXT__) {
-    return window.__TSR_ROUTER_CONTEXT__
-  }
-
-  window.__TSR_ROUTER_CONTEXT__ = routerContext as any
-
-  return routerContext
-}
+export const routerContext = React.createContext<AnyRouter>(null!)

package/src/useRouter.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react'
 import warning from 'tiny-warning'
-import { getRouterContext } from './routerContext'
+import { routerContext } from './routerContext'
 import type { AnyRouter, RegisteredRouter } from '@tanstack/router-core'
 
 /**
@@ -16,7 +16,7 @@ import type { AnyRouter, RegisteredRouter } from '@tanstack/router-core'
 export function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {
   warn?: boolean
 }): TRouter {
-  const value = React.useContext(getRouterContext())
+  const value = React.useContext(routerContext)
   warning(
     !((opts?.warn ?? true) && !value),
     'useRouter must be used inside a <RouterProvider> component!',