@tanstack/vue-router 0.0.1 → 1.140.1

package/dist/esm/fileRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileRoute.js","sources":["../../src/fileRoute.ts"],"sourcesContent":["import warning from 'tiny-warning'\nimport { createRoute } from './route'\n\nimport { useMatch } from './useMatch'\nimport { useLoaderDeps } from './useLoaderDeps'\nimport { useLoaderData } from './useLoaderData'\nimport { useSearch } from './useSearch'\nimport { useParams } from './useParams'\nimport { useNavigate } from './useNavigate'\nimport { useRouter } from './useRouter'\nimport type { UseParamsRoute } from './useParams'\nimport type { UseMatchRoute } from './useMatch'\nimport type { UseSearchRoute } from './useSearch'\nimport type {\n  AnyContext,\n  AnyRoute,\n  AnyRouter,\n  Constrain,\n  ConstrainLiteral,\n  FileBaseRouteOptions,\n  FileRoutesByPath,\n  LazyRouteOptions,\n  Register,\n  RegisteredRouter,\n  ResolveParams,\n  Route,\n  RouteById,\n  RouteConstraints,\n  RouteIds,\n  RouteLoaderFn,\n  UpdatableRouteOptions,\n  UseNavigateResult,\n} from '@tanstack/router-core'\nimport type { UseLoaderDepsRoute } from './useLoaderDeps'\nimport type { UseLoaderDataRoute } from './useLoaderData'\nimport type { UseRouteContextRoute } from './useRouteContext'\n\nexport function createFileRoute<\n  TFilePath extends keyof FileRoutesByPath,\n  TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],\n  TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],\n  TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],\n  TFullPath extends\n    RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath'],\n>(\n  path?: TFilePath,\n): FileRoute<TFilePath, TParentRoute, TId, TPath, TFullPath>['createRoute'] {\n  if (typeof path === 'object') {\n    return new FileRoute<TFilePath, TParentRoute, TId, TPath, TFullPath>(path, {\n      silent: true,\n    }).createRoute(path) as any\n  }\n  return new FileRoute<TFilePath, TParentRoute, TId, TPath, TFullPath>(path, {\n    silent: true,\n  }).createRoute\n}\n\n/**\n  @deprecated It's no longer recommended to use the `FileRoute` class directly.\n  Instead, use `createFileRoute('/path/to/file')(options)` to create a file route.\n*/\nexport class FileRoute<\n  TFilePath extends keyof FileRoutesByPath,\n  TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],\n  TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],\n  TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],\n  TFullPath extends\n    RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath'],\n> {\n  silent?: boolean\n\n  constructor(\n    public path?: TFilePath,\n    _opts?: { silent: boolean },\n  ) {\n    this.silent = _opts?.silent\n  }\n\n  createRoute = <\n    TRegister = Register,\n    TSearchValidator = undefined,\n    TParams = ResolveParams<TPath>,\n    TRouteContextFn = AnyContext,\n    TBeforeLoadFn = AnyContext,\n    TLoaderDeps extends Record<string, any> = {},\n    TLoaderFn = undefined,\n    TChildren = unknown,\n    TSSR = unknown,\n    TMiddlewares = unknown,\n    THandlers = undefined,\n  >(\n    options?: FileBaseRouteOptions<\n      TRegister,\n      TParentRoute,\n      TId,\n      TPath,\n      TSearchValidator,\n      TParams,\n      TLoaderDeps,\n      TLoaderFn,\n      AnyContext,\n      TRouteContextFn,\n      TBeforeLoadFn,\n      AnyContext,\n      TSSR,\n      TMiddlewares,\n      THandlers\n    > &\n      UpdatableRouteOptions<\n        TParentRoute,\n        TId,\n        TFullPath,\n        TParams,\n        TSearchValidator,\n        TLoaderFn,\n        TLoaderDeps,\n        AnyContext,\n        TRouteContextFn,\n        TBeforeLoadFn\n      >,\n  ): Route<\n    TRegister,\n    TParentRoute,\n    TPath,\n    TFullPath,\n    TFilePath,\n    TId,\n    TSearchValidator,\n    TParams,\n    AnyContext,\n    TRouteContextFn,\n    TBeforeLoadFn,\n    TLoaderDeps,\n    TLoaderFn,\n    TChildren,\n    unknown,\n    TSSR,\n    TMiddlewares,\n    THandlers\n  > => {\n    warning(\n      this.silent,\n      'FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead.',\n    )\n    const route = createRoute(options as any)\n    ;(route as any).isRoot = false\n    return route as any\n  }\n}\n\n/**\n  @deprecated It's recommended not to split loaders into separate files.\n  Instead, place the loader function in the the main route file, inside the\n  `createFileRoute('/path/to/file)(options)` options.\n*/\nexport function FileRouteLoader<\n  TFilePath extends keyof FileRoutesByPath,\n  TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],\n>(\n  _path: TFilePath,\n): <TLoaderFn>(\n  loaderFn: Constrain<\n    TLoaderFn,\n    RouteLoaderFn<\n      Register,\n      TRoute['parentRoute'],\n      TRoute['types']['id'],\n      TRoute['types']['params'],\n      TRoute['types']['loaderDeps'],\n      TRoute['types']['routerContext'],\n      TRoute['types']['routeContextFn'],\n      TRoute['types']['beforeLoadFn']\n    >\n  >,\n) => TLoaderFn {\n  warning(\n    false,\n    `FileRouteLoader is deprecated and will be removed in the next major version. Please place the loader function in the the main route file, inside the \\`createFileRoute('/path/to/file')(options)\\` options`,\n  )\n  return (loaderFn) => loaderFn as any\n}\n\ndeclare module '@tanstack/router-core' {\n  export interface LazyRoute<in out TRoute extends AnyRoute> {\n    useMatch: UseMatchRoute<TRoute['id']>\n    useRouteContext: UseRouteContextRoute<TRoute['id']>\n    useSearch: UseSearchRoute<TRoute['id']>\n    useParams: UseParamsRoute<TRoute['id']>\n    useLoaderDeps: UseLoaderDepsRoute<TRoute['id']>\n    useLoaderData: UseLoaderDataRoute<TRoute['id']>\n    useNavigate: () => UseNavigateResult<TRoute['fullPath']>\n  }\n}\n\nexport class LazyRoute<TRoute extends AnyRoute> {\n  options: {\n    id: string\n  } & LazyRouteOptions\n\n  constructor(\n    opts: {\n      id: string\n    } & LazyRouteOptions,\n  ) {\n    this.options = opts\n  }\n\n  useMatch: UseMatchRoute<TRoute['id']> = (opts) => {\n    return useMatch({\n      select: opts?.select,\n      from: this.options.id,\n    } as any) as any\n  }\n\n  useRouteContext: UseRouteContextRoute<TRoute['id']> = (opts) => {\n    return useMatch({\n      from: this.options.id,\n      select: (d: any) => (opts?.select ? opts.select(d.context) : d.context),\n    }) as any\n  }\n\n  useSearch: UseSearchRoute<TRoute['id']> = (opts) => {\n    return useSearch({\n      select: opts?.select,\n      from: this.options.id,\n    } as any) as any\n  }\n\n  useParams: UseParamsRoute<TRoute['id']> = (opts) => {\n    return useParams({\n      select: opts?.select,\n      from: this.options.id,\n    } as any) as any\n  }\n\n  useLoaderDeps: UseLoaderDepsRoute<TRoute['id']> = (opts) => {\n    return useLoaderDeps({ ...opts, from: this.options.id } as any)\n  }\n\n  useLoaderData: UseLoaderDataRoute<TRoute['id']> = (opts) => {\n    return useLoaderData({ ...opts, from: this.options.id } as any)\n  }\n\n  useNavigate = (): UseNavigateResult<TRoute['fullPath']> => {\n    const router = useRouter()\n    return useNavigate({ from: router.routesById[this.options.id].fullPath })\n  }\n}\n\nexport function createLazyRoute<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TId extends string = string,\n  TRoute extends AnyRoute = RouteById<TRouter['routeTree'], TId>,\n>(id: ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>) {\n  return (opts: LazyRouteOptions) => {\n    return new LazyRoute<TRoute>({\n      id: id,\n      ...opts,\n    })\n  }\n}\nexport function createLazyFileRoute<\n  TFilePath extends keyof FileRoutesByPath,\n  TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],\n>(id: TFilePath): (opts: LazyRouteOptions) => LazyRoute<TRoute> {\n  if (typeof id === 'object') {\n    return new LazyRoute<TRoute>(id) as any\n  }\n\n  return (opts: LazyRouteOptions) => new LazyRoute<TRoute>({ id, ...opts })\n}\n"],"names":["opts"],"mappings":";;;;;;;;;AAqCO,SAAS,gBAQd,MAC0E;AAC1E,MAAI,OAAO,SAAS,UAAU;AAC5B,WAAO,IAAI,UAA0D,MAAM;AAAA,MACzE,QAAQ;AAAA,IAAA,CACT,EAAE,YAAY,IAAI;AAAA,EACrB;AACA,SAAO,IAAI,UAA0D,MAAM;AAAA,IACzE,QAAQ;AAAA,EAAA,CACT,EAAE;AACL;AAMO,MAAM,UAOX;AAAA,EAGA,YACS,MACP,OACA;AAFO,SAAA,OAAA;AAMT,SAAA,cAAc,CAaZ,YAgDG;AACH;AAAA,QACE,KAAK;AAAA,QACL;AAAA,MAAA;AAEF,YAAM,QAAQ,YAAY,OAAc;AACtC,YAAc,SAAS;AACzB,aAAO;AAAA,IACT;AAxEE,SAAK,SAAS,OAAO;AAAA,EACvB;AAwEF;AAOO,SAAS,gBAId,OAea;AACb;AAAA,IACE;AAAA,IACA;AAAA,EAAA;AAEF,SAAO,CAAC,aAAa;AACvB;AAcO,MAAM,UAAmC;AAAA,EAK9C,YACE,MAGA;AAIF,SAAA,WAAwC,CAACA,UAAS;AAChD,aAAO,SAAS;AAAA,QACd,QAAQA,OAAM;AAAA,QACd,MAAM,KAAK,QAAQ;AAAA,MAAA,CACb;AAAA,IACV;AAEA,SAAA,kBAAsD,CAACA,UAAS;AAC9D,aAAO,SAAS;AAAA,QACd,MAAM,KAAK,QAAQ;AAAA,QACnB,QAAQ,CAAC,MAAYA,OAAM,SAASA,MAAK,OAAO,EAAE,OAAO,IAAI,EAAE;AAAA,MAAA,CAChE;AAAA,IACH;AAEA,SAAA,YAA0C,CAACA,UAAS;AAClD,aAAO,UAAU;AAAA,QACf,QAAQA,OAAM;AAAA,QACd,MAAM,KAAK,QAAQ;AAAA,MAAA,CACb;AAAA,IACV;AAEA,SAAA,YAA0C,CAACA,UAAS;AAClD,aAAO,UAAU;AAAA,QACf,QAAQA,OAAM;AAAA,QACd,MAAM,KAAK,QAAQ;AAAA,MAAA,CACb;AAAA,IACV;AAEA,SAAA,gBAAkD,CAACA,UAAS;AAC1D,aAAO,cAAc,EAAE,GAAGA,OAAM,MAAM,KAAK,QAAQ,IAAW;AAAA,IAChE;AAEA,SAAA,gBAAkD,CAACA,UAAS;AAC1D,aAAO,cAAc,EAAE,GAAGA,OAAM,MAAM,KAAK,QAAQ,IAAW;AAAA,IAChE;AAEA,SAAA,cAAc,MAA6C;AACzD,YAAM,SAAS,UAAA;AACf,aAAO,YAAY,EAAE,MAAM,OAAO,WAAW,KAAK,QAAQ,EAAE,EAAE,UAAU;AAAA,IAC1E;AA1CE,SAAK,UAAU;AAAA,EACjB;AA0CF;AAEO,SAAS,gBAId,IAA2D;AAC3D,SAAO,CAAC,SAA2B;AACjC,WAAO,IAAI,UAAkB;AAAA,MAC3B;AAAA,MACA,GAAG;AAAA,IAAA,CACJ;AAAA,EACH;AACF;AACO,SAAS,oBAGd,IAA8D;AAC9D,MAAI,OAAO,OAAO,UAAU;AAC1B,WAAO,IAAI,UAAkB,EAAE;AAAA,EACjC;AAEA,SAAO,CAAC,SAA2B,IAAI,UAAkB,EAAE,IAAI,GAAG,MAAM;AAC1E;"}

package/dist/esm/history.d.ts

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

package/dist/esm/index.d.ts

@@ -0,0 +1,51 @@
+export { defer, TSR_DEFERRED_PROMISE, isMatch, joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, resolvePath, interpolatePath, rootRouteId, defaultSerializeError, defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith, functionalUpdate, replaceEqualDeep, isPlainObject, isPlainArray, deepEqual, createControlledPromise, retainSearchParams, stripSearchParams, createSerializationAdapter, } from '@tanstack/router-core';
+export type { AnyRoute, DeferredPromiseState, DeferredPromise, ParsedLocation, RemoveTrailingSlashes, RemoveLeadingSlashes, ActiveOptions, ResolveRelativePath, RootRouteId, AnyPathParams, ResolveParams, ResolveOptionalParams, ResolveRequiredParams, SearchSchemaInput, AnyContext, RouteContext, PreloadableObj, RoutePathOptions, StaticDataRouteOption, RoutePathOptionsIntersection, UpdatableStaticRouteOption, MetaDescriptor, RouteLinkEntry, ParseParamsFn, SearchFilter, ResolveId, InferFullSearchSchema, InferFullSearchSchemaInput, ErrorRouteProps, ErrorComponentProps, NotFoundRouteProps, TrimPath, TrimPathLeft, TrimPathRight, StringifyParamsFn, ParamsOptions, InferAllParams, InferAllContext, LooseReturnType, LooseAsyncReturnType, ContextReturnType, ContextAsyncReturnType, ResolveLoaderData, ResolveRouteContext, SearchSerializer, SearchParser, TrailingSlashOption, Manifest, RouterManagedTag, ControlledPromise, Constrain, Expand, MergeAll, Assign, IntersectAssign, ResolveValidatorInput, ResolveValidatorOutput, Register, AnyValidator, DefaultValidator, ValidatorFn, AnySchema, AnyValidatorAdapter, AnyValidatorFn, AnyValidatorObj, ResolveValidatorInputFn, ResolveValidatorOutputFn, ResolveSearchValidatorInput, ResolveSearchValidatorInputFn, Validator, ValidatorAdapter, ValidatorObj, FileRoutesByPath, RouteById, RootRouteOptions, CreateFileRoute, SerializationAdapter, AnySerializationAdapter, } 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.js';
+export type { AwaitOptions } from './awaited.js';
+export { CatchBoundary, ErrorComponent } from './CatchBoundary.js';
+export { FileRoute, createFileRoute, FileRouteLoader, LazyRoute, createLazyRoute, createLazyFileRoute, } from './fileRoute.js';
+export * from './history.js';
+export { lazyRouteComponent } from './lazyRouteComponent.js';
+export { useLinkProps, createLink, Link, linkOptions } from './link.js';
+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, RedirectOptions, ResolvedRedirect, MakeRouteMatch, MakeRouteMatchUnion, RouteMatch, AnyRouteMatch, RouteContextFn, RouteContextOptions, BeforeLoadContextOptions, ContextOptions, RouteOptions, FileBaseRouteOptions, BaseRouteOptions, UpdatableRouteOptions, RouteLoaderFn, LoaderFnContext, LazyRouteOptions, AnyRouter, RegisteredRouter, RouterContextOptions, ControllablePromise, InjectedHtmlEntry, RouterOptions, 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.js';
+export { Matches, useMatchRoute, MatchRoute, useMatches, useParentMatches, useChildMatches, } from './Matches.js';
+export type { UseMatchRouteOptions, MakeMatchRouteOptions } from './Matches.js';
+export { matchContext } from './matchContext.js';
+export { Match, Outlet } from './Match.js';
+export { useMatch } from './useMatch.js';
+export { useLoaderDeps } from './useLoaderDeps.js';
+export { useLoaderData } from './useLoaderData.js';
+export { redirect, isRedirect, createRouterConfig } from '@tanstack/router-core';
+export { RouteApi, getRouteApi, Route, createRoute, RootRoute, rootRouteWithContext, createRootRoute, createRootRouteWithContext, createRouteMask, NotFoundRoute, } from './route.js';
+export type { AnyRootRoute, VueNode, SyncRouteComponent, AsyncRouteComponent, RouteComponent, ErrorRouteComponent, NotFoundRouteComponent, } from './route.js';
+export { createRouter, Router } from './router.js';
+export { componentTypes, lazyFn, SearchParamError, PathParamError, getInitialRouterState, } from '@tanstack/router-core';
+export { RouterProvider, RouterContextProvider } from './RouterProvider.js';
+export type { RouterProps } from './RouterProvider.js';
+export { useElementScrollRestoration, ScrollRestoration, } from './ScrollRestoration.js';
+export type { UseBlockerOpts, ShouldBlockFn } from './useBlocker.js';
+export { useBlocker, Block } from './useBlocker.js';
+export { useNavigate, Navigate } from './useNavigate.js';
+export { useParams } from './useParams.js';
+export { useSearch } from './useSearch.js';
+export { getRouterContext, } from './routerContext.js';
+export { useRouteContext } from './useRouteContext.js';
+export { useRouter } from './useRouter.js';
+export { useRouterState } from './useRouterState.js';
+export { useLocation } from './useLocation.js';
+export { useCanGoBack } from './useCanGoBack.js';
+export { useLayoutEffect } from './utils.js';
+export { CatchNotFound, DefaultGlobalNotFound } from './not-found.js';
+export { notFound, isNotFound } from '@tanstack/router-core';
+export type { NotFoundError } from '@tanstack/router-core';
+export type { ValidateLinkOptions, ValidateUseSearchOptions, ValidateUseParamsOptions, ValidateLinkOptionsArray, } from './typePrimitives.js';
+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.js';
+export { Asset } from './Asset.js';
+export { HeadContent } from './HeadContent.js';
+export { Scripts } from './Scripts.js';
+export { composeRewrites } from '@tanstack/router-core';
+export type { LocationRewrite, LocationRewriteFunction, } from '@tanstack/router-core';

package/dist/esm/index.js

@@ -0,0 +1,138 @@
+import { PathParamError, SearchParamError, TSR_DEFERRED_PROMISE, cleanPath, componentTypes, composeRewrites, createControlledPromise, createRouterConfig, createSerializationAdapter, deepEqual, defaultParseSearch, defaultSerializeError, defaultStringifySearch, defer, functionalUpdate, getInitialRouterState, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, lazyFn, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight } from "@tanstack/router-core";
+import { createBrowserHistory, createHashHistory, createHistory, createMemoryHistory } from "@tanstack/history";
+import { Await, useAwaited } from "./awaited.js";
+import { CatchBoundary, ErrorComponent } from "./CatchBoundary.js";
+import { FileRoute, FileRouteLoader, LazyRoute, createFileRoute, createLazyFileRoute, createLazyRoute } from "./fileRoute.js";
+import { lazyRouteComponent } from "./lazyRouteComponent.js";
+import { Link, createLink, linkOptions, useLinkProps } from "./link.js";
+import { MatchRoute, Matches, useChildMatches, useMatchRoute, useMatches, useParentMatches } from "./Matches.js";
+import { matchContext } from "./matchContext.js";
+import { Match, Outlet } from "./Match.js";
+import { useMatch } from "./useMatch.js";
+import { useLoaderDeps } from "./useLoaderDeps.js";
+import { useLoaderData } from "./useLoaderData.js";
+import { NotFoundRoute, RootRoute, Route, RouteApi, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, getRouteApi, rootRouteWithContext } from "./route.js";
+import { Router, createRouter } from "./router.js";
+import { RouterContextProvider, RouterProvider } from "./RouterProvider.js";
+import { ScrollRestoration, useElementScrollRestoration } from "./ScrollRestoration.js";
+import { Block, useBlocker } from "./useBlocker.js";
+import { Navigate, useNavigate } from "./useNavigate.js";
+import { useParams } from "./useParams.js";
+import { useSearch } from "./useSearch.js";
+import { getRouterContext } from "./routerContext.js";
+import { useRouteContext } from "./useRouteContext.js";
+import { useRouter } from "./useRouter.js";
+import { useRouterState } from "./useRouterState.js";
+import { useLocation } from "./useLocation.js";
+import { useCanGoBack } from "./useCanGoBack.js";
+import { useLayoutEffect } from "./utils.js";
+import { CatchNotFound, DefaultGlobalNotFound } from "./not-found.js";
+import { ScriptOnce } from "./ScriptOnce.js";
+import { Asset } from "./Asset.js";
+import { HeadContent } from "./HeadContent.js";
+import { Scripts } from "./Scripts.js";
+export {
+  Asset,
+  Await,
+  Block,
+  CatchBoundary,
+  CatchNotFound,
+  DefaultGlobalNotFound,
+  ErrorComponent,
+  FileRoute,
+  FileRouteLoader,
+  HeadContent,
+  LazyRoute,
+  Link,
+  Match,
+  MatchRoute,
+  Matches,
+  Navigate,
+  NotFoundRoute,
+  Outlet,
+  PathParamError,
+  RootRoute,
+  Route,
+  RouteApi,
+  Router,
+  RouterContextProvider,
+  RouterProvider,
+  ScriptOnce,
+  Scripts,
+  ScrollRestoration,
+  SearchParamError,
+  TSR_DEFERRED_PROMISE,
+  cleanPath,
+  componentTypes,
+  composeRewrites,
+  createBrowserHistory,
+  createControlledPromise,
+  createFileRoute,
+  createHashHistory,
+  createHistory,
+  createLazyFileRoute,
+  createLazyRoute,
+  createLink,
+  createMemoryHistory,
+  createRootRoute,
+  createRootRouteWithContext,
+  createRoute,
+  createRouteMask,
+  createRouter,
+  createRouterConfig,
+  createSerializationAdapter,
+  deepEqual,
+  defaultParseSearch,
+  defaultSerializeError,
+  defaultStringifySearch,
+  defer,
+  functionalUpdate,
+  getInitialRouterState,
+  getRouteApi,
+  getRouterContext,
+  interpolatePath,
+  isMatch,
+  isNotFound,
+  isPlainArray,
+  isPlainObject,
+  isRedirect,
+  joinPaths,
+  lazyFn,
+  lazyRouteComponent,
+  linkOptions,
+  matchContext,
+  notFound,
+  parseSearchWith,
+  redirect,
+  replaceEqualDeep,
+  resolvePath,
+  retainSearchParams,
+  rootRouteId,
+  rootRouteWithContext,
+  stringifySearchWith,
+  stripSearchParams,
+  trimPath,
+  trimPathLeft,
+  trimPathRight,
+  useAwaited,
+  useBlocker,
+  useCanGoBack,
+  useChildMatches,
+  useElementScrollRestoration,
+  useLayoutEffect,
+  useLinkProps,
+  useLoaderData,
+  useLoaderDeps,
+  useLocation,
+  useMatch,
+  useMatchRoute,
+  useMatches,
+  useNavigate,
+  useParams,
+  useParentMatches,
+  useRouteContext,
+  useRouter,
+  useRouterState,
+  useSearch
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

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

package/dist/esm/lazyRouteComponent.d.ts

@@ -0,0 +1,8 @@
+import { AsyncRouteComponent } from './route.js';
+import * as Vue from 'vue';
+export declare function ClientOnly(props: {
+    children?: any;
+    fallback?: Vue.VNode;
+}): () => any;
+export declare function useHydrated(): Vue.Ref<boolean, boolean> | Vue.ComputedRef<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;

package/dist/esm/lazyRouteComponent.js

@@ -0,0 +1,106 @@
+import * as Vue from "vue";
+import { Outlet } from "./Match.js";
+function isModuleNotFoundError(error) {
+  if (typeof 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 ClientOnly(props) {
+  const hydrated = useHydrated();
+  return () => {
+    if (hydrated.value) {
+      return props.children;
+    }
+    return props.fallback || null;
+  };
+}
+function useHydrated() {
+  const hydrated = Vue.ref(false);
+  if (typeof window === "undefined") {
+    return Vue.computed(() => false);
+  }
+  Vue.onMounted(() => {
+    hydrated.value = true;
+  });
+  return hydrated;
+}
+function lazyRouteComponent(importer, exportName, ssr) {
+  let loadPromise;
+  let comp = null;
+  let error = null;
+  let attemptedReload = false;
+  const load = () => {
+    if (typeof document === "undefined" && 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;
+        loadPromise = void 0;
+        if (isModuleNotFoundError(error)) {
+          return null;
+        }
+        throw err;
+      });
+    }
+    return loadPromise;
+  };
+  const lazyComp = Vue.defineComponent({
+    name: "LazyRouteComponent",
+    setup(props) {
+      const component = Vue.ref(comp);
+      const errorState = Vue.ref(error);
+      const loading = Vue.ref(!component.value && !errorState.value);
+      Vue.onMounted(() => {
+        if (!component.value && !errorState.value) {
+          loading.value = true;
+          load().then((result) => {
+            component.value = result;
+            loading.value = false;
+          }).catch((err) => {
+            errorState.value = err;
+            loading.value = false;
+          });
+        }
+      });
+      if (errorState.value && isModuleNotFoundError(errorState.value) && !attemptedReload) {
+        if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+          const storageKey = `tanstack_router_reload:${errorState.value.message}`;
+          if (!sessionStorage.getItem(storageKey)) {
+            sessionStorage.setItem(storageKey, "1");
+            attemptedReload = true;
+            window.location.reload();
+            return () => null;
+          }
+        }
+      }
+      if (errorState.value && !isModuleNotFoundError(errorState.value)) {
+        throw errorState.value;
+      }
+      return () => {
+        if (loading.value || !component.value) {
+          return Vue.h("div", null);
+        }
+        if (ssr?.() === false) {
+          return Vue.h(ClientOnly, {
+            fallback: Vue.h(Outlet),
+            children: Vue.h(component.value, props)
+          });
+        }
+        return Vue.h(component.value, props);
+      };
+    }
+  });
+  lazyComp.preload = load;
+  return lazyComp;
+}
+export {
+  ClientOnly,
+  lazyRouteComponent,
+  useHydrated
+};
+//# sourceMappingURL=lazyRouteComponent.js.map

package/dist/esm/lazyRouteComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyRouteComponent.js","sources":["../../src/lazyRouteComponent.tsx"],"sourcesContent":["import * as Vue from 'vue'\nimport { Outlet } from './Match'\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 ClientOnly(props: { children?: any; fallback?: Vue.VNode }) {\n  const hydrated = useHydrated()\n\n  return () => {\n    if (hydrated.value) {\n      return props.children\n    }\n    return props.fallback || null\n  }\n}\n\nexport function useHydrated() {\n  // Only hydrate on client-side, never on server\n  const hydrated = Vue.ref(false)\n\n  // If on server, return false\n  if (typeof window === 'undefined') {\n    return Vue.computed(() => false)\n  }\n\n  // On client, set to true once mounted\n  Vue.onMounted(() => {\n    hydrated.value = true\n  })\n\n  return hydrated\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'] | null = null\n  let error: any = null\n  let attemptedReload = false\n\n  const load = () => {\n    // If we're on the server and SSR is disabled for this component\n    if (typeof document === 'undefined' && ssr?.() === false) {\n      comp = (() => null) as any\n      return Promise.resolve(comp)\n    }\n\n    // Use existing promise or create new one\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          loadPromise = undefined\n\n          // If it's a module not found error, we'll try to handle it in the component\n          if (isModuleNotFoundError(error)) {\n            return null\n          }\n\n          throw err\n        })\n    }\n\n    return loadPromise\n  }\n\n  // Create a lazy component wrapper using defineComponent so it works in Vue SFC templates\n  const lazyComp = Vue.defineComponent({\n    name: 'LazyRouteComponent',\n    setup(props: any) {\n      // Create refs to track component state\n      const component = Vue.ref<any>(comp)\n      const errorState = Vue.ref<any>(error)\n      const loading = Vue.ref(!component.value && !errorState.value)\n\n      // Setup effect to load the component when this component is used\n      Vue.onMounted(() => {\n        if (!component.value && !errorState.value) {\n          loading.value = true\n\n          load()\n            .then((result) => {\n              component.value = result\n              loading.value = false\n            })\n            .catch((err) => {\n              errorState.value = err\n              loading.value = false\n            })\n        }\n      })\n\n      // Handle module not found error with reload attempt\n      if (\n        errorState.value &&\n        isModuleNotFoundError(errorState.value) &&\n        !attemptedReload\n      ) {\n        if (\n          typeof window !== 'undefined' &&\n          typeof sessionStorage !== 'undefined'\n        ) {\n          // Try to reload once on module not found error\n          const storageKey = `tanstack_router_reload:${errorState.value.message}`\n          if (!sessionStorage.getItem(storageKey)) {\n            sessionStorage.setItem(storageKey, '1')\n            attemptedReload = true\n            window.location.reload()\n            return () => null // Return empty while reloading\n          }\n        }\n      }\n\n      // If we have a non-module-not-found error, throw it\n      if (errorState.value && !isModuleNotFoundError(errorState.value)) {\n        throw errorState.value\n      }\n\n      // Return a render function\n      return () => {\n        // If we're still loading or don't have a component yet, use a suspense pattern\n        if (loading.value || !component.value) {\n          return Vue.h('div', null) // Empty div while loading\n        }\n\n        // If SSR is disabled for this component\n        if (ssr?.() === false) {\n          return Vue.h(ClientOnly, {\n            fallback: Vue.h(Outlet),\n            children: Vue.h(component.value, props),\n          })\n        }\n\n        // Regular render with the loaded component\n        return Vue.h(component.value, props)\n      }\n    },\n  })\n\n  // Add preload method\n  ;(lazyComp as any).preload = load\n\n  return lazyComp as any\n}\n"],"names":["isModuleNotFoundError","error","message","startsWith","ClientOnly","props","hydrated","useHydrated","value","children","fallback","Vue","ref","window","computed","onMounted","lazyRouteComponent","importer","exportName","ssr","loadPromise","comp","attemptedReload","load","document","Promise","resolve","then","res","undefined","catch","err","lazyComp","defineComponent","name","setup","component","errorState","loading","result","sessionStorage","storageKey","getItem","setItem","location","reload","h","Outlet","preload"],"mappings":"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"}

package/dist/esm/link.d.ts

@@ -0,0 +1,61 @@
+import { AnyRouter, Constrain, LinkOptions, RegisteredRouter, RoutePaths } from '@tanstack/router-core';
+import { ValidateLinkOptions, ValidateLinkOptionsArray } from './typePrimitives.js';
+import * as Vue from 'vue';
+type EventHandler<TEvent = Event> = (e: TEvent) => void;
+interface HTMLAttributes {
+    class?: string;
+    style?: Record<string, string | number>;
+    onClick?: EventHandler<MouseEvent>;
+    onFocus?: EventHandler<FocusEvent>;
+    onMouseenter?: EventHandler<MouseEvent>;
+    onMouseleave?: EventHandler<MouseEvent>;
+    onMouseover?: EventHandler<MouseEvent>;
+    onMouseout?: EventHandler<MouseEvent>;
+    onTouchstart?: EventHandler<TouchEvent>;
+    onMouseEnter?: EventHandler<MouseEvent>;
+    onMouseLeave?: EventHandler<MouseEvent>;
+    onMouseOver?: EventHandler<MouseEvent>;
+    onMouseOut?: EventHandler<MouseEvent>;
+    onTouchStart?: EventHandler<TouchEvent>;
+    [key: string]: any;
+}
+export declare function useLinkProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = ''>(options: UseLinkPropsOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): HTMLAttributes;
+export type UseLinkPropsOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string | undefined = '.', TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = '.'> = ActiveLinkOptions<'a', TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & HTMLAttributes;
+export type ActiveLinkOptions<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & ActiveLinkOptionProps<TComp>;
+type ActiveLinkProps<TComp> = Partial<HTMLAttributes & {
+    [key: `data-${string}`]: unknown;
+}>;
+export interface ActiveLinkOptionProps<TComp = 'a'> {
+    /**
+     * A function that returns additional props for the `active` state of this link.
+     * These props override other props passed to the link (`style`'s are merged, `class`'s are concatenated)
+     */
+    activeProps?: ActiveLinkProps<TComp> | (() => ActiveLinkProps<TComp>);
+    /**
+     * A function that returns additional props for the `inactive` state of this link.
+     * These props override other props passed to the link (`style`'s are merged, `class`'s are concatenated)
+     */
+    inactiveProps?: ActiveLinkProps<TComp> | (() => ActiveLinkProps<TComp>);
+}
+export type LinkProps<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = ActiveLinkOptions<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & LinkPropsChildren;
+export interface LinkPropsChildren {
+    children?: Vue.VNode | ((state: {
+        isActive: boolean;
+        isTransitioning: boolean;
+    }) => Vue.VNode);
+}
+type LinkComponentVueProps<TComp> = TComp extends keyof HTMLElementTagNameMap ? Omit<HTMLAttributes, keyof CreateLinkProps> : TComp extends Vue.Component ? Record<string, any> : Record<string, any>;
+export type LinkComponentProps<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkComponentVueProps<TComp> & LinkProps<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+export type CreateLinkProps = LinkProps<any, any, string, string, string, string>;
+export type LinkComponent<TComp> = <TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: LinkComponentProps<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Vue.VNode;
+export declare function createLink<const TComp>(Comp: Constrain<TComp, any, (props: CreateLinkProps) => Vue.VNode>): LinkComponent<TComp>;
+/**
+ * Link component with proper TypeScript generics support
+ */
+export declare const Link: {
+    <TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter["routeTree"]> | string = string, TTo extends string | undefined = ".", TMaskFrom extends RoutePaths<TRouter["routeTree"]> | string = TFrom, TMaskTo extends string = ".">(props: LinkComponentProps<"a", TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): Vue.VNode;
+};
+export type LinkOptionsFnOptions<TOptions, TComp, TRouter extends AnyRouter = RegisteredRouter> = TOptions extends ReadonlyArray<any> ? ValidateLinkOptionsArray<TRouter, TOptions, string, TComp> : ValidateLinkOptions<TRouter, TOptions, string, TComp>;
+export type LinkOptionsFn<TComp> = <const TOptions, TRouter extends AnyRouter = RegisteredRouter>(options: LinkOptionsFnOptions<TOptions, TComp, TRouter>) => TOptions;
+export declare const linkOptions: LinkOptionsFn<'a'>;
+export {};