@tanstack/react-router 1.20.1 → 1.20.3-alpha.1

package/dist/cjs/index.cjs

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const history = require("@tanstack/history");
 const invariant = require("tiny-invariant");
 const warning = require("tiny-warning");
+const routerCore = require("@tanstack/router-core");
+const history = require("@tanstack/history");
 const awaited = require("./awaited.cjs");
-const defer = require("./defer.cjs");
 const CatchBoundary = require("./CatchBoundary.cjs");
+const ClientOnly = require("./ClientOnly.cjs");
 const fileRoute = require("./fileRoute.cjs");
 const lazyRouteComponent = require("./lazyRouteComponent.cjs");
 const link = require("./link.cjs");
 const Matches = require("./Matches.cjs");
-const path = require("./path.cjs");
-const qss = require("./qss.cjs");
-const redirects = require("./redirects.cjs");
+const matchContext = require("./matchContext.cjs");
+const Match = require("./Match.cjs");
+const useMatch = require("./useMatch.cjs");
+const useLoaderDeps = require("./useLoaderDeps.cjs");
+const useLoaderData = require("./useLoaderData.cjs");
 const route = require("./route.cjs");
 const router = require("./router.cjs");
 const RouterProvider = require("./RouterProvider.cjs");
-const scrollRestoration = require("./scroll-restoration.cjs");
-const searchParams = require("./searchParams.cjs");
+const ScrollRestoration = require("./ScrollRestoration.cjs");
 const useBlocker = require("./useBlocker.cjs");
 const useNavigate = require("./useNavigate.cjs");
 const useParams = require("./useParams.cjs");
@@ -26,18 +28,205 @@ 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 createServerFn = require("./createServerFn.cjs");
+const ScriptOnce = require("./ScriptOnce.cjs");
+const Asset = require("./Asset.cjs");
+const HeadContent = require("./HeadContent.cjs");
+const Scripts = require("./Scripts.cjs");
 exports.invariant = invariant;
 exports.warning = warning;
+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, "createControlledPromise", {
+  enumerable: true,
+  get: () => routerCore.createControlledPromise
+});
+Object.defineProperty(exports, "decode", {
+  enumerable: true,
+  get: () => routerCore.decode
+});
+Object.defineProperty(exports, "deepEqual", {
+  enumerable: true,
+  get: () => routerCore.deepEqual
+});
+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
+});
+Object.defineProperty(exports, "defer", {
+  enumerable: true,
+  get: () => routerCore.defer
+});
+Object.defineProperty(exports, "encode", {
+  enumerable: true,
+  get: () => routerCore.encode
+});
+Object.defineProperty(exports, "escapeJSON", {
+  enumerable: true,
+  get: () => routerCore.escapeJSON
+});
+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
+});
+Object.defineProperty(exports, "isMatch", {
+  enumerable: true,
+  get: () => routerCore.isMatch
+});
+Object.defineProperty(exports, "isNotFound", {
+  enumerable: true,
+  get: () => routerCore.isNotFound
+});
+Object.defineProperty(exports, "isPlainArray", {
+  enumerable: true,
+  get: () => routerCore.isPlainArray
+});
+Object.defineProperty(exports, "isPlainObject", {
+  enumerable: true,
+  get: () => routerCore.isPlainObject
+});
+Object.defineProperty(exports, "isRedirect", {
+  enumerable: true,
+  get: () => routerCore.isRedirect
+});
+Object.defineProperty(exports, "joinPaths", {
+  enumerable: true,
+  get: () => routerCore.joinPaths
+});
+Object.defineProperty(exports, "lazyFn", {
+  enumerable: true,
+  get: () => routerCore.lazyFn
+});
+Object.defineProperty(exports, "matchByPath", {
+  enumerable: true,
+  get: () => routerCore.matchByPath
+});
+Object.defineProperty(exports, "matchPathname", {
+  enumerable: true,
+  get: () => routerCore.matchPathname
+});
+Object.defineProperty(exports, "notFound", {
+  enumerable: true,
+  get: () => routerCore.notFound
+});
+Object.defineProperty(exports, "parsePathname", {
+  enumerable: true,
+  get: () => routerCore.parsePathname
+});
+Object.defineProperty(exports, "parseSearchWith", {
+  enumerable: true,
+  get: () => routerCore.parseSearchWith
+});
+Object.defineProperty(exports, "pick", {
+  enumerable: true,
+  get: () => routerCore.pick
+});
+Object.defineProperty(exports, "redirect", {
+  enumerable: true,
+  get: () => routerCore.redirect
+});
+Object.defineProperty(exports, "removeBasepath", {
+  enumerable: true,
+  get: () => routerCore.removeBasepath
+});
+Object.defineProperty(exports, "replaceEqualDeep", {
+  enumerable: true,
+  get: () => routerCore.replaceEqualDeep
+});
+Object.defineProperty(exports, "resolvePath", {
+  enumerable: true,
+  get: () => routerCore.resolvePath
+});
+Object.defineProperty(exports, "retainSearchParams", {
+  enumerable: true,
+  get: () => routerCore.retainSearchParams
+});
+Object.defineProperty(exports, "rootRouteId", {
+  enumerable: true,
+  get: () => routerCore.rootRouteId
+});
+Object.defineProperty(exports, "shallow", {
+  enumerable: true,
+  get: () => routerCore.shallow
+});
+Object.defineProperty(exports, "stringifySearchWith", {
+  enumerable: true,
+  get: () => routerCore.stringifySearchWith
+});
+Object.defineProperty(exports, "stripSearchParams", {
+  enumerable: true,
+  get: () => routerCore.stripSearchParams
+});
+Object.defineProperty(exports, "trimPath", {
+  enumerable: true,
+  get: () => routerCore.trimPath
+});
+Object.defineProperty(exports, "trimPathLeft", {
+  enumerable: true,
+  get: () => routerCore.trimPathLeft
+});
+Object.defineProperty(exports, "trimPathRight", {
+  enumerable: true,
+  get: () => routerCore.trimPathRight
+});
+Object.defineProperty(exports, "createBrowserHistory", {
+  enumerable: true,
+  get: () => history.createBrowserHistory
+});
+Object.defineProperty(exports, "createHashHistory", {
+  enumerable: true,
+  get: () => history.createHashHistory
+});
+Object.defineProperty(exports, "createHistory", {
+  enumerable: true,
+  get: () => history.createHistory
+});
+Object.defineProperty(exports, "createMemoryHistory", {
+  enumerable: true,
+  get: () => history.createMemoryHistory
+});
 exports.Await = awaited.Await;
 exports.useAwaited = awaited.useAwaited;
-exports.defer = defer.defer;
-exports.isDehydratedDeferred = defer.isDehydratedDeferred;
 exports.CatchBoundary = CatchBoundary.CatchBoundary;
-exports.CatchBoundaryImpl = CatchBoundary.CatchBoundaryImpl;
 exports.ErrorComponent = CatchBoundary.ErrorComponent;
+exports.ClientOnly = ClientOnly.ClientOnly;
 exports.FileRoute = fileRoute.FileRoute;
 exports.FileRouteLoader = fileRoute.FileRouteLoader;
 exports.LazyRoute = fileRoute.LazyRoute;
@@ -47,37 +236,20 @@ exports.createLazyRoute = fileRoute.createLazyRoute;
 exports.lazyRouteComponent = lazyRouteComponent.lazyRouteComponent;
 exports.Link = link.Link;
 exports.createLink = link.createLink;
+exports.linkOptions = link.linkOptions;
 exports.useLinkProps = link.useLinkProps;
-exports.Match = Matches.Match;
 exports.MatchRoute = Matches.MatchRoute;
 exports.Matches = Matches.Matches;
-exports.Outlet = Matches.Outlet;
-exports.defaultDeserializeError = Matches.defaultDeserializeError;
-exports.getRenderedMatches = Matches.getRenderedMatches;
-exports.isServerSideError = Matches.isServerSideError;
-exports.matchContext = Matches.matchContext;
 exports.useChildMatches = Matches.useChildMatches;
-exports.useLoaderData = Matches.useLoaderData;
-exports.useLoaderDeps = Matches.useLoaderDeps;
-exports.useMatch = Matches.useMatch;
 exports.useMatchRoute = Matches.useMatchRoute;
 exports.useMatches = Matches.useMatches;
 exports.useParentMatches = Matches.useParentMatches;
-exports.cleanPath = path.cleanPath;
-exports.interpolatePath = path.interpolatePath;
-exports.joinPaths = path.joinPaths;
-exports.matchByPath = path.matchByPath;
-exports.matchPathname = path.matchPathname;
-exports.parsePathname = path.parsePathname;
-exports.removeBasepath = path.removeBasepath;
-exports.resolvePath = path.resolvePath;
-exports.trimPath = path.trimPath;
-exports.trimPathLeft = path.trimPathLeft;
-exports.trimPathRight = path.trimPathRight;
-exports.decode = qss.decode;
-exports.encode = qss.encode;
-exports.isRedirect = redirects.isRedirect;
-exports.redirect = redirects.redirect;
+exports.matchContext = matchContext.matchContext;
+exports.Match = Match.Match;
+exports.Outlet = Match.Outlet;
+exports.useMatch = useMatch.useMatch;
+exports.useLoaderDeps = useLoaderDeps.useLoaderDeps;
+exports.useLoaderData = useLoaderData.useLoaderData;
 exports.NotFoundRoute = route.NotFoundRoute;
 exports.RootRoute = route.RootRoute;
 exports.Route = route.Route;
@@ -87,25 +259,13 @@ exports.createRootRouteWithContext = route.createRootRouteWithContext;
 exports.createRoute = route.createRoute;
 exports.createRouteMask = route.createRouteMask;
 exports.getRouteApi = route.getRouteApi;
-exports.rootRouteId = route.rootRouteId;
 exports.rootRouteWithContext = route.rootRouteWithContext;
-exports.PathParamError = router.PathParamError;
 exports.Router = router.Router;
-exports.SearchParamError = router.SearchParamError;
-exports.componentTypes = router.componentTypes;
 exports.createRouter = router.createRouter;
-exports.defaultSerializeError = router.defaultSerializeError;
-exports.getInitialRouterState = router.getInitialRouterState;
-exports.lazyFn = router.lazyFn;
+exports.RouterContextProvider = RouterProvider.RouterContextProvider;
 exports.RouterProvider = RouterProvider.RouterProvider;
-exports.getRouteMatch = RouterProvider.getRouteMatch;
-exports.ScrollRestoration = scrollRestoration.ScrollRestoration;
-exports.useElementScrollRestoration = scrollRestoration.useElementScrollRestoration;
-exports.useScrollRestoration = scrollRestoration.useScrollRestoration;
-exports.defaultParseSearch = searchParams.defaultParseSearch;
-exports.defaultStringifySearch = searchParams.defaultStringifySearch;
-exports.parseSearchWith = searchParams.parseSearchWith;
-exports.stringifySearchWith = searchParams.stringifySearchWith;
+exports.ScrollRestoration = ScrollRestoration.ScrollRestoration;
+exports.useElementScrollRestoration = ScrollRestoration.useElementScrollRestoration;
 exports.Block = useBlocker.Block;
 exports.useBlocker = useBlocker.useBlocker;
 exports.Navigate = useNavigate.Navigate;
@@ -116,31 +276,14 @@ exports.getRouterContext = routerContext.getRouterContext;
 exports.useRouteContext = useRouteContext.useRouteContext;
 exports.useRouter = useRouter.useRouter;
 exports.useRouterState = useRouterState.useRouterState;
-exports.deepEqual = utils.deepEqual;
-exports.escapeJSON = utils.escapeJSON;
-exports.functionalUpdate = utils.functionalUpdate;
-exports.isPlainArray = utils.isPlainArray;
-exports.isPlainObject = utils.isPlainObject;
-exports.isServer = utils.isServer;
-exports.last = utils.last;
-exports.pick = utils.pick;
-exports.replaceEqualDeep = utils.replaceEqualDeep;
-exports.shallow = utils.shallow;
+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.isNotFound = notFound.isNotFound;
-exports.notFound = notFound.notFound;
-exports.createServerFn = createServerFn.createServerFn;
-exports.json = createServerFn.json;
-exports.serverFnPayloadTypeHeader = createServerFn.serverFnPayloadTypeHeader;
-exports.serverFnReturnTypeHeader = createServerFn.serverFnReturnTypeHeader;
-Object.keys(history).forEach((k) => {
-  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
-    Object.defineProperty(exports, k, {
-      enumerable: true,
-      get: () => history[k]
-    });
-});
+exports.ScriptOnce = ScriptOnce.ScriptOnce;
+exports.Asset = Asset.Asset;
+exports.HeadContent = HeadContent.HeadContent;
+exports.Scripts = Scripts.Scripts;
 //# sourceMappingURL=index.cjs.map

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,32 +1,55 @@
-export * from '@tanstack/history';
 export { default as invariant } from 'tiny-invariant';
 export { default as warning } from 'tiny-warning';
-export * from './awaited.cjs';
-export * from './defer.cjs';
-export * from './CatchBoundary.cjs';
-export * from './fileRoute.cjs';
+export { defer, TSR_DEFERRED_PROMISE, isMatch, joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, resolvePath, parsePathname, interpolatePath, matchPathname, removeBasepath, matchByPath, encode, decode, rootRouteId, defaultSerializeError, defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith, escapeJSON, // SSR
+pick, functionalUpdate, replaceEqualDeep, isPlainObject, isPlainArray, deepEqual, shallow, createControlledPromise, retainSearchParams, stripSearchParams, } from '@tanstack/router-core';
+export type { AnyRoute, StartSerializer, Serializable, SerializerParse, SerializerParseBy, SerializerStringify, SerializerStringifyBy, DeferredPromiseState, DeferredPromise, ParsedLocation, ParsePathParams, RemoveTrailingSlashes, RemoveLeadingSlashes, ActiveOptions, Segment, ResolveRelativePath, RootRouteId, AnyPathParams, ResolveParams, SearchSchemaInput, AnyContext, RouteContext, PreloadableObj, RoutePathOptions, StaticDataRouteOption, RoutePathOptionsIntersection, UpdatableStaticRouteOption, MetaDescriptor, RouteLinkEntry, ParseParamsFn, SearchFilter, ResolveId, InferFullSearchSchema, InferFullSearchSchemaInput, ErrorRouteProps, ErrorComponentProps, NotFoundRouteProps, TrimPath, TrimPathLeft, TrimPathRight, ParseSplatParams, SplatParams, StringifyParamsFn, ParamsOptions, InferAllParams, InferAllContext, LooseReturnType, LooseAsyncReturnType, ContextReturnType, ContextAsyncReturnType, ResolveLoaderData, ResolveRouteContext, SearchSerializer, SearchParser, TrailingSlashOption, ExtractedEntry, ExtractedStream, ExtractedPromise, StreamState, 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, SerializerExtensions, CreateFileRoute, } from '@tanstack/router-core';
+export type * from './serializer.cjs';
+export { createHistory, createBrowserHistory, createHashHistory, createMemoryHistory, } from '@tanstack/history';
+export type { BlockerFn, HistoryLocation, RouterHistory, ParsedPath, HistoryState, } from '@tanstack/history';
+export { useAwaited, Await } from './awaited.cjs';
+export type { AwaitOptions } from './awaited.cjs';
+export { CatchBoundary, ErrorComponent } from './CatchBoundary.cjs';
+export { ClientOnly } from './ClientOnly.cjs';
+export { FileRoute, createFileRoute, FileRouteLoader, LazyRoute, createLazyRoute, createLazyFileRoute, } from './fileRoute.cjs';
 export * from './history.cjs';
-export * from './lazyRouteComponent.cjs';
-export * from './link.cjs';
-export * from './location.cjs';
-export * from './Matches.cjs';
-export * from './path.cjs';
-export * from './qss.cjs';
-export * from './redirects.cjs';
-export * from './route.cjs';
-export * from './routeInfo.cjs';
-export * from './router.cjs';
-export * from './RouterProvider.cjs';
-export * from './scroll-restoration.cjs';
-export * from './searchParams.cjs';
-export * from './useBlocker.cjs';
-export * from './useNavigate.cjs';
-export * from './useParams.cjs';
-export * from './useSearch.cjs';
-export * from './routerContext.cjs';
-export * from './useRouteContext.cjs';
-export * from './useRouter.cjs';
-export * from './useRouterState.cjs';
-export * from './utils.cjs';
-export * from './not-found.cjs';
-export * from './createServerFn.cjs';
+export { lazyRouteComponent } from './lazyRouteComponent.cjs';
+export { useLinkProps, createLink, Link, linkOptions } from './link.cjs';
+export type { InferDescendantToPaths, RelativeToPath, RelativeToParentPath, RelativeToCurrentPath, AbsoluteToPath, RelativeToPathAutoComplete, NavigateOptions, ToOptions, ToMaskOptions, ToSubOptions, ResolveRoute, SearchParamOptions, PathParamOptions, ToPathOption, LinkOptions, MakeOptionalPathParams, FileRouteTypes, RouteContextParameter, BeforeLoadContextParameter, ResolveAllContext, ResolveAllParamsFromParent, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, RouteIds, NavigateFn, BuildLocationFn, FullSearchSchemaOption, MakeRemountDepsOptionsUnion, RemountDepsOptions, ResolveFullPath, AnyRouteWithContext, AnyRouterWithContext, CommitLocationOptions, MatchLocation, UseNavigateResult, AnyRedirect, Redirect, ResolvedRedirect, MakeRouteMatch, MakeRouteMatchUnion, RouteMatch, AnyRouteMatch, RouteContextFn, RouteContextOptions, BeforeLoadFn, BeforeLoadContextOptions, ContextOptions, RouteOptions, FileBaseRouteOptions, BaseRouteOptions, UpdatableRouteOptions, RouteLoaderFn, LoaderFnContext, LazyRouteOptions, AnyRouter, RegisteredRouter, RouterContextOptions, ControllablePromise, InjectedHtmlEntry, RouterOptions, RouterErrorSerializer, RouterState, ListenerFn, BuildNextOptions, RouterConstructorOptions, RouterEvents, RouterEvent, RouterListener, RouteConstraints, RouteMask, MatchRouteOptions, CreateLazyFileRoute, } from '@tanstack/router-core';
+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';
+export { useLoaderData } from './useLoaderData.cjs';
+export { redirect, isRedirect } from '@tanstack/router-core';
+export { RouteApi, getRouteApi, Route, createRoute, RootRoute, rootRouteWithContext, createRootRoute, createRootRouteWithContext, createRouteMask, NotFoundRoute, } from './route.cjs';
+export type { AnyRootRoute, ReactNode, SyncRouteComponent, AsyncRouteComponent, RouteComponent, ErrorRouteComponent, NotFoundRouteComponent, } from './route.cjs';
+export { createRouter, Router } from './router.cjs';
+export { componentTypes, lazyFn, SearchParamError, PathParamError, getInitialRouterState, } from '@tanstack/router-core';
+export { RouterProvider, RouterContextProvider } from './RouterProvider.cjs';
+export type { RouterProps } from './RouterProvider.cjs';
+export { useElementScrollRestoration, ScrollRestoration, } from './ScrollRestoration.cjs';
+export type { UseBlockerOpts, ShouldBlockFn } from './useBlocker.cjs';
+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';
+export type { ValidateLinkOptions, InferStructuralSharing, ValidateUseSearchOptions, ValidateUseParamsOptions, ValidateLinkOptionsArray, } from './typePrimitives.cjs';
+export type { ValidateFromPath, ValidateToPath, ValidateSearch, ValidateParams, InferFrom, InferTo, InferMaskTo, InferMaskFrom, ValidateNavigateOptions, ValidateNavigateOptionsArray, ValidateRedirectOptions, ValidateRedirectOptionsArray, ValidateId, InferStrict, InferShouldThrow, InferSelected, ValidateUseSearchResult, ValidateUseParamsResult, } from '@tanstack/router-core';
+export { ScriptOnce } from './ScriptOnce.cjs';
+export { Asset } from './Asset.cjs';
+export { HeadContent } from './HeadContent.cjs';
+export { Scripts } from './Scripts.cjs';

package/dist/cjs/lazyRouteComponent.cjs

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
 const React = require("react");
+const Match = require("./Match.cjs");
+const ClientOnly = require("./ClientOnly.cjs");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -19,47 +22,55 @@ function _interopNamespaceDefault(e) {
 }
 const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
 function isModuleNotFoundError(error) {
-  return typeof (error == null ? void 0 : error.message) === "string" && /Failed to fetch dynamically imported module/.test(error.message);
+  if (typeof (error == null ? void 0 : error.message) !== "string") return false;
+  return error.message.startsWith("Failed to fetch dynamically imported module") || error.message.startsWith("error loading dynamically imported module") || error.message.startsWith("Importing a module script failed");
 }
-function lazyRouteComponent(importer, exportName) {
+function lazyRouteComponent(importer, exportName, ssr) {
   let loadPromise;
+  let comp;
+  let error;
+  let reload;
   const load = () => {
+    if (typeof document === "undefined" && (ssr == null ? void 0 : ssr()) === false) {
+      comp = () => null;
+      return Promise.resolve();
+    }
     if (!loadPromise) {
-      loadPromise = importer().catch((error) => {
+      loadPromise = importer().then((res) => {
+        loadPromise = void 0;
+        comp = res[exportName ?? "default"];
+      }).catch((err) => {
+        error = err;
         if (isModuleNotFoundError(error)) {
-          loadPromise.moduleNotFoundError = error;
-          return null;
+          if (error instanceof Error && typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+            const storageKey = `tanstack_router_reload:${error.message}`;
+            if (!sessionStorage.getItem(storageKey)) {
+              sessionStorage.setItem(storageKey, "1");
+              reload = true;
+            }
+          }
         }
-        throw error;
       });
     }
     return loadPromise;
   };
-  const lazyComp = React__namespace.lazy(async () => {
-    try {
-      const promise = load();
-      if (promise.moduleNotFoundError) {
-        throw promise.moduleNotFoundError;
-      }
-      const moduleExports = await promise;
-      const comp = moduleExports[exportName ?? "default"];
-      return {
-        default: comp
-      };
-    } catch (error) {
-      if (error instanceof Error && isModuleNotFoundError(error) && typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
-        const storageKey = `tanstack_router_reload:${error.message}`;
-        if (!sessionStorage.getItem(storageKey)) {
-          sessionStorage.setItem(storageKey, "1");
-          window.location.reload();
-          return {
-            default: () => null
-          };
-        }
-      }
+  const lazyComp = function Lazy(props) {
+    if (reload) {
+      window.location.reload();
+      throw new Promise(() => {
+      });
+    }
+    if (error) {
       throw error;
     }
-  });
+    if (!comp) {
+      throw load();
+    }
+    if ((ssr == null ? void 0 : ssr()) === false) {
+      return /* @__PURE__ */ jsxRuntime.jsx(ClientOnly.ClientOnly, { fallback: /* @__PURE__ */ jsxRuntime.jsx(Match.Outlet, {}), children: React__namespace.createElement(comp, props) });
+    }
+    return React__namespace.createElement(comp, props);
+  };
   lazyComp.preload = load;
   return lazyComp;
 }

package/dist/cjs/lazyRouteComponent.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lazyRouteComponent.cjs","sources":["../../src/lazyRouteComponent.tsx"],"sourcesContent":["import * as React from 'react'\nimport { AsyncRouteComponent } from './route'\n\n// If the load fails due to module not found, it may mean a new version of\n// the build was deployed and the user's browser is still using an old version.\n// If this happens, the old version in the user's browser would have an outdated\n// URL to the lazy module.\n// In that case, we want to attempt one window refresh to get the latest.\nfunction isModuleNotFoundError(error: any): boolean {\n  return (\n    typeof error?.message === 'string' &&\n    /Failed to fetch dynamically imported module/.test(error.message)\n  )\n}\n\nexport function lazyRouteComponent<\n  T extends Record<string, any>,\n  TKey extends keyof T = 'default',\n>(\n  importer: () => Promise<T>,\n  exportName?: TKey,\n): T[TKey] extends (props: infer TProps) => any\n  ? AsyncRouteComponent<TProps>\n  : never {\n  let loadPromise: Promise<any> & {\n    moduleNotFoundError?: Error\n  }\n\n  const load = () => {\n    if (!loadPromise) {\n      loadPromise = importer().catch((error) => {\n        if (isModuleNotFoundError(error)) {\n          // We don't want an error thrown from preload in this case, because\n          // there's nothing we want to do about module not found during preload.\n          // Record the error, recover the promise with a null return,\n          // and we will attempt module not found resolution during the render path.\n\n          loadPromise.moduleNotFoundError = error\n\n          return null\n        }\n        throw error\n      })\n    }\n\n    return loadPromise\n  }\n\n  const lazyComp = React.lazy(async () => {\n    try {\n      const promise = load()\n\n      // Now that we're out of preload and into actual render path,\n      // throw the error if it was a module not found error during preload\n      if (promise.moduleNotFoundError) {\n        throw promise.moduleNotFoundError\n      }\n      const moduleExports = await promise\n\n      const comp = moduleExports[exportName ?? 'default']\n      return {\n        default: comp,\n      }\n    } catch (error) {\n      if (\n        error instanceof Error &&\n        isModuleNotFoundError(error) &&\n        typeof window !== 'undefined' &&\n        typeof sessionStorage !== 'undefined'\n      ) {\n        // Again, we want to reload one time on module not found error and not enter\n        // a reload loop if there is some other issue besides an old deploy.\n        // That's why we store our reload attempt in sessionStorage.\n        // Use error.message as key because it contains the module path that failed.\n        const storageKey = `tanstack_router_reload:${error.message}`\n        if (!sessionStorage.getItem(storageKey)) {\n          sessionStorage.setItem(storageKey, '1')\n          window.location.reload()\n\n          // Return empty component while we wait for window to reload\n          return {\n            default: () => null,\n          }\n        }\n      }\n      throw error\n    }\n  })\n\n  ;(lazyComp as any).preload = load\n\n  return lazyComp as any\n}\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;AAQA,SAAS,sBAAsB,OAAqB;AAClD,SACE,QAAO,+BAAO,aAAY,YAC1B,8CAA8C,KAAK,MAAM,OAAO;AAEpE;AAEgB,SAAA,mBAId,UACA,YAGQ;AACJ,MAAA;AAIJ,QAAM,OAAO,MAAM;AACjB,QAAI,CAAC,aAAa;AAChB,oBAAc,SAAS,EAAE,MAAM,CAAC,UAAU;AACpC,YAAA,sBAAsB,KAAK,GAAG;AAMhC,sBAAY,sBAAsB;AAE3B,iBAAA;AAAA,QACT;AACM,cAAA;AAAA,MAAA,CACP;AAAA,IACH;AAEO,WAAA;AAAA,EAAA;AAGH,QAAA,WAAWA,iBAAM,KAAK,YAAY;AAClC,QAAA;AACF,YAAM,UAAU;AAIhB,UAAI,QAAQ,qBAAqB;AAC/B,cAAM,QAAQ;AAAA,MAChB;AACA,YAAM,gBAAgB,MAAM;AAEtB,YAAA,OAAO,cAAc,cAAc,SAAS;AAC3C,aAAA;AAAA,QACL,SAAS;AAAA,MAAA;AAAA,aAEJ,OAAO;AAEZ,UAAA,iBAAiB,SACjB,sBAAsB,KAAK,KAC3B,OAAO,WAAW,eAClB,OAAO,mBAAmB,aAC1B;AAKM,cAAA,aAAa,0BAA0B,MAAM,OAAO;AAC1D,YAAI,CAAC,eAAe,QAAQ,UAAU,GAAG;AACxB,yBAAA,QAAQ,YAAY,GAAG;AACtC,iBAAO,SAAS;AAGT,iBAAA;AAAA,YACL,SAAS,MAAM;AAAA,UAAA;AAAA,QAEnB;AAAA,MACF;AACM,YAAA;AAAA,IACR;AAAA,EAAA,CACD;AAEC,WAAiB,UAAU;AAEtB,SAAA;AACT;;"}
+{"version":3,"file":"lazyRouteComponent.cjs","sources":["../../src/lazyRouteComponent.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Outlet } from './Match'\nimport { ClientOnly } from './ClientOnly'\nimport type { AsyncRouteComponent } from './route'\n\n// If the load fails due to module not found, it may mean a new version of\n// the build was deployed and the user's browser is still using an old version.\n// If this happens, the old version in the user's browser would have an outdated\n// URL to the lazy module.\n// In that case, we want to attempt one window refresh to get the latest.\nfunction isModuleNotFoundError(error: any): boolean {\n  // chrome: \"Failed to fetch dynamically imported module: http://localhost:5173/src/routes/posts.index.tsx?tsr-split\"\n  // firefox: \"error loading dynamically imported module: http://localhost:5173/src/routes/posts.index.tsx?tsr-split\"\n  // safari: \"Importing a module script failed.\"\n  if (typeof error?.message !== 'string') return false\n  return (\n    error.message.startsWith('Failed to fetch dynamically imported module') ||\n    error.message.startsWith('error loading dynamically imported module') ||\n    error.message.startsWith('Importing a module script failed')\n  )\n}\n\nexport function lazyRouteComponent<\n  T extends Record<string, any>,\n  TKey extends keyof T = 'default',\n>(\n  importer: () => Promise<T>,\n  exportName?: TKey,\n  ssr?: () => boolean,\n): T[TKey] extends (props: infer TProps) => any\n  ? AsyncRouteComponent<TProps>\n  : never {\n  let loadPromise: Promise<any> | undefined\n  let comp: T[TKey] | T['default']\n  let error: any\n  let reload: boolean\n\n  const load = () => {\n    if (typeof document === 'undefined' && ssr?.() === false) {\n      comp = (() => null) as any\n      return Promise.resolve()\n    }\n    if (!loadPromise) {\n      loadPromise = importer()\n        .then((res) => {\n          loadPromise = undefined\n          comp = res[exportName ?? 'default']\n        })\n        .catch((err) => {\n          // We don't want an error thrown from preload in this case, because\n          // there's nothing we want to do about module not found during preload.\n          // Record the error, the rest is handled during the render path.\n          error = err\n          if (isModuleNotFoundError(error)) {\n            if (\n              error instanceof Error &&\n              typeof window !== 'undefined' &&\n              typeof sessionStorage !== 'undefined'\n            ) {\n              // Again, we want to reload one time on module not found error and not enter\n              // a reload loop if there is some other issue besides an old deploy.\n              // That's why we store our reload attempt in sessionStorage.\n              // Use error.message as key because it contains the module path that failed.\n              const storageKey = `tanstack_router_reload:${error.message}`\n              if (!sessionStorage.getItem(storageKey)) {\n                sessionStorage.setItem(storageKey, '1')\n                reload = true\n              }\n            }\n          }\n        })\n    }\n\n    return loadPromise\n  }\n\n  const lazyComp = function Lazy(props: any) {\n    // Now that we're out of preload and into actual render path,\n    if (reload) {\n      // If it was a module loading error,\n      // throw eternal suspense while we wait for window to reload\n      window.location.reload()\n      throw new Promise(() => {})\n    }\n    if (error) {\n      // Otherwise, just throw the error\n      throw error\n    }\n\n    if (!comp) {\n      throw load()\n    }\n\n    if (ssr?.() === false) {\n      return (\n        <ClientOnly fallback={<Outlet />}>\n          {React.createElement(comp, props)}\n        </ClientOnly>\n      )\n    }\n    return React.createElement(comp, props)\n  }\n\n  ;(lazyComp as any).preload = load\n\n  return lazyComp as any\n}\n"],"names":["jsx","ClientOnly","Outlet","React"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAUA,SAAS,sBAAsB,OAAqB;AAIlD,MAAI,QAAO,+BAAO,aAAY,SAAiB,QAAA;AAC/C,SACE,MAAM,QAAQ,WAAW,6CAA6C,KACtE,MAAM,QAAQ,WAAW,2CAA2C,KACpE,MAAM,QAAQ,WAAW,kCAAkC;AAE/D;AAEgB,SAAA,mBAId,UACA,YACA,KAGQ;AACJ,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AAEJ,QAAM,OAAO,MAAM;AACjB,QAAI,OAAO,aAAa,gBAAe,kCAAY,OAAO;AACxD,aAAQ,MAAM;AACd,aAAO,QAAQ,QAAQ;AAAA,IAAA;AAEzB,QAAI,CAAC,aAAa;AAChB,oBAAc,SAAS,EACpB,KAAK,CAAC,QAAQ;AACC,sBAAA;AACP,eAAA,IAAI,cAAc,SAAS;AAAA,MAAA,CACnC,EACA,MAAM,CAAC,QAAQ;AAIN,gBAAA;AACJ,YAAA,sBAAsB,KAAK,GAAG;AAChC,cACE,iBAAiB,SACjB,OAAO,WAAW,eAClB,OAAO,mBAAmB,aAC1B;AAKM,kBAAA,aAAa,0BAA0B,MAAM,OAAO;AAC1D,gBAAI,CAAC,eAAe,QAAQ,UAAU,GAAG;AACxB,6BAAA,QAAQ,YAAY,GAAG;AAC7B,uBAAA;AAAA,YAAA;AAAA,UACX;AAAA,QACF;AAAA,MACF,CACD;AAAA,IAAA;AAGE,WAAA;AAAA,EACT;AAEM,QAAA,WAAW,SAAS,KAAK,OAAY;AAEzC,QAAI,QAAQ;AAGV,aAAO,SAAS,OAAO;AACjB,YAAA,IAAI,QAAQ,MAAM;AAAA,MAAA,CAAE;AAAA,IAAA;AAE5B,QAAI,OAAO;AAEH,YAAA;AAAA,IAAA;AAGR,QAAI,CAAC,MAAM;AACT,YAAM,KAAK;AAAA,IAAA;AAGT,SAAA,kCAAY,OAAO;AAEnB,aAAAA,2BAAA,IAACC,WAAW,YAAA,EAAA,UAAWD,2BAAAA,IAAAE,MAAAA,QAAA,CAAA,CAAO,GAC3B,UAAMC,iBAAA,cAAc,MAAM,KAAK,EAClC,CAAA;AAAA,IAAA;AAGG,WAAAA,iBAAM,cAAc,MAAM,KAAK;AAAA,EACxC;AAEE,WAAiB,UAAU;AAEtB,SAAA;AACT;;"}

package/dist/cjs/lazyRouteComponent.d.cts

@@ -1,2 +1,2 @@
 import { AsyncRouteComponent } from './route.cjs';
-export declare function lazyRouteComponent<T extends Record<string, any>, TKey extends keyof T = 'default'>(importer: () => Promise<T>, exportName?: TKey): T[TKey] extends (props: infer TProps) => any ? AsyncRouteComponent<TProps> : never;
+export declare function lazyRouteComponent<T extends Record<string, any>, TKey extends keyof T = 'default'>(importer: () => Promise<T>, exportName?: TKey, ssr?: () => boolean): T[TKey] extends (props: infer TProps) => any ? AsyncRouteComponent<TProps> : never;