@tanstack/react-router 1.121.16 → 1.121.17

package/dist/cjs/index.cjs

@@ -1,289 +0,0 @@
-"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.useStableCallback = utils.useStableCallback;
-exports.CatchNotFound = notFound.CatchNotFound;
-exports.DefaultGlobalNotFound = notFound.DefaultGlobalNotFound;
-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 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -1,55 +0,0 @@
-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 { AnyRoute, 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, 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 { 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,78 +0,0 @@
-"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) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
-function isModuleNotFoundError(error) {
-  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, 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().then((res) => {
-        loadPromise = void 0;
-        comp = res[exportName ?? "default"];
-      }).catch((err) => {
-        error = err;
-        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");
-              reload = true;
-            }
-          }
-        }
-      });
-    }
-    return loadPromise;
-  };
-  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;
-}
-exports.lazyRouteComponent = lazyRouteComponent;
-//# sourceMappingURL=lazyRouteComponent.cjs.map

package/dist/cjs/lazyRouteComponent.cjs.map

@@ -1 +0,0 @@
-{"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 +0,0 @@
-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;