@tanstack/react-router 1.4.7 → 1.4.9

package/build/types/Matches.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { ResolveRelativePath, ToOptions } from './link';
 import { AnyRoute, ReactNode } from './route';
-import { FullSearchSchema, ParseRoute, RouteById, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { ParseRoute, RouteById, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
 import { RegisteredRouter, RouterState } from './router';
-import { NoInfer, StrictOrFrom } from './utils';
+import { GetTFrom, NoInfer, StrictOrFrom } from './utils';
 export declare const matchContext: React.Context<string | undefined>;
 export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id']> {
     id: string;
@@ -21,7 +21,7 @@ export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId ext
     loaderData?: RouteById<TRouteTree, TRouteId>['types']['loaderData'];
     routeContext: RouteById<TRouteTree, TRouteId>['types']['routeContext'];
     context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
-    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
+    search: RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
     fetchCount: number;
     abortController: AbortController;
     cause: 'preload' | 'enter' | 'stay';
@@ -49,18 +49,18 @@ export type MakeMatchRouteOptions<TRouteTree extends AnyRoute = RegisteredRouter
 };
 export declare function MatchRoute<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: MakeMatchRouteOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): any;
 export declare function getRenderedMatches(state: RouterState): RouteMatch<AnyRoute, any>[];
-export declare function useMatch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatchState = RouteMatch<TRouteTree, TFrom>, TSelected = TRouteMatchState>(opts: StrictOrFrom<TFrom> & {
+export declare function useMatch<TOpts extends StrictOrFrom<TFrom>, TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TFromInferred extends RouteIds<TRouteTree> = GetTFrom<TOpts, TRouteTree>, TRouteMatchState = RouteMatch<TRouteTree, TFromInferred>, TSelected = TRouteMatchState>(opts: TOpts & {
     select?: (match: TRouteMatchState) => TSelected;
-}): TStrict extends true ? TSelected : TSelected | undefined;
+}): TSelected;
 export declare function useMatches<T = RouteMatch[]>(opts?: {
     select?: (matches: RouteMatch[]) => T;
 }): T;
 export declare function useParentMatches<T = RouteMatch[]>(opts?: {
     select?: (matches: RouteMatch[]) => T;
 }): T;
-export declare function useLoaderDeps<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>['loaderDeps']>(opts: StrictOrFrom<TFrom> & {
+export declare function useLoaderDeps<TOpts extends StrictOrFrom<TFrom>, TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TFromInferred extends RouteIds<TRouteTree> = GetTFrom<TOpts, TRouteTree>, TRouteMatch extends RouteMatch<TRouteTree, TFromInferred> = RouteMatch<TRouteTree, TFromInferred>, TSelected = Required<TRouteMatch>['loaderDeps']>(opts: TOpts & {
     select?: (match: TRouteMatch) => TSelected;
-}): TStrict extends true ? TSelected : TSelected | undefined;
-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> & {
+}): TSelected;
+export declare function useLoaderData<TOpts extends StrictOrFrom<TFrom>, TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TFromInferred extends RouteIds<TRouteTree> = GetTFrom<TOpts, TRouteTree>, TRouteMatch extends RouteMatch<TRouteTree, TFromInferred> = RouteMatch<TRouteTree, TFromInferred>, TSelected = Required<TRouteMatch>['loaderData']>(opts: TOpts & {
     select?: (match: TRouteMatch) => TSelected;
-}): TStrict extends true ? TSelected : TSelected | undefined;
+}): TSelected;

package/build/types/link.d.ts

@@ -4,7 +4,7 @@ import { AnyRoute, ReactNode, RootSearchSchema } from './route';
 import { RouteByPath, RoutePaths } from './routeInfo';
 import { RegisteredRouter } from './router';
 import { LinkProps, UseLinkPropsOptions } from './useNavigate';
-import { Expand, NoInfer, NonNullableUpdater, PickRequired, Updater, WithoutEmpty } from './utils';
+import { Expand, NoInfer, NonNullableUpdater, PickRequired, StringLiteral, Updater, WithoutEmpty } from './utils';
 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;
@@ -26,22 +26,22 @@ export type RelativeToPathAutoComplete<AllPaths extends string, TFrom extends st
 ] ? `${TTo}${Join<RestPath>}` : never : (TFrom extends `/` ? never : SplitPaths extends [...Split<TFrom, false>, ...infer RestPath] ? Join<RestPath> extends {
     length: 0;
 } ? never : './' : never) | (TFrom extends `/` ? never : '../') | AllPaths;
-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> & {
+export type NavigateOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = RoutePaths<TRouteTree>, 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> & {
+export type ToOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = RoutePaths<TRouteTree>, 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> & {
+export type ToMaskOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TMaskFrom extends RoutePaths<TRouteTree> | string = RoutePaths<TRouteTree>, 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 = '', TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
+export type ToSubOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = RoutePaths<TRouteTree>, TTo extends string = '', TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
     to?: ToPathOption<TRouteTree, TFrom, TTo>;
     hash?: true | Updater<string>;
     state?: true | NonNullableUpdater<HistoryState>;
-    from?: TFrom;
+    from?: StringLiteral<TFrom>;
 } & CheckPath<TRouteTree, NoInfer<TResolved>, {}> & SearchParamOptions<TRouteTree, TFrom, TTo, TResolved> & PathParamOptions<TRouteTree, TFrom, TTo, TResolved>;
 type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo);
 type ParamVariant = 'PATH' | 'SEARCH';

package/build/types/useNavigate.d.ts

@@ -3,8 +3,9 @@ import { LinkOptions, NavigateOptions } from './link';
 import { AnyRoute } from './route';
 import { RoutePaths } from './routeInfo';
 import { RegisteredRouter } from './router';
-export declare function useNavigate<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDefaultFrom extends RoutePaths<TRouteTree> | string = string>(_defaultOpts?: {
-    from?: TDefaultFrom;
+import { StringLiteral } from './utils';
+export declare function useNavigate<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDefaultFrom extends RoutePaths<TRouteTree> | string = RoutePaths<TRouteTree>>(_defaultOpts?: {
+    from?: StringLiteral<TDefaultFrom>;
 }): <TFrom extends string | import("./routeInfo").ParseRoute<TRouteTree>["fullPath"] = TDefaultFrom, TTo extends string = "", TMaskFrom extends string | import("./routeInfo").ParseRoute<TRouteTree>["fullPath"] = TFrom, TMaskTo extends string = "">({ from, ...rest }: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
 export declare function Navigate<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''>(props: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): null;
 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>;

package/build/types/useParams.d.ts

@@ -1,7 +1,7 @@
 import { AnyRoute } from './route';
-import { RouteIds, RouteById, AllParams } from './routeInfo';
+import { RouteIds, RouteById } from './routeInfo';
 import { RegisteredRouter } from './router';
-import { StrictOrFrom } from './utils';
-export declare function useParams<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TDefaultSelected = AllParams<TRouteTree> & RouteById<TRouteTree, TFrom>['types']['allParams'], TSelected = TDefaultSelected>(opts: StrictOrFrom<TFrom> & {
-    select?: (search: TDefaultSelected) => TSelected;
+import { StrictOrFrom, GetTFrom } from './utils';
+export declare function useParams<TOpts extends StrictOrFrom<TFrom>, TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TFromInferred = GetTFrom<TOpts, TRouteTree>, TParams = RouteById<TRouteTree, TFromInferred>['types']['allParams'], TSelected = TParams>(opts: TOpts & {
+    select?: (params: TParams) => TSelected;
 }): TSelected;

package/build/types/useSearch.d.ts

@@ -1,7 +1,7 @@
 import { AnyRoute } from './route';
 import { RouteIds, RouteById } from './routeInfo';
 import { RegisteredRouter } from './router';
-import { StrictOrFrom } from './utils';
-export declare function useSearch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TSearch = RouteById<TRouteTree, TFrom>['types']['fullSearchSchema'], TSelected = TSearch>(opts: StrictOrFrom<TFrom> & {
+import { StrictOrFrom, GetTFrom } from './utils';
+export declare function useSearch<TOpts extends StrictOrFrom<TFrom>, TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TFromInferred = GetTFrom<TOpts, TRouteTree>, TSearch = RouteById<TRouteTree, TFromInferred>['types']['fullSearchSchema'], TSelected = TSearch>(opts: TOpts & {
     select?: (search: TSearch) => TSelected;
-}): TStrict extends true ? TSelected : TSelected | undefined;
+}): TSelected;

package/build/types/utils.d.ts

@@ -36,16 +36,18 @@ export declare function isPlainArray(value: unknown): boolean;
 export declare function deepEqual(a: any, b: any, partial?: boolean): boolean;
 export declare function useStableCallback<T extends (...args: any[]) => any>(fn: T): T;
 export declare function shallow<T>(objA: T, objB: T): boolean;
+export type StringLiteral<T> = T extends string ? string extends T ? string : T : never;
 export type StrictOrFrom<TFrom> = {
-    from: TFrom;
+    from: StringLiteral<TFrom> | TFrom;
     strict?: true;
 } | {
     from?: never;
     strict: false;
 };
-export declare function useRouteContext<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteContext = RouteById<TRouteTree, TFrom>['types']['allContext'], TSelected = TRouteContext>(opts: StrictOrFrom<TFrom> & {
+export type GetTFrom<T, TRouteTree extends AnyRoute> = T extends StrictOrFrom<infer TFrom extends RouteIds<TRouteTree>> ? TFrom : never;
+export declare function useRouteContext<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TRouteContext = RouteById<TRouteTree, TFrom>['types']['allContext'], TSelected = TRouteContext>(opts: StrictOrFrom<TFrom> & {
     select?: (search: TRouteContext) => TSelected;
-}): TStrict extends true ? TSelected : TSelected | undefined;
+}): TSelected;
 export declare const useLayoutEffect: typeof React.useLayoutEffect;
 export declare function escapeJSON(jsonString: string): string;
 export {};

package/build/umd/index.development.js

@@ -809,16 +809,22 @@
     const next = _next;
     const array = isPlainArray(prev) && isPlainArray(next);
     if (array || isPlainObject(prev) && isPlainObject(next)) {
-      const prevSize = array ? prev.length : Object.keys(prev).length;
+      const prevItems = array ? prev : Object.keys(prev);
+      const prevSize = prevItems.length;
       const nextItems = array ? next : Object.keys(next);
       const nextSize = nextItems.length;
       const copy = array ? [] : {};
       let equalItems = 0;
       for (let i = 0; i < nextSize; i++) {
         const key = array ? i : nextItems[i];
-        copy[key] = replaceEqualDeep(prev[key], next[key]);
-        if (copy[key] === prev[key] && prev[key] !== undefined) {
+        if (!array && prev[key] === undefined && next[key] === undefined && prevItems.includes(key)) {
+          copy[key] = undefined;
           equalItems++;
+        } else {
+          copy[key] = replaceEqualDeep(prev[key], next[key]);
+          if (copy[key] === prev[key] && prev[key] !== undefined) {
+            equalItems++;
+          }
         }
       }
       return prevSize === nextSize && equalItems === prevSize ? prev : copy;
@@ -1603,13 +1609,12 @@
     }
     useMatch = opts => {
       return useMatch({
-        ...opts,
+        select: opts?.select,
         from: this.id
       });
     };
     useRouteContext = opts => {
       return useMatch({
-        ...opts,
         from: this.id,
         select: d => opts?.select ? opts.select(d.context) : d.context
       });
@@ -2713,7 +2718,7 @@
             }
             const parentContext = parentMatch?.context ?? this.options.context ?? {};
             const pendingMs = route.options.pendingMs ?? this.options.defaultPendingMs;
-            const pendingPromise = new Promise(r => setTimeout(r, pendingMs));
+            const pendingPromise = typeof pendingMs === 'number' && pendingMs <= 0 ? Promise.resolve() : new Promise(r => setTimeout(r, pendingMs));
             const beforeLoadContext = (await route.options.beforeLoad?.({
               search: match.search,
               abortController,
@@ -2778,7 +2783,7 @@
           let didShowPending = false;
           const pendingMs = route.options.pendingMs ?? this.options.defaultPendingMs;
           const pendingMinMs = route.options.pendingMinMs ?? this.options.defaultPendingMinMs;
-          const shouldPending = !preload && pendingMs && (route.options.pendingComponent ?? this.options.defaultPendingComponent);
+          const shouldPending = !preload && typeof pendingMs === 'number' && (route.options.pendingComponent ?? this.options.defaultPendingComponent);
           const loaderContext = {
             params: match.params,
             deps: match.loaderDeps,
@@ -3362,8 +3367,7 @@
 
   function useNavigate(_defaultOpts) {
     const {
-      navigate,
-      buildLocation
+      navigate
     } = useRouter();
     const matchPathname = useMatch({
       strict: false,