@tanstack/react-router 0.0.1-beta.263 → 0.0.1-beta.265

package/build/types/Matches.d.ts

@@ -21,6 +21,7 @@ export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId ext
     loadPromise?: Promise<void>;
     loaderData?: RouteById<TRouteTree, TRouteId>['types']['loaderData'];
     __resolveLoadPromise?: () => void;
+    routeContext: RouteById<TRouteTree, TRouteId>['types']['routeContext'];
     context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
     search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
     fetchedAt: number;
@@ -52,6 +53,6 @@ export declare function useMatch<TRouteTree extends AnyRoute = RegisteredRouter[
 export declare function useMatches<T = RouteMatch[]>(opts?: {
     select?: (matches: RouteMatch[]) => T;
 }): T;
-export declare function useLoaderData<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatch extends RouteMatch<TRouteTree, TFrom> = RouteMatch<TRouteTree, TFrom>, TSelected = TRouteMatch['loaderData']>(opts: StrictOrFrom<TFrom> & {
+export declare function useLoaderData<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatch extends RouteMatch<TRouteTree, TFrom> = RouteMatch<TRouteTree, TFrom>, TSelected = Required<TRouteMatch>['loaderData']>(opts: StrictOrFrom<TFrom> & {
     select?: (match: TRouteMatch) => TSelected;
 }): TStrict extends true ? TSelected : TSelected | undefined;

package/build/types/route.d.ts

@@ -2,8 +2,8 @@ import * as React from 'react';
 import { AnyRouteMatch } from './Matches';
 import { NavigateOptions, ParsePathParams, ToSubOptions } from './link';
 import { ParsedLocation } from './location';
-import { RoutePaths } from './routeInfo';
-import { AnyRouter } from './router';
+import { RouteById, RouteIds, RoutePaths } from './routeInfo';
+import { AnyRouter, RegisteredRouter } from './router';
 import { Assign, Expand, IsAny, NoInfer, PickRequired, UnionToIntersection } from './utils';
 import { BuildLocationFn, NavigateFn } from './RouterProvider';
 export declare const rootRouteId: "__root__";
@@ -141,6 +141,27 @@ export type RouteConstraints = {
     TChildren: unknown;
     TRouteTree: AnyRoute;
 };
+export declare class RouteApi<TId extends RouteIds<RegisteredRouter['routeTree']>, TRoute extends AnyRoute = RouteById<RegisteredRouter['routeTree'], TId>, TFullSearchSchema extends Record<string, any> = TRoute['types']['fullSearchSchema'], TAllParams extends AnyPathParams = TRoute['types']['allParams'], TAllContext extends Record<string, any> = TRoute['types']['allContext'], TLoaderData extends any = TRoute['types']['loaderData']> {
+    id: TId;
+    constructor({ id }: {
+        id: TId;
+    });
+    useMatch: <TSelected = TAllContext>(opts?: {
+        select?: ((search: TAllContext) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useRouteContext: <TSelected = TAllContext>(opts?: {
+        select?: ((search: TAllContext) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useSearch: <TSelected = TFullSearchSchema>(opts?: {
+        select?: ((search: TFullSearchSchema) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useParams: <TSelected = TAllParams>(opts?: {
+        select?: ((search: TAllParams) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useLoaderData: <TSelected = TLoaderData>(opts?: {
+        select?: ((search: TLoaderData) => TSelected) | undefined;
+    } | undefined) => TSelected;
+}
 export declare class Route<TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, TPath extends RouteConstraints['TPath'] = '/', TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints['TCustomId'] = string, TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, TSearchSchema extends RouteConstraints['TSearchSchema'] = {}, TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends RouteConstraints['TParams'] = Expand<Record<ParsePathParams<TPath>, string>>, TAllParams extends RouteConstraints['TAllParams'] = ResolveAllParams<TParentRoute, TParams>, TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends Expand<Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>> = Expand<Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TLoaderData extends any = unknown, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
     isRoot: TParentRoute extends Route<any> ? true : false;
     options: RouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TAllContext, TLoaderData>;

package/build/umd/index.development.js

@@ -1122,6 +1122,44 @@
 
   // The parse type here allows a zod schema to be passed directly to the validator
 
+  class RouteApi {
+    constructor({
+      id
+    }) {
+      this.id = id;
+    }
+    useMatch = opts => {
+      return useMatch({
+        ...opts,
+        from: this.id
+      });
+    };
+    useRouteContext = opts => {
+      return useMatch({
+        ...opts,
+        from: this.id,
+        select: d => opts?.select ? opts.select(d.context) : d.context
+      });
+    };
+    useSearch = opts => {
+      return useSearch({
+        ...opts,
+        from: this.id
+      });
+    };
+    useParams = opts => {
+      return useParams({
+        ...opts,
+        from: this.id
+      });
+    };
+    useLoaderData = opts => {
+      return useLoaderData({
+        ...opts,
+        from: this.id
+      });
+    };
+  }
   class Route {
     // Set up in this.init()
 
@@ -2280,6 +2318,7 @@
           error: undefined,
           paramsError: parseErrors[index],
           loadPromise: Promise.resolve(),
+          routeContext: undefined,
           context: undefined,
           abortController: new AbortController(),
           shouldReloadDeps: undefined,
@@ -2559,6 +2598,7 @@
             };
             matches[index] = match = {
               ...match,
+              routeContext: replaceEqualDeep(match.routeContext, beforeLoadContext),
               context: replaceEqualDeep(match.context, context),
               abortController
             };
@@ -3186,6 +3226,7 @@
   exports.PathParamError = PathParamError;
   exports.RootRoute = RootRoute;
   exports.Route = Route;
+  exports.RouteApi = RouteApi;
   exports.Router = Router;
   exports.RouterProvider = RouterProvider;
   exports.ScrollRestoration = ScrollRestoration;