@tanstack/react-router 1.65.0 → 1.67.0

package/dist/esm/searchMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { SearchMiddleware } from './route.js';
+export declare function retainSearchParams<TSearchSchema extends object>(keys: Array<keyof TSearchSchema>): SearchMiddleware<TSearchSchema>;

package/dist/esm/searchMiddleware.js

@@ -0,0 +1,15 @@
+function retainSearchParams(keys) {
+  return ({ search, next }) => {
+    const result = next(search);
+    keys.forEach((key) => {
+      if (!(key in result)) {
+        result[key] = search[key];
+      }
+    });
+    return result;
+  };
+}
+export {
+  retainSearchParams
+};
+//# sourceMappingURL=searchMiddleware.js.map

package/dist/esm/searchMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchMiddleware.js","sources":["../../src/searchMiddleware.ts"],"sourcesContent":["import type { SearchMiddleware } from './route'\n\nexport function retainSearchParams<TSearchSchema extends object>(\n  keys: Array<keyof TSearchSchema>,\n): SearchMiddleware<TSearchSchema> {\n  return ({ search, next }) => {\n    const result = next(search)\n    // add missing keys from search to result\n    keys.forEach((key) => {\n      if (!(key in result)) {\n        result[key] = search[key]\n      }\n    })\n    return result\n  }\n}\n"],"names":[],"mappings":"AAEO,SAAS,mBACd,MACiC;AACjC,SAAO,CAAC,EAAE,QAAQ,WAAW;AACrB,UAAA,SAAS,KAAK,MAAM;AAErB,SAAA,QAAQ,CAAC,QAAQ;AAChB,UAAA,EAAE,OAAO,SAAS;AACb,eAAA,GAAG,IAAI,OAAO,GAAG;AAAA,MAC1B;AAAA,IAAA,CACD;AACM,WAAA;AAAA,EAAA;AAEX;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/react-router",
-  "version": "1.65.0",
+  "version": "1.67.0",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/index.tsx

@@ -351,3 +351,5 @@ export type { Manifest, RouterManagedTag } from './manifest'
 
 export { createControlledPromise } from './utils'
 export type { ControlledPromise } from './utils'
+
+export { retainSearchParams } from './searchMiddleware'

package/src/route.ts

@@ -338,13 +338,20 @@ export interface UpdatableRouteOptions<
   preload?: boolean
   preloadStaleTime?: number
   preloadGcTime?: number
-  // Filter functions that can manipulate search params *before* they are passed to links and navigate
-  // calls that match this route.
+  search?: {
+    middlewares?: Array<
+      SearchMiddleware<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>
+    >
+  }
+  /** 
+  @deprecated Use search.middlewares instead
+  */
   preSearchFilters?: Array<
     SearchFilter<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>
   >
-  // Filter functions that can manipulate search params *after* they are passed to links and navigate
-  // calls that match this route.
+  /** 
+  @deprecated Use search.middlewares instead
+  */
   postSearchFilters?: Array<
     SearchFilter<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>
   >
@@ -556,6 +563,15 @@ export interface LoaderFnContext<
 
 export type SearchFilter<TInput, TResult = TInput> = (prev: TInput) => TResult
 
+export type SearchMiddlewareContext<TSearchSchema> = {
+  search: TSearchSchema
+  next: (newSearch: TSearchSchema) => TSearchSchema
+}
+
+export type SearchMiddleware<TSearchSchema> = (
+  ctx: SearchMiddlewareContext<TSearchSchema>,
+) => TSearchSchema
+
 export type ResolveId<
   TParentRoute,
   TCustomId extends string,

package/src/router.ts

@@ -51,6 +51,7 @@ import type {
   RouteComponent,
   RouteContextOptions,
   RouteMask,
+  SearchMiddleware,
 } from './route'
 import type {
   FullSearchSchema,
@@ -1428,39 +1429,86 @@ export class Router<
         leaveParams: opts.leaveParams,
       })
 
-      const preSearchFilters =
-        stayingMatches
-          ?.map((route) => route.options.preSearchFilters ?? [])
-          .flat()
-          .filter(Boolean) ?? []
-
-      const postSearchFilters =
-        stayingMatches
-          ?.map((route) => route.options.postSearchFilters ?? [])
-          .flat()
-          .filter(Boolean) ?? []
-
-      // Pre filters first
-      const preFilteredSearch = preSearchFilters.length
-        ? preSearchFilters.reduce((prev, next) => next(prev), fromSearch)
-        : fromSearch
-
-      // Then the link/navigate function
-      const destSearch =
-        dest.search === true
-          ? preFilteredSearch // Preserve resolvedFrom true
-          : dest.search
-            ? functionalUpdate(dest.search, preFilteredSearch) // Updater
-            : preSearchFilters.length
-              ? preFilteredSearch // Preserve resolvedFrom filters
-              : {}
-
-      // Then post filters
-      const postFilteredSearch = postSearchFilters.length
-        ? postSearchFilters.reduce((prev, next) => next(prev), destSearch)
-        : destSearch
-
-      let search = postFilteredSearch
+      const applyMiddlewares = () => {
+        const allMiddlewares =
+          stayingMatches?.reduce(
+            (acc, route) => {
+              let middlewares: Array<SearchMiddleware<any>> = []
+              if ('search' in route.options) {
+                if (route.options.search?.middlewares) {
+                  middlewares = route.options.search.middlewares
+                }
+              }
+              // TODO remove preSearchFilters and postSearchFilters in v2
+              else if (
+                route.options.preSearchFilters ||
+                route.options.postSearchFilters
+              ) {
+                const legacyMiddleware: SearchMiddleware<any> = ({
+                  search,
+                  next,
+                }) => {
+                  let nextSearch = search
+                  if (
+                    'preSearchFilters' in route.options &&
+                    route.options.preSearchFilters
+                  ) {
+                    nextSearch = route.options.preSearchFilters.reduce(
+                      (prev, next) => next(prev),
+                      search,
+                    )
+                  }
+                  const result = next(nextSearch)
+                  if (
+                    'postSearchFilters' in route.options &&
+                    route.options.postSearchFilters
+                  ) {
+                    return route.options.postSearchFilters.reduce(
+                      (prev, next) => next(prev),
+                      result,
+                    )
+                  }
+                  return result
+                }
+                middlewares = [legacyMiddleware]
+              }
+              return acc.concat(middlewares)
+            },
+            [] as Array<SearchMiddleware<any>>,
+          ) ?? []
+
+        // the chain ends here since `next` is not called
+        const final: SearchMiddleware<any> = ({ search }) => {
+          if (!dest.search) {
+            return {}
+          }
+          if (dest.search === true) {
+            return search
+          }
+          return functionalUpdate(dest.search, search)
+        }
+        allMiddlewares.push(final)
+
+        const applyNext = (index: number, currentSearch: any): any => {
+          // no more middlewares left, return the current search
+          if (index >= allMiddlewares.length) {
+            return currentSearch
+          }
+
+          const middleware = allMiddlewares[index]!
+
+          const next = (newSearch: any): any => {
+            return applyNext(index + 1, newSearch)
+          }
+
+          return middleware({ search: currentSearch, next })
+        }
+
+        // Start applying middlewares
+        return applyNext(0, fromSearch)
+      }
+
+      let search = applyMiddlewares()
 
       if (opts._includeValidateSearch) {
         matchedRoutesResult?.matchedRoutes.forEach((route) => {
@@ -1657,7 +1705,8 @@ export class Router<
       const parsed = parseHref(href, {})
       rest.to = parsed.pathname
       rest.search = this.options.parseSearch(parsed.search)
-      rest.hash = parsed.hash
+      // remove the leading `#` from the hash
+      rest.hash = parsed.hash.slice(1)
     }
 
     const location = this.buildLocation({

package/src/searchMiddleware.ts

@@ -0,0 +1,16 @@
+import type { SearchMiddleware } from './route'
+
+export function retainSearchParams<TSearchSchema extends object>(
+  keys: Array<keyof TSearchSchema>,
+): SearchMiddleware<TSearchSchema> {
+  return ({ search, next }) => {
+    const result = next(search)
+    // add missing keys from search to result
+    keys.forEach((key) => {
+      if (!(key in result)) {
+        result[key] = search[key]
+      }
+    })
+    return result
+  }
+}