@tanstack/solid-router 1.121.20 → 1.121.21

package/dist/cjs/fileRoute.d.cts

@@ -0,0 +1,54 @@
+import { UseParamsRoute } from './useParams.cjs';
+import { UseMatchRoute } from './useMatch.cjs';
+import { UseSearchRoute } from './useSearch.cjs';
+import { AnyContext, AnyRoute, AnyRouter, Constrain, ConstrainLiteral, FileBaseRouteOptions, FileRoutesByPath, LazyRouteOptions, RegisteredRouter, ResolveParams, Route, RouteById, RouteConstraints, RouteIds, RouteLoaderFn, UpdatableRouteOptions, UseNavigateResult } from '@tanstack/router-core';
+import { UseLoaderDepsRoute } from './useLoaderDeps.cjs';
+import { UseLoaderDataRoute } from './useLoaderData.cjs';
+import { UseRouteContextRoute } from './useRouteContext.cjs';
+export declare function createFileRoute<TFilePath extends keyof FileRoutesByPath, TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'], TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'], TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'], TFullPath extends RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath']>(path?: TFilePath): FileRoute<TFilePath, TParentRoute, TId, TPath, TFullPath>['createRoute'];
+/**
+  @deprecated It's no longer recommended to use the `FileRoute` class directly.
+  Instead, use `createFileRoute('/path/to/file')(options)` to create a file route.
+*/
+export declare class FileRoute<TFilePath extends keyof FileRoutesByPath, TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'], TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'], TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'], TFullPath extends RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath']> {
+    path?: TFilePath | undefined;
+    silent?: boolean;
+    constructor(path?: TFilePath | undefined, _opts?: {
+        silent: boolean;
+    });
+    createRoute: <TSearchValidator = undefined, TParams = ResolveParams<TPath>, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TChildren = unknown>(options?: FileBaseRouteOptions<TParentRoute, TId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, AnyContext, TRouteContextFn, TBeforeLoadFn> & UpdatableRouteOptions<TParentRoute, TId, TFullPath, TParams, TSearchValidator, TLoaderFn, TLoaderDeps, AnyContext, TRouteContextFn, TBeforeLoadFn>) => Route<TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchValidator, TParams, AnyContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, unknown>;
+}
+/**
+  @deprecated It's recommended not to split loaders into separate files.
+  Instead, place the loader function in the the main route file, inside the
+  `createFileRoute('/path/to/file)(options)` options.
+*/
+export declare function FileRouteLoader<TFilePath extends keyof FileRoutesByPath, TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute']>(_path: TFilePath): <TLoaderFn>(loaderFn: Constrain<TLoaderFn, RouteLoaderFn<TRoute['parentRoute'], TRoute['types']['id'], TRoute['types']['params'], TRoute['types']['loaderDeps'], TRoute['types']['routerContext'], TRoute['types']['routeContextFn'], TRoute['types']['beforeLoadFn']>>) => TLoaderFn;
+declare module '@tanstack/router-core' {
+    interface LazyRoute<in out TRoute extends AnyRoute> {
+        useMatch: UseMatchRoute<TRoute['id']>;
+        useRouteContext: UseRouteContextRoute<TRoute['id']>;
+        useSearch: UseSearchRoute<TRoute['id']>;
+        useParams: UseParamsRoute<TRoute['id']>;
+        useLoaderDeps: UseLoaderDepsRoute<TRoute['id']>;
+        useLoaderData: UseLoaderDataRoute<TRoute['id']>;
+        useNavigate: () => UseNavigateResult<TRoute['fullPath']>;
+    }
+}
+export declare class LazyRoute<TRoute extends AnyRoute> {
+    options: {
+        id: string;
+    } & LazyRouteOptions;
+    constructor(opts: {
+        id: string;
+    } & LazyRouteOptions);
+    useMatch: UseMatchRoute<TRoute['id']>;
+    useRouteContext: UseRouteContextRoute<TRoute['id']>;
+    useSearch: UseSearchRoute<TRoute['id']>;
+    useParams: UseParamsRoute<TRoute['id']>;
+    useLoaderDeps: UseLoaderDepsRoute<TRoute['id']>;
+    useLoaderData: UseLoaderDataRoute<TRoute['id']>;
+    useNavigate: () => UseNavigateResult<TRoute["fullPath"]>;
+}
+export declare function createLazyRoute<TRouter extends AnyRouter = RegisteredRouter, TId extends string = string, TRoute extends AnyRoute = RouteById<TRouter['routeTree'], TId>>(id: ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>): (opts: LazyRouteOptions) => LazyRoute<TRoute>;
+export declare function createLazyFileRoute<TFilePath extends keyof FileRoutesByPath, TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute']>(id: TFilePath): (opts: LazyRouteOptions) => LazyRoute<TRoute>;

package/dist/cjs/history.d.cts

@@ -0,0 +1,8 @@
+declare module '@tanstack/history' {
+    interface HistoryState {
+        __tempLocation?: HistoryLocation;
+        __tempKey?: string;
+        __hashScrollIntoViewOptions?: boolean | ScrollIntoViewOptions;
+    }
+}
+export {};

package/dist/cjs/index.cjs

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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 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 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("./ScrollRestoration.cjs");
+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");
+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.CatchBoundary = CatchBoundary.CatchBoundary;
+exports.ErrorComponent = CatchBoundary.ErrorComponent;
+exports.ClientOnly = ClientOnly.ClientOnly;
+exports.FileRoute = fileRoute.FileRoute;
+exports.FileRouteLoader = fileRoute.FileRouteLoader;
+exports.LazyRoute = fileRoute.LazyRoute;
+exports.createFileRoute = fileRoute.createFileRoute;
+exports.createLazyFileRoute = fileRoute.createLazyFileRoute;
+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.MatchRoute = Matches.MatchRoute;
+exports.Matches = Matches.Matches;
+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;
+exports.useLoaderDeps = useLoaderDeps.useLoaderDeps;
+exports.useLoaderData = useLoaderData.useLoaderData;
+exports.NotFoundRoute = route.NotFoundRoute;
+exports.RootRoute = route.RootRoute;
+exports.Route = route.Route;
+exports.RouteApi = route.RouteApi;
+exports.createRootRoute = route.createRootRoute;
+exports.createRootRouteWithContext = route.createRootRouteWithContext;
+exports.createRoute = route.createRoute;
+exports.createRouteMask = route.createRouteMask;
+exports.getRouteApi = route.getRouteApi;
+exports.rootRouteWithContext = route.rootRouteWithContext;
+exports.Router = router.Router;
+exports.createRouter = router.createRouter;
+exports.RouterContextProvider = RouterProvider.RouterContextProvider;
+exports.RouterProvider = RouterProvider.RouterProvider;
+exports.ScrollRestoration = ScrollRestoration.ScrollRestoration;
+exports.useElementScrollRestoration = ScrollRestoration.useElementScrollRestoration;
+exports.Block = useBlocker.Block;
+exports.useBlocker = useBlocker.useBlocker;
+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.CatchNotFound = notFound.CatchNotFound;
+exports.DefaultGlobalNotFound = notFound.DefaultGlobalNotFound;
+exports.ScriptOnce = ScriptOnce.ScriptOnce;
+exports.Asset = Asset.Asset;
+exports.HeadContent = HeadContent.HeadContent;
+exports.useTags = HeadContent.useTags;
+exports.Scripts = Scripts.Scripts;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

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

package/dist/cjs/index.d.cts

@@ -0,0 +1,52 @@
+export { default as invariant } from 'tiny-invariant';
+export { default as warning } from 'tiny-warning';
+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 { StartSerializer, Serializable, SerializerParse, SerializerParseBy, SerializerStringify, SerializerStringifyBy, DeferredPromiseState, DeferredPromise, ParsedLocation, RemoveTrailingSlashes, RemoveLeadingSlashes, ActiveOptions, Segment, 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, ExtractedEntry, ExtractedStream, ExtractedPromise, StreamState, Manifest, RouterManagedTag, ControlledPromise, Constrain, Expand, MergeAll, Assign, IntersectAssign, ResolveValidatorInput, ResolveValidatorOutput, AnyValidator, DefaultValidator, ValidatorFn, AnySchema, AnyValidatorAdapter, AnyValidatorFn, AnyValidatorObj, ResolveValidatorInputFn, ResolveValidatorOutputFn, ResolveSearchValidatorInput, ResolveSearchValidatorInputFn, Validator, ValidatorAdapter, ValidatorObj, NavigateFn, BuildLocationFn, InferDescendantToPaths, RelativeToPath, RelativeToParentPath, RelativeToCurrentPath, Register, AbsoluteToPath, RelativeToPathAutoComplete, NavigateOptions, ToOptions, ToMaskOptions, ToSubOptions, ResolveRoute, SearchParamOptions, PathParamOptions, ToPathOption, LinkOptions, MakeOptionalPathParams, AnyRouterWithContext, ParseRoute, RoutesById, RouteById, RouteIds, RoutesByPath, RouteByPath, RoutePaths, FullSearchSchema, AllParams, AllLoaderData, FullSearchSchemaInput, AllContext, CommitLocationOptions, MatchLocation, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, ResolveAllParamsFromParent, RouteContextParameter, BeforeLoadContextParameter, ResolveAllContext, FullSearchSchemaOption, MakeRemountDepsOptionsUnion, RemountDepsOptions, FileRouteTypes, FileRoutesByPath, UseNavigateResult, AnyRedirect, Redirect, ResolvedRedirect, RouteOptions, FileBaseRouteOptions, BaseRouteOptions, UpdatableRouteOptions, RouteLoaderFn, LoaderFnContext, MakeRouteMatch, MakeRouteMatchUnion, RouteMatch, AnyRouteMatch, RouteContextFn, RouteContextOptions, BeforeLoadFn, BeforeLoadContextOptions, ContextOptions, RootRouteOptions, AnyRouteWithContext, LazyRouteOptions, AnyRoute, ResolveFullPath, RouteConstraints, RouterState, ListenerFn, BuildNextOptions, AnyRouter, RegisteredRouter, RouterEvents, RouterEvent, RouterListener, MatchRouteOptions, RouteMask, RouterContextOptions, RouterOptions, RouterConstructorOptions, ControllablePromise, InjectedHtmlEntry, RouterErrorSerializer, SerializerExtensions, CreateFileRoute, CreateLazyFileRoute, } from '@tanstack/router-core';
+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 { lazyRouteComponent } from './lazyRouteComponent.cjs';
+export { useLinkProps, createLink, Link, linkOptions } from './link.cjs';
+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, SolidNode, 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 } 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, 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, useTags } from './HeadContent.cjs';
+export { Scripts } from './Scripts.cjs';

package/dist/cjs/lazyRouteComponent.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const web = require("solid-js/web");
+const Solid = require("solid-js");
+const Match = require("./Match.cjs");
+const ClientOnly = require("./ClientOnly.cjs");
+function isModuleNotFoundError(error) {
+  return typeof (error == null ? void 0 : error.message) === "string" && /Failed to fetch dynamically imported module/.test(error.message);
+}
+function lazyRouteComponent(importer, exportName, ssr) {
+  let loadPromise;
+  let comp;
+  let error;
+  const load = () => {
+    if (typeof document === "undefined" && (ssr == null ? void 0 : ssr()) === false) {
+      comp = () => null;
+      return Promise.resolve(comp);
+    }
+    if (!loadPromise) {
+      loadPromise = importer().then((res) => {
+        loadPromise = void 0;
+        comp = res[exportName ?? "default"];
+        return comp;
+      }).catch((err) => {
+        error = err;
+      });
+    }
+    return loadPromise;
+  };
+  const lazyComp = function Lazy(props) {
+    if (error) {
+      if (isModuleNotFoundError(error)) {
+        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");
+            window.location.reload();
+            return {
+              default: () => null
+            };
+          }
+        }
+      }
+      throw error;
+    }
+    if (!comp) {
+      const [compResource] = Solid.createResource(load, {
+        initialValue: comp,
+        ssrLoadFrom: "initial"
+      });
+      return web.memo(compResource);
+    }
+    if ((ssr == null ? void 0 : ssr()) === false) {
+      return web.createComponent(ClientOnly.ClientOnly, {
+        get fallback() {
+          return web.createComponent(Match.Outlet, {});
+        },
+        get children() {
+          return web.createComponent(web.Dynamic, web.mergeProps({
+            component: comp
+          }, props));
+        }
+      });
+    }
+    return web.createComponent(web.Dynamic, web.mergeProps({
+      component: comp
+    }, props));
+  };
+  lazyComp.preload = load;
+  return lazyComp;
+}
+exports.lazyRouteComponent = lazyRouteComponent;
+//# sourceMappingURL=lazyRouteComponent.cjs.map

package/dist/cjs/lazyRouteComponent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyRouteComponent.cjs","sources":["../../src/lazyRouteComponent.tsx"],"sourcesContent":["import { Dynamic } from 'solid-js/web'\nimport { createResource } from 'solid-js'\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  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  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\n  const load = () => {\n    if (typeof document === 'undefined' && ssr?.() === false) {\n      comp = (() => null) as any\n      return Promise.resolve(comp)\n    }\n    if (!loadPromise) {\n      loadPromise = importer()\n        .then((res) => {\n          loadPromise = undefined\n          comp = res[exportName ?? 'default']\n          return comp\n        })\n        .catch((err) => {\n          error = err\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    // throw the error if it was a module not found error during preload\n    if (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        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            window.location.reload()\n\n            // Return empty component while we wait for window to reload\n            return {\n              default: () => null,\n            }\n          }\n        }\n      }\n\n      // Otherwise, just throw the error\n      throw error\n    }\n\n    if (!comp) {\n      const [compResource] = createResource(load, {\n        initialValue: comp,\n        ssrLoadFrom: 'initial',\n      })\n      return <>{compResource()}</>\n    }\n\n    if (ssr?.() === false) {\n      return (\n        <ClientOnly fallback={<Outlet />}>\n          <Dynamic component={comp} {...props} />\n        </ClientOnly>\n      )\n    }\n    return <Dynamic component={comp} {...props} />\n  }\n\n  ;(lazyComp as any).preload = load\n\n  return lazyComp as any\n}\n"],"names":["isModuleNotFoundError","error","message","test","lazyRouteComponent","importer","exportName","ssr","loadPromise","comp","load","document","Promise","resolve","then","res","undefined","catch","err","lazyComp","Lazy","props","Error","window","sessionStorage","storageKey","getItem","setItem","location","reload","default","compResource","createResource","initialValue","ssrLoadFrom","_$memo","_$createComponent","ClientOnly","fallback","Outlet","children","Dynamic","_$mergeProps","component","preload"],"mappings":";;;;;;AAWA,SAASA,sBAAsBC,OAAqB;AAClD,SACE,QAAOA,+BAAOC,aAAY,YAC1B,8CAA8CC,KAAKF,MAAMC,OAAO;AAEpE;AAEgBE,SAAAA,mBAIdC,UACAC,YACAC,KAGQ;AACJC,MAAAA;AACAC,MAAAA;AACAR,MAAAA;AAEJ,QAAMS,OAAOA,MAAM;AACjB,QAAI,OAAOC,aAAa,gBAAeJ,kCAAY,OAAO;AACxDE,aAAQ,MAAM;AACPG,aAAAA,QAAQC,QAAQJ,IAAI;AAAA,IAAA;AAE7B,QAAI,CAACD,aAAa;AACFH,oBAAAA,SAAAA,EACXS,KAAMC,CAAQ,QAAA;AACCC,sBAAAA;AACPD,eAAAA,IAAIT,cAAc,SAAS;AAC3BG,eAAAA;AAAAA,MAAAA,CACR,EACAQ,MAAOC,CAAQ,QAAA;AACNA,gBAAAA;AAAAA,MAAAA,CACT;AAAA,IAAA;AAGEV,WAAAA;AAAAA,EACT;AAEMW,QAAAA,WAAW,SAASC,KAAKC,OAAY;AAGzC,QAAIpB,OAAO;AACLD,UAAAA,sBAAsBC,KAAK,GAAG;AAMhC,YACEA,iBAAiBqB,SACjB,OAAOC,WAAW,eAClB,OAAOC,mBAAmB,aAC1B;AAKMC,gBAAAA,aAAa,0BAA0BxB,MAAMC,OAAO;AAC1D,cAAI,CAACsB,eAAeE,QAAQD,UAAU,GAAG;AACxBE,2BAAAA,QAAQF,YAAY,GAAG;AACtCF,mBAAOK,SAASC,OAAO;AAGhB,mBAAA;AAAA,cACLC,SAASA,MAAM;AAAA,YACjB;AAAA,UAAA;AAAA,QACF;AAAA,MACF;AAII7B,YAAAA;AAAAA,IAAAA;AAGR,QAAI,CAACQ,MAAM;AACT,YAAM,CAACsB,YAAY,IAAIC,MAAAA,eAAetB,MAAM;AAAA,QAC1CuB,cAAcxB;AAAAA,QACdyB,aAAa;AAAA,MAAA,CACd;AACD,aAAAC,IAAAA,KAAUJ,YAAY;AAAA,IAAA;AAGpBxB,SAAAA,kCAAY,OAAO;AACrB,aAAA6B,IAAAA,gBACGC,WAAAA,YAAU;AAAA,QAAA,IAACC,WAAQ;AAAAF,iBAAAA,IAAAA,gBAAGG,MAAM,QAAA,EAAA;AAAA,QAAA;AAAA,QAAA,IAAAC,WAAA;AAAAJ,iBAAAA,IAAAA,gBAC1BK,aAAOC,eAAA;AAAA,YAACC,WAAWlC;AAAAA,UAAI,GAAMY,KAAK,CAAA;AAAA,QAAA;AAAA,MAAA,CAAA;AAAA,IAAA;AAIzCe,WAAAA,IAAAA,gBAAQK,aAAOC,eAAA;AAAA,MAACC,WAAWlC;AAAAA,IAAI,GAAMY,KAAK,CAAA;AAAA,EAC5C;AAEEF,WAAiByB,UAAUlC;AAEtBS,SAAAA;AACT;;"}

package/dist/cjs/lazyRouteComponent.d.cts

@@ -0,0 +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, ssr?: () => boolean): T[TKey] extends (props: infer TProps) => any ? AsyncRouteComponent<TProps> : never;