@tanstack/solid-router 1.108.0

package/dist/cjs/fileRoute.d.cts

@@ -0,0 +1,58 @@
+import { UseParamsRoute } from './useParams.cjs';
+import { UseMatchRoute } from './useMatch.cjs';
+import { UseSearchRoute } from './useSearch.cjs';
+import { AnyContext, AnyPathParams, AnyValidator, Constrain, ResolveParams } from '@tanstack/router-core';
+import { AnyRoute, FileBaseRouteOptions, RootRoute, Route, RouteConstraints, RouteLoaderFn, UpdatableRouteOptions } from './route.cjs';
+import { RegisteredRouter } from './router.cjs';
+import { RouteById, RouteIds } from './routeInfo.cjs';
+import { UseLoaderDepsRoute } from './useLoaderDeps.cjs';
+import { UseLoaderDataRoute } from './useLoaderData.cjs';
+import { UseRouteContextRoute } from './useRouteContext.cjs';
+export interface FileRoutesByPath {
+}
+export interface FileRouteTypes {
+    fileRoutesByFullPath: any;
+    fullPaths: any;
+    to: any;
+    fileRoutesByTo: any;
+    id: any;
+    fileRoutesById: any;
+}
+export type InferFileRouteTypes<TRouteTree extends AnyRoute> = TRouteTree extends RootRoute<any, any, any, any, any, any, any, infer TFileRouteTypes extends FileRouteTypes> ? TFileRouteTypes : never;
+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;
+    silent?: boolean;
+    constructor(path: TFilePath, _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>;
+}
+/**
+  @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;
+export type LazyRouteOptions = Pick<UpdatableRouteOptions<AnyRoute, string, string, AnyPathParams, AnyValidator, {}, AnyContext, AnyContext, AnyContext, AnyContext>, 'component' | 'errorComponent' | 'pendingComponent' | 'notFoundComponent'>;
+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: () => import('./useNavigate.cjs').UseNavigateResult<string>;
+}
+export declare function createLazyRoute<TId extends RouteIds<RegisteredRouter['routeTree']>, TRoute extends AnyRoute = RouteById<RegisteredRouter['routeTree'], TId>>(id: TId): (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,260 @@
+"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 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 redirects = require("./redirects.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, "TSR_DEFERRED_PROMISE", {
+  enumerable: true,
+  get: () => routerCore.TSR_DEFERRED_PROMISE
+});
+Object.defineProperty(exports, "cleanPath", {
+  enumerable: true,
+  get: () => routerCore.cleanPath
+});
+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, "interpolatePath", {
+  enumerable: true,
+  get: () => routerCore.interpolatePath
+});
+Object.defineProperty(exports, "isMatch", {
+  enumerable: true,
+  get: () => routerCore.isMatch
+});
+Object.defineProperty(exports, "isPlainArray", {
+  enumerable: true,
+  get: () => routerCore.isPlainArray
+});
+Object.defineProperty(exports, "isPlainObject", {
+  enumerable: true,
+  get: () => routerCore.isPlainObject
+});
+Object.defineProperty(exports, "joinPaths", {
+  enumerable: true,
+  get: () => routerCore.joinPaths
+});
+Object.defineProperty(exports, "matchByPath", {
+  enumerable: true,
+  get: () => routerCore.matchByPath
+});
+Object.defineProperty(exports, "matchPathname", {
+  enumerable: true,
+  get: () => routerCore.matchPathname
+});
+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, "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.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.isRedirect = redirects.isRedirect;
+exports.redirect = redirects.redirect;
+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.PathParamError = router.PathParamError;
+exports.Router = router.Router;
+exports.SearchParamError = router.SearchParamError;
+exports.componentTypes = router.componentTypes;
+exports.createRouter = router.createRouter;
+exports.getInitialRouterState = router.getInitialRouterState;
+exports.lazyFn = router.lazyFn;
+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.isNotFound = notFound.isNotFound;
+exports.notFound = notFound.notFound;
+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

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

package/dist/cjs/index.d.cts

@@ -0,0 +1,53 @@
+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, 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, AnyValidator, DefaultValidator, ValidatorFn, AnySchema, AnyValidatorAdapter, AnyValidatorFn, AnyValidatorObj, ResolveValidatorInputFn, ResolveValidatorOutputFn, ResolveSearchValidatorInput, ResolveSearchValidatorInputFn, Validator, ValidatorAdapter, ValidatorObj, } 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 { FileRoute, createFileRoute, FileRouteLoader, LazyRoute, createLazyRoute, createLazyFileRoute, } from './fileRoute.cjs';
+export type { FileRoutesByPath, FileRouteTypes, LazyRouteOptions, } from './fileRoute.cjs';
+export * from './history.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, UseLinkPropsOptions, ActiveLinkOptions, LinkProps, LinkComponent, LinkComponentProps, CreateLinkProps, MakeOptionalPathParams, } from './link.cjs';
+export { Matches, useMatchRoute, MatchRoute, useMatches, useParentMatches, useChildMatches, } from './Matches.cjs';
+export type { RouteMatch, AnyRouteMatch, MatchRouteOptions, UseMatchRouteOptions, MakeMatchRouteOptions, MakeRouteMatch, MakeRouteMatchUnion, } 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 './redirects.cjs';
+export type { AnyRedirect, Redirect, ResolvedRedirect } from './redirects.cjs';
+export { RouteApi, getRouteApi, Route, createRoute, RootRoute, rootRouteWithContext, createRootRoute, createRootRouteWithContext, createRouteMask, NotFoundRoute, } from './route.cjs';
+export type { RouteOptions, FileBaseRouteOptions, BaseRouteOptions, UpdatableRouteOptions, RouteLoaderFn, LoaderFnContext, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, AnyRoute, RouteConstraints, AnyRootRoute, ResolveFullPath, RouteMask, SolidNode, SyncRouteComponent, AsyncRouteComponent, RouteComponent, ErrorRouteComponent, NotFoundRouteComponent, RootRouteOptions, AnyRouteWithContext, FullSearchSchemaOption, RouteContextFn, RouteContextOptions, BeforeLoadFn, BeforeLoadContextOptions, ContextOptions, RouteContextParameter, BeforeLoadContextParameter, ResolveAllContext, ResolveAllParamsFromParent, MakeRemountDepsOptionsUnion, RemountDepsOptions, } from './route.cjs';
+export type { ParseRoute, RoutesById, RouteById, RouteIds, RoutesByPath, RouteByPath, RoutePaths, FullSearchSchema, AllParams, AllLoaderData, FullSearchSchemaInput, AllContext, } from './routeInfo.cjs';
+export { componentTypes, createRouter, Router, lazyFn, SearchParamError, PathParamError, getInitialRouterState, } from './router.cjs';
+export type { Register, AnyRouter, RegisteredRouter, RouterContextOptions, RouterOptions, RouterErrorSerializer, RouterState, ListenerFn, BuildNextOptions, RouterConstructorOptions, RouterEvents, RouterEvent, RouterListener, AnyRouterWithContext, ControllablePromise, InjectedHtmlEntry, } from './router.cjs';
+export { RouterProvider, RouterContextProvider } from './RouterProvider.cjs';
+export type { RouterProps, CommitLocationOptions, MatchLocation, NavigateFn, BuildLocationFn, } 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 type { UseNavigateResult } 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 { notFound, isNotFound, CatchNotFound, DefaultGlobalNotFound, } from './not-found.cjs';
+export type { NotFoundError } from './not-found.cjs';
+export * from './typePrimitives.cjs';
+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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const web = require("solid-js/web");
+const Match = require("./Match.cjs");
+function isModuleNotFoundError(error) {
+  return typeof (error == null ? void 0 : error.message) === "string" && /Failed to fetch dynamically imported module/.test(error.message);
+}
+function ClientOnly(props) {
+  return useHydrated() ? web.memo(() => props.children) : web.memo(() => props.fallback);
+}
+function useHydrated() {
+  return web.isServer;
+}
+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();
+    }
+    if (!loadPromise) {
+      loadPromise = importer().then((res) => {
+        loadPromise = void 0;
+        comp = res[exportName ?? "default"];
+      }).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) {
+      throw load();
+    }
+    if ((ssr == null ? void 0 : ssr()) === false) {
+      return web.createComponent(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.ClientOnly = ClientOnly;
+exports.lazyRouteComponent = lazyRouteComponent;
+exports.useHydrated = useHydrated;
+//# 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, isServer } from 'solid-js/web'\nimport { Outlet } from './Match'\nimport type * as Solid from 'solid-js'\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 ClientOnly(\n  props: Solid.ParentProps<{ fallback?: Solid.JSX.Element }>,\n) {\n  return useHydrated() ? <>{props.children}</> : <>{props.fallback}</>\n}\n\nexport function useHydrated() {\n  return isServer\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()\n    }\n    if (!loadPromise) {\n      loadPromise = importer()\n        .then((res) => {\n          loadPromise = undefined\n          comp = res[exportName ?? 'default']\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      throw load()\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","ClientOnly","props","useHydrated","_$memo","children","fallback","isServer","lazyRouteComponent","importer","exportName","ssr","loadPromise","comp","load","document","Promise","resolve","then","res","undefined","catch","err","lazyComp","Lazy","Error","window","sessionStorage","storageKey","getItem","setItem","location","reload","default","_$createComponent","Outlet","Dynamic","_$mergeProps","component","preload"],"mappings":";;;;AAUA,SAASA,sBAAsBC,OAAqB;AAClD,SACE,QAAOA,+BAAOC,aAAY,YAC1B,8CAA8CC,KAAKF,MAAMC,OAAO;AAEpE;AAEO,SAASE,WACdC,OACA;AACOC,SAAAA,YAAAA,IAAaC,IAAAA,KAAMF,MAAAA,MAAMG,QAAQ,IAAAD,IAAAA,KAAA,MAAUF,MAAMI,QAAQ;AAClE;AAEO,SAASH,cAAc;AACrBI,SAAAA,IAAAA;AACT;AAEgBC,SAAAA,mBAIdC,UACAC,YACAC,KAGQ;AACJC,MAAAA;AACAC,MAAAA;AACAf,MAAAA;AAEJ,QAAMgB,OAAOA,MAAM;AACjB,QAAI,OAAOC,aAAa,gBAAeJ,kCAAY,OAAO;AACxDE,aAAQ,MAAM;AACd,aAAOG,QAAQC,QAAQ;AAAA,IAAA;AAEzB,QAAI,CAACL,aAAa;AACFH,oBAAAA,SAAAA,EACXS,KAAMC,CAAQ,QAAA;AACCC,sBAAAA;AACPD,eAAAA,IAAIT,cAAc,SAAS;AAAA,MAAA,CACnC,EACAW,MAAOC,CAAQ,QAAA;AACNA,gBAAAA;AAAAA,MAAAA,CACT;AAAA,IAAA;AAGEV,WAAAA;AAAAA,EACT;AAEMW,QAAAA,WAAW,SAASC,KAAKtB,OAAY;AAGzC,QAAIJ,OAAO;AACLD,UAAAA,sBAAsBC,KAAK,GAAG;AAMhC,YACEA,iBAAiB2B,SACjB,OAAOC,WAAW,eAClB,OAAOC,mBAAmB,aAC1B;AAKMC,gBAAAA,aAAa,0BAA0B9B,MAAMC,OAAO;AAC1D,cAAI,CAAC4B,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;AAIInC,YAAAA;AAAAA,IAAAA;AAGR,QAAI,CAACe,MAAM;AACT,YAAMC,KAAK;AAAA,IAAA;AAGTH,SAAAA,kCAAY,OAAO;AACrB,aAAAuB,IAAAA,gBACGjC,YAAU;AAAA,QAAA,IAACK,WAAQ;AAAA4B,iBAAAA,IAAAA,gBAAGC,MAAM,QAAA,EAAA;AAAA,QAAA;AAAA,QAAA,IAAA9B,WAAA;AAAA6B,iBAAAA,IAAAA,gBAC1BE,aAAOC,eAAA;AAAA,YAACC,WAAWzB;AAAAA,UAAI,GAAMX,KAAK,CAAA;AAAA,QAAA;AAAA,MAAA,CAAA;AAAA,IAAA;AAIzCgC,WAAAA,IAAAA,gBAAQE,aAAOC,eAAA;AAAA,MAACC,WAAWzB;AAAAA,IAAI,GAAMX,KAAK,CAAA;AAAA,EAC5C;AAEEqB,WAAiBgB,UAAUzB;AAEtBS,SAAAA;AACT;;;;"}

package/dist/cjs/lazyRouteComponent.d.cts

@@ -0,0 +1,7 @@
+import { AsyncRouteComponent } from './route.cjs';
+import type * as Solid from 'solid-js';
+export declare function ClientOnly(props: Solid.ParentProps<{
+    fallback?: Solid.JSX.Element;
+}>): Solid.JSX.Element;
+export declare function useHydrated(): boolean;
+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;