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

package/dist/cjs/link.d.cts

@@ -1,93 +1,48 @@
+import { AnyRouter, Constrain, LinkOptions, RegisteredRouter, RoutePaths } from '@tanstack/router-core';
+import { ReactNode } from 'react';
+import { ValidateLinkOptions, ValidateLinkOptionsArray } from './typePrimitives.cjs';
 import * as React from 'react';
-import { Trim } from './fileRoute.cjs';
-import { AnyRoute, RootSearchSchema } from './route.cjs';
-import { RouteByPath, RoutePaths, RoutePathsAutoComplete } from './routeInfo.cjs';
-import { RegisteredRouter } from './router.cjs';
-import { Expand, IsUnion, MakeDifferenceOptional, NoInfer, NonNullableUpdater, PickRequired, Updater, WithoutEmpty } from './utils.cjs';
-import { HistoryState } from '@tanstack/history';
-export type CleanPath<T extends string> = T extends `${infer L}//${infer R}` ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`> : T extends `${infer L}//` ? `${CleanPath<L>}/` : T extends `//${infer L}` ? `/${CleanPath<L>}` : T;
-export type Split<S, TIncludeTrailingSlash = true> = S extends unknown ? string extends S ? string[] : S extends string ? CleanPath<S> extends '' ? [] : TIncludeTrailingSlash extends true ? CleanPath<S> extends `${infer T}/` ? [...Split<T>, '/'] : CleanPath<S> extends `/${infer U}` ? Split<U> : CleanPath<S> extends `${infer T}/${infer U}` ? [...Split<T>, ...Split<U>] : [S] : CleanPath<S> extends `${infer T}/${infer U}` ? [...Split<T>, ...Split<U>] : S extends string ? [S] : never : never : never;
-export type ParsePathParams<T extends string> = keyof {
-    [K in Trim<Split<T>[number], '_'> as K extends `$${infer L}` ? L extends '' ? '_splat' : L : never]: K;
-};
-export type Join<T, Delimiter extends string = '/'> = T extends [] ? '' : T extends [infer L extends string] ? L : T extends [infer L extends string, ...infer Tail extends [...string[]]] ? CleanPath<`${L}${Delimiter}${Join<Tail>}`> : never;
-export type Last<T extends any[]> = T extends [...infer _, infer L] ? L : never;
-export type RemoveTrailingSlashes<T> = T extends `${infer R}/` ? RemoveTrailingSlashes<R> : T;
-export type RemoveLeadingSlashes<T> = T extends `/${infer R}` ? RemoveLeadingSlashes<R> : T;
-export type SearchPaths<TPaths, TSearchPath extends string> = TPaths extends `${TSearchPath}/${infer TRest}` ? TRest : never;
-export type SearchRelativePathAutoComplete<TTo extends string, TSearchPath extends string, TPaths, SearchedPaths = SearchPaths<TPaths, TSearchPath>> = SearchedPaths extends string ? `${TTo}/${SearchedPaths}` : never;
-export type RelativeToParentPathAutoComplete<TFrom extends string, TTo extends string, TPaths, TResolvedPath extends string = RemoveTrailingSlashes<ResolveRelativePath<TFrom, TTo>>> = SearchRelativePathAutoComplete<TTo, TResolvedPath, TPaths> | (TResolvedPath extends '' ? never : `${TTo}/../`);
-export type RelativeToCurrentPathAutoComplete<TFrom extends string, TTo extends string, TRestTo extends string, TPaths, TResolvedPath extends string = RemoveTrailingSlashes<`${RemoveTrailingSlashes<TFrom>}/${RemoveLeadingSlashes<TRestTo>}`>> = SearchRelativePathAutoComplete<TTo, TResolvedPath, TPaths>;
-export type AbsolutePathAutoComplete<TFrom extends string, TPaths> = (string extends TFrom ? './' : TFrom extends `/` ? never : SearchPaths<TPaths, RemoveTrailingSlashes<TFrom>> extends infer SearchedPaths ? SearchedPaths extends '' ? never : './' : never) | (string extends TFrom ? '../' : TFrom extends `/` ? never : '../') | TPaths;
-export type RelativeToPathAutoComplete<TRouteTree extends AnyRoute, TFrom extends string, TTo extends string, TPaths = RoutePaths<TRouteTree>> = TTo extends `..${string}` ? RelativeToParentPathAutoComplete<TFrom, RemoveTrailingSlashes<TTo>, TPaths> : TTo extends `./${infer TRestTTo}` ? RelativeToCurrentPathAutoComplete<TFrom, RemoveTrailingSlashes<TTo>, TRestTTo, TPaths> : AbsolutePathAutoComplete<TFrom, TPaths>;
-export type NavigateOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''> = ToOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
-    replace?: boolean;
-    resetScroll?: boolean;
-    startTransition?: boolean;
-};
-export type ToOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''> = ToSubOptions<TRouteTree, TFrom, TTo> & {
-    mask?: ToMaskOptions<TRouteTree, TMaskFrom, TMaskTo>;
-};
-export type ToMaskOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TMaskFrom extends RoutePaths<TRouteTree> | string = string, TMaskTo extends string = ''> = ToSubOptions<TRouteTree, TMaskFrom, TMaskTo> & {
-    unmaskOnReload?: boolean;
-};
-export type ToSubOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = ''> = {
-    to?: ToPathOption<TRouteTree, TFrom, TTo>;
-    hash?: true | Updater<string>;
-    state?: true | NonNullableUpdater<HistoryState>;
-    from?: RoutePathsAutoComplete<TRouteTree, TFrom>;
-} & CheckPath<TRouteTree, {}, TFrom, TTo> & SearchParamOptions<TRouteTree, TFrom, TTo> & PathParamOptions<TRouteTree, TFrom, TTo>;
-type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo);
-type ParamVariant = 'PATH' | 'SEARCH';
-type ExcludeRootSearchSchema<T, Excluded = Exclude<T, RootSearchSchema>> = [
-    Excluded
-] extends [never] ? {} : Excluded;
-export type ResolveRoute<TRouteTree extends AnyRoute, TFrom, TTo, TPath = RemoveTrailingSlashes<string extends TTo ? TFrom : ResolveRelativePath<TFrom, TTo>>> = RouteByPath<TRouteTree, `${TPath & string}/`> extends never ? RouteByPath<TRouteTree, TPath> : RouteByPath<TRouteTree, `${TPath & string}/`>;
-type PostProcessParams<T, TParamVariant extends ParamVariant> = TParamVariant extends 'SEARCH' ? ExcludeRootSearchSchema<T> : T;
-export type ParamOptions<TRouteTree extends AnyRoute, TFrom, TTo extends string, TParamVariant extends ParamVariant, TFromRouteType extends 'allParams' | 'fullSearchSchema' = TParamVariant extends 'PATH' ? 'allParams' : 'fullSearchSchema', TToRouteType extends 'allParams' | 'fullSearchSchemaInput' = TParamVariant extends 'PATH' ? 'allParams' : 'fullSearchSchemaInput', TFromParams = PostProcessParams<RouteByPath<TRouteTree, TFrom>['types'][TFromRouteType], TParamVariant>, TToParams = PostProcessParams<ResolveRoute<TRouteTree, TFrom, TTo>['types'][TToRouteType], TParamVariant>, TRelativeToParams = TParamVariant extends 'SEARCH' ? TToParams : true extends IsUnion<TFromParams> ? TToParams : MakeDifferenceOptional<TFromParams, TToParams>, TReducer = ParamsReducer<TFromParams, TRelativeToParams>> = Expand<WithoutEmpty<PickRequired<TRelativeToParams>>> extends never ? Partial<MakeParamOption<TParamVariant, true | TReducer>> : TFromParams extends Expand<WithoutEmpty<PickRequired<TRelativeToParams>>> ? MakeParamOption<TParamVariant, true | TReducer> : MakeParamOption<TParamVariant, TReducer>;
-type MakeParamOption<TParamVariant extends ParamVariant, T> = TParamVariant extends 'PATH' ? MakePathParamOptions<T> : MakeSearchParamOptions<T>;
-type MakeSearchParamOptions<T> = {
-    search: T;
-};
-type MakePathParamOptions<T> = {
-    params: T;
-};
-export type SearchParamOptions<TRouteTree extends AnyRoute, TFrom, TTo extends string> = ParamOptions<TRouteTree, TFrom, TTo, 'SEARCH'>;
-export type PathParamOptions<TRouteTree extends AnyRoute, TFrom, TTo extends string> = ParamOptions<TRouteTree, TFrom, TTo, 'PATH'>;
-export type ToPathOption<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = ''> = TTo | RelativeToPathAutoComplete<TRouteTree, NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
-export interface ActiveOptions {
-    exact?: boolean;
-    includeHash?: boolean;
-    includeSearch?: boolean;
+export declare function useLinkProps<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(options: UseLinkPropsOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>, forwardedRef?: React.ForwardedRef<Element>): React.ComponentPropsWithRef<'a'>;
+type UseLinkReactProps<TComp> = TComp extends keyof React.JSX.IntrinsicElements ? React.JSX.IntrinsicElements[TComp] : React.PropsWithoutRef<TComp extends React.ComponentType<infer TProps> ? TProps : never> & React.RefAttributes<TComp extends React.FC<{
+    ref: infer TRef;
+}> | React.Component<{
+    ref: infer TRef;
+}> ? TRef : never>;
+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> & UseLinkReactProps<'a'>;
+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<LinkComponentReactProps<TComp> & {
+    [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, `className`'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, `className`'s are concatenated)
+     */
+    inactiveProps?: ActiveLinkProps<TComp> | (() => ActiveLinkProps<TComp>);
 }
-export type LinkOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
-    target?: HTMLAnchorElement['target'];
-    activeOptions?: ActiveOptions;
-    preload?: false | 'intent';
-    preloadDelay?: number;
-    disabled?: boolean;
-};
-export type CheckPath<TRouteTree extends AnyRoute, TPass, TFrom, TTo> = ResolveRoute<TRouteTree, TFrom, TTo> extends never ? string extends TFrom ? RemoveTrailingSlashes<TTo> extends '.' | '..' ? TPass : CheckPathError<TRouteTree> : CheckPathError<TRouteTree> : TPass;
-export type CheckPathError<TRouteTree extends AnyRoute> = {
-    to: RoutePaths<TRouteTree>;
-};
-export type ResolveRelativePath<TFrom, TTo = '.'> = TFrom extends string ? TTo extends string ? TTo extends '.' ? TFrom : TTo extends `./` ? Join<[TFrom, '/']> : TTo extends `./${infer TRest}` ? ResolveRelativePath<TFrom, TRest> : TTo extends `/${infer TRest}` ? TTo : Split<TTo> extends ['..', ...infer ToRest] ? Split<TFrom> extends [...infer FromRest, infer FromTail] ? ToRest extends ['/'] ? Join<['/', ...FromRest, '/']> : ResolveRelativePath<Join<FromRest>, Join<ToRest>> : never : Split<TTo> extends ['.', ...infer ToRest] ? ToRest extends ['/'] ? Join<[TFrom, '/']> : ResolveRelativePath<TFrom, Join<ToRest>> : CleanPath<Join<['/', ...Split<TFrom>, ...Split<TTo>]>> : never : never;
-export declare function useLinkProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''>(options: UseLinkPropsOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): React.AnchorHTMLAttributes<HTMLAnchorElement>;
-export type UseLinkPropsOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''> = ActiveLinkOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>;
-export type ActiveLinkOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''> = LinkOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
-    activeProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
-    inactiveProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
-};
-export type LinkProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''> = ActiveLinkOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
+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?: React.ReactNode | ((state: {
         isActive: boolean;
+        isTransitioning: boolean;
     }) => React.ReactNode);
-};
-type LinkComponent<TComp> = <TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''>(props: React.PropsWithoutRef<LinkProps<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & (TComp extends React.FC<infer TProps> | React.Component<infer TProps> ? TProps : TComp extends keyof JSX.IntrinsicElements ? Omit<React.HTMLProps<TComp>, 'children' | 'preload'> : never)> & React.RefAttributes<TComp extends React.FC<{
-    ref: infer TRef;
-}> | React.Component<{
-    ref: infer TRef;
-}> ? TRef : TComp extends keyof JSX.IntrinsicElements ? React.ComponentRef<TComp> : never>) => React.ReactElement;
-export declare function createLink<const TComp>(Comp: TComp): LinkComponent<TComp>;
+}
+type LinkComponentReactProps<TComp> = Omit<UseLinkReactProps<TComp>, keyof CreateLinkProps>;
+export type LinkComponentProps<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkComponentReactProps<TComp> & LinkProps<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+export type CreateLinkProps = LinkProps<any, any, string, string, string, string>;
+export type LinkComponent<in out TComp, in out TDefaultFrom extends string = string> = <TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = TDefaultFrom, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: LinkComponentProps<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => React.ReactElement;
+export interface LinkComponentRoute<in out TDefaultFrom extends string = string> {
+    defaultFrom: TDefaultFrom;
+    <TRouter extends AnyRouter = RegisteredRouter, const TTo extends string | undefined = undefined, const TMaskTo extends string = ''>(props: LinkComponentProps<'a', TRouter, this['defaultFrom'], TTo, this['defaultFrom'], TMaskTo>): React.ReactElement;
+}
+export declare function createLink<const TComp>(Comp: Constrain<TComp, any, (props: CreateLinkProps) => ReactNode>): LinkComponent<TComp>;
 export declare const Link: LinkComponent<'a'>;
+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 {};

package/dist/cjs/matchContext.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+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);
+const matchContext = React__namespace.createContext(void 0);
+const dummyMatchContext = React__namespace.createContext(
+  void 0
+);
+exports.dummyMatchContext = dummyMatchContext;
+exports.matchContext = matchContext;
+//# sourceMappingURL=matchContext.cjs.map

package/dist/cjs/matchContext.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchContext.cjs","sources":["../../src/matchContext.tsx"],"sourcesContent":["import * as React from 'react'\n\nexport const matchContext = React.createContext<string | undefined>(undefined)\n\n// N.B. this only exists so we can conditionally call useContext on it when we are not interested in the nearest match\nexport const dummyMatchContext = React.createContext<string | undefined>(\n  undefined,\n)\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;AAEa,MAAA,eAAeA,iBAAM,cAAkC,MAAS;AAGtE,MAAM,oBAAoBA,iBAAM;AAAA,EACrC;AACF;;;"}

package/dist/cjs/matchContext.d.cts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export declare const matchContext: React.Context<string | undefined>;
+export declare const dummyMatchContext: React.Context<string | undefined>;

package/dist/cjs/not-found.cjs

@@ -1,17 +1,9 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const jsxRuntime = require("react/jsx-runtime");
+const routerCore = require("@tanstack/router-core");
 const CatchBoundary = require("./CatchBoundary.cjs");
 const useRouterState = require("./useRouterState.cjs");
-function notFound(options = {}) {
-  options.isNotFound = true;
-  if (options.throw)
-    throw options;
-  return options;
-}
-function isNotFound(obj) {
-  return !!(obj == null ? void 0 : obj.isNotFound);
-}
 function CatchNotFound(props) {
   const resetKey = useRouterState.useRouterState({
     select: (s) => `not-found-${s.location.pathname}-${s.status}`
@@ -20,17 +12,21 @@ function CatchNotFound(props) {
     CatchBoundary.CatchBoundary,
     {
       getResetKey: () => resetKey,
-      onCatch: (error) => {
+      onCatch: (error, errorInfo) => {
         var _a;
-        if (isNotFound(error)) {
-          (_a = props.onCatch) == null ? void 0 : _a.call(props, error);
+        if (routerCore.isNotFound(error)) {
+          (_a = props.onCatch) == null ? void 0 : _a.call(props, error, errorInfo);
         } else {
           throw error;
         }
       },
       errorComponent: ({ error }) => {
         var _a;
-        return (_a = props.fallback) == null ? void 0 : _a.call(props, error);
+        if (routerCore.isNotFound(error)) {
+          return (_a = props.fallback) == null ? void 0 : _a.call(props, error);
+        } else {
+          throw error;
+        }
       },
       children: props.children
     }
@@ -41,6 +37,4 @@ function DefaultGlobalNotFound() {
 }
 exports.CatchNotFound = CatchNotFound;
 exports.DefaultGlobalNotFound = DefaultGlobalNotFound;
-exports.isNotFound = isNotFound;
-exports.notFound = notFound;
 //# sourceMappingURL=not-found.cjs.map

package/dist/cjs/not-found.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"not-found.cjs","sources":["../../src/not-found.tsx"],"sourcesContent":["import * as React from 'react'\nimport { CatchBoundary } from './CatchBoundary'\nimport { useRouterState } from './useRouterState'\nimport { RegisteredRouter } from './router'\nimport { RouteIds } from './routeInfo'\n\nexport type NotFoundError = {\n  /**\n    @deprecated\n    Use `routeId: rootRouteId` instead\n  */\n  global?: boolean\n  /**\n    @private\n    Do not use this. It's used internally to indicate a path matching error\n  */\n  _global?: boolean\n  data?: any\n  throw?: boolean\n  routeId?: RouteIds<RegisteredRouter['routeTree']>\n}\n\nexport function notFound(options: NotFoundError = {}) {\n  ;(options as any).isNotFound = true\n  if (options.throw) throw options\n  return options\n}\n\nexport function isNotFound(obj: any): obj is NotFoundError {\n  return !!obj?.isNotFound\n}\n\nexport function CatchNotFound(props: {\n  fallback?: (error: NotFoundError) => React.ReactElement\n  onCatch?: (error: any) => void\n  children: React.ReactNode\n}) {\n  // TODO: Some way for the user to programmatically reset the not-found boundary?\n  const resetKey = useRouterState({\n    select: (s) => `not-found-${s.location.pathname}-${s.status}`,\n  })\n\n  return (\n    <CatchBoundary\n      getResetKey={() => resetKey}\n      onCatch={(error) => {\n        if (isNotFound(error)) {\n          props.onCatch?.(error)\n        } else {\n          throw error\n        }\n      }}\n      errorComponent={({ error }: { error: NotFoundError }) =>\n        props.fallback?.(error)\n      }\n    >\n      {props.children}\n    </CatchBoundary>\n  )\n}\n\nexport function DefaultGlobalNotFound() {\n  return <p>Not Found</p>\n}\n"],"names":["useRouterState","jsx","CatchBoundary"],"mappings":";;;;;AAsBgB,SAAA,SAAS,UAAyB,IAAI;AAClD,UAAgB,aAAa;AAC/B,MAAI,QAAQ;AAAa,UAAA;AAClB,SAAA;AACT;AAEO,SAAS,WAAW,KAAgC;AAClD,SAAA,CAAC,EAAC,2BAAK;AAChB;AAEO,SAAS,cAAc,OAI3B;AAED,QAAM,WAAWA,eAAAA,eAAe;AAAA,IAC9B,QAAQ,CAAC,MAAM,aAAa,EAAE,SAAS,QAAQ,IAAI,EAAE,MAAM;AAAA,EAAA,CAC5D;AAGC,SAAAC,2BAAA;AAAA,IAACC,cAAA;AAAA,IAAA;AAAA,MACC,aAAa,MAAM;AAAA,MACnB,SAAS,CAAC,UAAU;;AACd,YAAA,WAAW,KAAK,GAAG;AACrB,sBAAM,YAAN,+BAAgB;AAAA,QAAK,OAChB;AACC,gBAAA;AAAA,QACR;AAAA,MACF;AAAA,MACA,gBAAgB,CAAC,EAAE,YACjB;;AAAA,2BAAM,aAAN,+BAAiB;AAAA;AAAA,MAGlB,UAAM,MAAA;AAAA,IAAA;AAAA,EAAA;AAGb;AAEO,SAAS,wBAAwB;AAC/B,SAAAD,2BAAA,IAAC,OAAE,UAAS,YAAA,CAAA;AACrB;;;;;"}
+{"version":3,"file":"not-found.cjs","sources":["../../src/not-found.tsx"],"sourcesContent":["import * as React from 'react'\nimport { isNotFound } from '@tanstack/router-core'\nimport { CatchBoundary } from './CatchBoundary'\nimport { useRouterState } from './useRouterState'\nimport type { ErrorInfo } from 'react'\nimport type { NotFoundError } from '@tanstack/router-core'\n\nexport function CatchNotFound(props: {\n  fallback?: (error: NotFoundError) => React.ReactElement\n  onCatch?: (error: Error, errorInfo: ErrorInfo) => void\n  children: React.ReactNode\n}) {\n  // TODO: Some way for the user to programmatically reset the not-found boundary?\n  const resetKey = useRouterState({\n    select: (s) => `not-found-${s.location.pathname}-${s.status}`,\n  })\n\n  return (\n    <CatchBoundary\n      getResetKey={() => resetKey}\n      onCatch={(error, errorInfo) => {\n        if (isNotFound(error)) {\n          props.onCatch?.(error, errorInfo)\n        } else {\n          throw error\n        }\n      }}\n      errorComponent={({ error }: { error: Error }) => {\n        if (isNotFound(error)) {\n          return props.fallback?.(error)\n        } else {\n          throw error\n        }\n      }}\n    >\n      {props.children}\n    </CatchBoundary>\n  )\n}\n\nexport function DefaultGlobalNotFound() {\n  return <p>Not Found</p>\n}\n"],"names":["useRouterState","jsx","CatchBoundary","isNotFound"],"mappings":";;;;;;AAOO,SAAS,cAAc,OAI3B;AAED,QAAM,WAAWA,eAAAA,eAAe;AAAA,IAC9B,QAAQ,CAAC,MAAM,aAAa,EAAE,SAAS,QAAQ,IAAI,EAAE,MAAM;AAAA,EAAA,CAC5D;AAGC,SAAAC,2BAAA;AAAA,IAACC,cAAA;AAAA,IAAA;AAAA,MACC,aAAa,MAAM;AAAA,MACnB,SAAS,CAAC,OAAO,cAAc;;AACzB,YAAAC,WAAAA,WAAW,KAAK,GAAG;AACf,sBAAA,YAAA,+BAAU,OAAO;AAAA,QAAS,OAC3B;AACC,gBAAA;AAAA,QAAA;AAAA,MAEV;AAAA,MACA,gBAAgB,CAAC,EAAE,YAA8B;;AAC3C,YAAAA,WAAAA,WAAW,KAAK,GAAG;AACd,kBAAA,WAAM,aAAN,+BAAiB;AAAA,QAAK,OACxB;AACC,gBAAA;AAAA,QAAA;AAAA,MAEV;AAAA,MAEC,UAAM,MAAA;AAAA,IAAA;AAAA,EACT;AAEJ;AAEO,SAAS,wBAAwB;AAC/B,SAAAF,2BAAA,IAAC,OAAE,UAAS,YAAA,CAAA;AACrB;;;"}

package/dist/cjs/not-found.d.cts

@@ -1,26 +1,9 @@
+import { ErrorInfo } from 'react';
+import { NotFoundError } from '@tanstack/router-core';
 import * as React from 'react';
-import { RegisteredRouter } from './router.cjs';
-import { RouteIds } from './routeInfo.cjs';
-export type NotFoundError = {
-    /**
-      @deprecated
-      Use `routeId: rootRouteId` instead
-    */
-    global?: boolean;
-    /**
-      @private
-      Do not use this. It's used internally to indicate a path matching error
-    */
-    _global?: boolean;
-    data?: any;
-    throw?: boolean;
-    routeId?: RouteIds<RegisteredRouter['routeTree']>;
-};
-export declare function notFound(options?: NotFoundError): NotFoundError;
-export declare function isNotFound(obj: any): obj is NotFoundError;
 export declare function CatchNotFound(props: {
     fallback?: (error: NotFoundError) => React.ReactElement;
-    onCatch?: (error: any) => void;
+    onCatch?: (error: Error, errorInfo: ErrorInfo) => void;
     children: React.ReactNode;
-}): React.JSX.Element;
-export declare function DefaultGlobalNotFound(): React.JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DefaultGlobalNotFound(): import("react/jsx-runtime").JSX.Element;

package/dist/cjs/renderRouteNotFound.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const warning = require("tiny-warning");
+const notFound = require("./not-found.cjs");
+function renderRouteNotFound(router, route, data) {
+  if (!route.options.notFoundComponent) {
+    if (router.options.defaultNotFoundComponent) {
+      return /* @__PURE__ */ jsxRuntime.jsx(router.options.defaultNotFoundComponent, { data });
+    }
+    if (process.env.NODE_ENV === "development") {
+      warning(
+        route.options.notFoundComponent,
+        `A notFoundError was encountered on the route with ID "${route.id}", but a notFoundComponent option was not configured, nor was a router level defaultNotFoundComponent configured. Consider configuring at least one of these to avoid TanStack Router's overly generic defaultNotFoundComponent (<div>Not Found<div>)`
+      );
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(notFound.DefaultGlobalNotFound, {});
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(route.options.notFoundComponent, { data });
+}
+exports.renderRouteNotFound = renderRouteNotFound;
+//# sourceMappingURL=renderRouteNotFound.cjs.map

package/dist/cjs/renderRouteNotFound.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderRouteNotFound.cjs","sources":["../../src/renderRouteNotFound.tsx"],"sourcesContent":["import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { DefaultGlobalNotFound } from './not-found'\nimport type { AnyRoute, AnyRouter } from '@tanstack/router-core'\n\nexport function renderRouteNotFound(\n  router: AnyRouter,\n  route: AnyRoute,\n  data: any,\n) {\n  if (!route.options.notFoundComponent) {\n    if (router.options.defaultNotFoundComponent) {\n      return <router.options.defaultNotFoundComponent data={data} />\n    }\n\n    if (process.env.NODE_ENV === 'development') {\n      warning(\n        route.options.notFoundComponent,\n        `A notFoundError was encountered on the route with ID \"${route.id}\", but a notFoundComponent option was not configured, nor was a router level defaultNotFoundComponent configured. Consider configuring at least one of these to avoid TanStack Router's overly generic defaultNotFoundComponent (<div>Not Found<div>)`,\n      )\n    }\n\n    return <DefaultGlobalNotFound />\n  }\n\n  return <route.options.notFoundComponent data={data} />\n}\n"],"names":["jsx","DefaultGlobalNotFound"],"mappings":";;;;;AAKgB,SAAA,oBACd,QACA,OACA,MACA;AACI,MAAA,CAAC,MAAM,QAAQ,mBAAmB;AAChC,QAAA,OAAO,QAAQ,0BAA0B;AAC3C,aAAQA,2BAAAA,IAAA,OAAO,QAAQ,0BAAf,EAAwC,KAAY,CAAA;AAAA,IAAA;AAG1D,QAAA,QAAQ,IAAI,aAAa,eAAe;AAC1C;AAAA,QACE,MAAM,QAAQ;AAAA,QACd,yDAAyD,MAAM,EAAE;AAAA,MACnE;AAAA,IAAA;AAGF,0CAAQC,SAAsB,uBAAA,EAAA;AAAA,EAAA;AAGhC,SAAQD,2BAAAA,IAAA,MAAM,QAAQ,mBAAd,EAAgC,KAAY,CAAA;AACtD;;"}

package/dist/cjs/renderRouteNotFound.d.cts

@@ -0,0 +1,2 @@
+import { AnyRoute, AnyRouter } from '@tanstack/router-core';
+export declare function renderRouteNotFound(router: AnyRouter, route: AnyRoute, data: any): import("react/jsx-runtime").JSX.Element;

package/dist/cjs/route.cjs

@@ -1,130 +1,119 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const invariant = require("tiny-invariant");
-const Matches = require("./Matches.cjs");
-const path = require("./path.cjs");
+const jsxRuntime = require("react/jsx-runtime");
+const routerCore = require("@tanstack/router-core");
+const React = require("react");
+const useLoaderData = require("./useLoaderData.cjs");
+const useLoaderDeps = require("./useLoaderDeps.cjs");
 const useParams = require("./useParams.cjs");
 const useSearch = require("./useSearch.cjs");
-const notFound = require("./not-found.cjs");
-const rootRouteId = "__root__";
+const useNavigate = require("./useNavigate.cjs");
+const useMatch = require("./useMatch.cjs");
+const useRouter = require("./useRouter.cjs");
+const link = require("./link.cjs");
 function getRouteApi(id) {
   return new RouteApi({ id });
 }
-class RouteApi {
+class RouteApi extends routerCore.BaseRouteApi {
   /**
    * @deprecated Use the `getRouteApi` function instead.
    */
   constructor({ id }) {
+    super({ id });
     this.useMatch = (opts) => {
-      return Matches.useMatch({ select: opts == null ? void 0 : opts.select, from: this.id });
+      return useMatch.useMatch({
+        select: opts == null ? void 0 : opts.select,
+        from: this.id,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing
+      });
     };
     this.useRouteContext = (opts) => {
-      return Matches.useMatch({
+      return useMatch.useMatch({
         from: this.id,
         select: (d) => (opts == null ? void 0 : opts.select) ? opts.select(d.context) : d.context
       });
     };
     this.useSearch = (opts) => {
-      return useSearch.useSearch({ ...opts, from: this.id });
+      return useSearch.useSearch({
+        select: opts == null ? void 0 : opts.select,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing,
+        from: this.id
+      });
     };
     this.useParams = (opts) => {
-      return useParams.useParams({ ...opts, from: this.id });
+      return useParams.useParams({
+        select: opts == null ? void 0 : opts.select,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing,
+        from: this.id
+      });
     };
     this.useLoaderDeps = (opts) => {
-      return Matches.useLoaderDeps({ ...opts, from: this.id, strict: false });
+      return useLoaderDeps.useLoaderDeps({ ...opts, from: this.id, strict: false });
     };
     this.useLoaderData = (opts) => {
-      return Matches.useLoaderData({ ...opts, from: this.id, strict: false });
+      return useLoaderData.useLoaderData({ ...opts, from: this.id, strict: false });
+    };
+    this.useNavigate = () => {
+      const router = useRouter.useRouter();
+      return useNavigate.useNavigate({ from: router.routesById[this.id].fullPath });
     };
     this.notFound = (opts) => {
-      return notFound.notFound({ routeId: this.id, ...opts });
+      return routerCore.notFound({ routeId: this.id, ...opts });
     };
-    this.id = id;
+    this.Link = React.forwardRef((props, ref) => {
+      const router = useRouter.useRouter();
+      const fullPath = router.routesById[this.id].fullPath;
+      return /* @__PURE__ */ jsxRuntime.jsx(link.Link, { ref, from: fullPath, ...props });
+    });
   }
 }
-class Route {
+class Route extends routerCore.BaseRoute {
   /**
    * @deprecated Use the `createRoute` function instead.
    */
   constructor(options) {
-    this.init = (opts) => {
-      var _a, _b;
-      this.originalIndex = opts.originalIndex;
-      const options2 = this.options;
-      const isRoot = !(options2 == null ? void 0 : options2.path) && !(options2 == null ? void 0 : options2.id);
-      this.parentRoute = (_b = (_a = this.options) == null ? void 0 : _a.getParentRoute) == null ? void 0 : _b.call(_a);
-      if (isRoot) {
-        this.path = rootRouteId;
-      } else {
-        invariant(
-          this.parentRoute,
-          `Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance.`
-        );
-      }
-      let path$1 = isRoot ? rootRouteId : options2.path;
-      if (path$1 && path$1 !== "/") {
-        path$1 = path.trimPathLeft(path$1);
-      }
-      const customId = (options2 == null ? void 0 : options2.id) || path$1;
-      let id = isRoot ? rootRouteId : path.joinPaths([
-        this.parentRoute.id === rootRouteId ? "" : this.parentRoute.id,
-        customId
-      ]);
-      if (path$1 === rootRouteId) {
-        path$1 = "/";
-      }
-      if (id !== rootRouteId) {
-        id = path.joinPaths(["/", id]);
-      }
-      const fullPath = id === rootRouteId ? "/" : path.joinPaths([this.parentRoute.fullPath, path$1]);
-      this.path = path$1;
-      this.id = id;
-      this.fullPath = fullPath;
-      this.to = fullPath;
-    };
-    this.addChildren = (children) => {
-      this.children = children;
-      return this;
-    };
-    this.updateLoader = (options2) => {
-      Object.assign(this.options, options2);
-      return this;
-    };
-    this.update = (options2) => {
-      Object.assign(this.options, options2);
-      return this;
-    };
-    this.lazy = (lazyFn) => {
-      this.lazyFn = lazyFn;
-      return this;
-    };
+    super(options);
     this.useMatch = (opts) => {
-      return Matches.useMatch({ ...opts, from: this.id });
+      return useMatch.useMatch({
+        select: opts == null ? void 0 : opts.select,
+        from: this.id,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing
+      });
     };
     this.useRouteContext = (opts) => {
-      return Matches.useMatch({
+      return useMatch.useMatch({
         ...opts,
         from: this.id,
         select: (d) => (opts == null ? void 0 : opts.select) ? opts.select(d.context) : d.context
       });
     };
     this.useSearch = (opts) => {
-      return useSearch.useSearch({ ...opts, from: this.id });
+      return useSearch.useSearch({
+        select: opts == null ? void 0 : opts.select,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing,
+        from: this.id
+      });
     };
     this.useParams = (opts) => {
-      return useParams.useParams({ ...opts, from: this.id });
+      return useParams.useParams({
+        select: opts == null ? void 0 : opts.select,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing,
+        from: this.id
+      });
     };
     this.useLoaderDeps = (opts) => {
-      return Matches.useLoaderDeps({ ...opts, from: this.id });
+      return useLoaderDeps.useLoaderDeps({ ...opts, from: this.id });
     };
     this.useLoaderData = (opts) => {
-      return Matches.useLoaderData({ ...opts, from: this.id });
+      return useLoaderData.useLoaderData({ ...opts, from: this.id });
+    };
+    this.useNavigate = () => {
+      return useNavigate.useNavigate({ from: this.fullPath });
     };
-    this.options = options || {};
-    this.isRoot = !(options == null ? void 0 : options.getParentRoute);
-    invariant(
-      !((options == null ? void 0 : options.id) && (options == null ? void 0 : options.path)),
-      `Route cannot have both an 'id' and a 'path' option.`
+    this.Link = React.forwardRef(
+      (props, ref) => {
+        return /* @__PURE__ */ jsxRuntime.jsx(link.Link, { ref, from: this.fullPath, ...props });
+      }
     );
     this.$$typeof = Symbol.for("react.memo");
   }
@@ -138,12 +127,55 @@ function createRootRouteWithContext() {
   };
 }
 const rootRouteWithContext = createRootRouteWithContext;
-class RootRoute extends Route {
+class RootRoute extends routerCore.BaseRootRoute {
   /**
    * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
    */
   constructor(options) {
     super(options);
+    this.useMatch = (opts) => {
+      return useMatch.useMatch({
+        select: opts == null ? void 0 : opts.select,
+        from: this.id,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing
+      });
+    };
+    this.useRouteContext = (opts) => {
+      return useMatch.useMatch({
+        ...opts,
+        from: this.id,
+        select: (d) => (opts == null ? void 0 : opts.select) ? opts.select(d.context) : d.context
+      });
+    };
+    this.useSearch = (opts) => {
+      return useSearch.useSearch({
+        select: opts == null ? void 0 : opts.select,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing,
+        from: this.id
+      });
+    };
+    this.useParams = (opts) => {
+      return useParams.useParams({
+        select: opts == null ? void 0 : opts.select,
+        structuralSharing: opts == null ? void 0 : opts.structuralSharing,
+        from: this.id
+      });
+    };
+    this.useLoaderDeps = (opts) => {
+      return useLoaderDeps.useLoaderDeps({ ...opts, from: this.id });
+    };
+    this.useLoaderData = (opts) => {
+      return useLoaderData.useLoaderData({ ...opts, from: this.id });
+    };
+    this.useNavigate = () => {
+      return useNavigate.useNavigate({ from: this.fullPath });
+    };
+    this.Link = React.forwardRef(
+      (props, ref) => {
+        return /* @__PURE__ */ jsxRuntime.jsx(link.Link, { ref, from: this.fullPath, ...props });
+      }
+    );
+    this.$$typeof = Symbol.for("react.memo");
   }
 }
 function createRootRoute(options) {
@@ -169,6 +201,5 @@ exports.createRootRouteWithContext = createRootRouteWithContext;
 exports.createRoute = createRoute;
 exports.createRouteMask = createRouteMask;
 exports.getRouteApi = getRouteApi;
-exports.rootRouteId = rootRouteId;
 exports.rootRouteWithContext = rootRouteWithContext;
 //# sourceMappingURL=route.cjs.map