@tanstack/router-core 1.171.25 → 1.171.26

package/src/path.ts

@@ -112,13 +112,25 @@ export function resolvePath({
   trailingSlash = 'never',
   cache,
 }: ResolvePathOptions) {
-  const isBase = to === '.'
-  const isAbsolute = to.startsWith('/')
+  if (to.includes('//')) {
+    to = cleanPath(to)
+  }
+
+  if (to.startsWith('/')) {
+    if (to.length === 1 || trailingSlash === 'preserve') {
+      return to
+    }
+    if (trailingSlash === 'always') {
+      return to.endsWith('/') ? to : `${to}/`
+    }
+    return to.endsWith('/') ? to.slice(0, -1) : to
+  }
 
+  const isBase = to === '.'
   let key
   if (cache) {
     // `trailingSlash` is static per router, so it doesn't need to be part of the cache key
-    key = isAbsolute ? to : isBase ? base : base + '\0' + to
+    key = isBase ? base : base + '\0' + to
     const cached = cache.get(key)
     if (cached) return cached
   }
@@ -126,9 +138,10 @@ export function resolvePath({
   let baseSegments: Array<string>
   if (isBase) {
     baseSegments = base.split('/')
-  } else if (isAbsolute) {
-    baseSegments = to.split('/')
   } else {
+    if (base.includes('//')) {
+      base = cleanPath(base)
+    }
     baseSegments = base.split('/')
     while (baseSegments.length > 1 && last(baseSegments) === '') {
       baseSegments.pop()
@@ -171,7 +184,8 @@ export function resolvePath({
     }
   }
 
-  const result = cleanPath(baseSegments.join('/')) || '/'
+  const joined = baseSegments.join('/')
+  const result = (isBase ? cleanPath(joined) : joined) || '/'
   if (key && cache) cache.set(key, result)
   return result
 }

package/src/router.ts

@@ -22,7 +22,6 @@ import {
   processRouteTree,
 } from './new-process-route-tree'
 import {
-  cleanPath,
   compileDecodeCharMap,
   interpolatePath,
   resolvePath,
@@ -1469,7 +1468,7 @@ export class RouterCore<
   resolvePathWithBase = (from: string, path: string) => {
     return resolvePath({
       base: from,
-      to: path.includes('//') ? cleanPath(path) : path,
+      to: path,
       trailingSlash: this.options.trailingSlash,
       cache: this.resolvePathCache,
     })
@@ -1892,28 +1891,19 @@ export class RouterCore<
         dest.unsafeRelative === 'path'
           ? currentLocation.pathname
           : (dest.from ?? lightweightResult[1 /* fullPath */])
-      const destTo = dest.to ? `${dest.to}` : undefined
 
       // From search should always use the current location
       const fromSearch = lightweightResult[2 /* search */]
       // Same with params. It can't hurt to provide as many as possible
-      const fromParams = Object.assign(
-        Object.create(null),
-        lightweightResult[3 /* params */],
-      )
-
-      const isAbsoluteTo = destTo?.charCodeAt(0) === 47
-      const sourcePath = isAbsoluteTo
-        ? '/'
-        : this.resolvePathWithBase(defaultedFromPath, '.')
+      const fromParams = lightweightResult[3 /* params */]
 
-      // Resolve the destination. Absolute destinations don't need the source path.
-      const nextTo = destTo
-        ? this.resolvePathWithBase(sourcePath, destTo)
-        : sourcePath
+      const nextTo = this.resolvePathWithBase(
+        defaultedFromPath,
+        dest.to ? `${dest.to}` : '.',
+      )
 
       // Resolve the next params
-      const nextParams = resolveNextParams(dest.params, fromParams)
+      let nextParams = resolveNextParams(dest.params, fromParams)
 
       const destRoute = this.routesByPath[
         trimPathRight(nextTo) as keyof typeof this.routesByPath
@@ -1945,6 +1935,9 @@ export class RouterCore<
           const fn =
             route.options.params?.stringify ?? route.options.stringifyParams
           if (fn) {
+            if (nextParams === fromParams) {
+              nextParams = Object.assign(Object.create(null), nextParams)
+            }
             try {
               Object.assign(nextParams, fn(nextParams))
             } catch {
@@ -2043,7 +2036,9 @@ export class RouterCore<
             : {}
 
       // Replace the equal deep
-      nextState = replaceEqualDeep(currentLocation.state, nextState)
+      if (dest.state) {
+        nextState = replaceEqualDeep(currentLocation.state, nextState)
+      }
 
       // Create the full path of the location
       const fullPath = `${nextPathname}${searchStr}${hashStr}`
@@ -2777,24 +2772,22 @@ function applySearchMiddleware(
     }
 
     const routeValidateSearch = routeOptions.validateSearch
-    if (routeValidateSearch) {
+    if (includeValidateSearch && routeValidateSearch) {
       const validate: SearchMiddleware<any> = ({ search, next, meta }) => {
         const result = next(search)
-        if (includeValidateSearch) {
-          try {
-            const validated = validateSearch(routeValidateSearch, result) as any
-
-            if (meta && validated) {
-              for (const key in validated) {
-                if (!(key in result)) {
-                  ;(meta.defaulted ||= new Map()).set(key, validated[key])
-                }
+        try {
+          const validated = validateSearch(routeValidateSearch, result) as any
+
+          if (meta && validated) {
+            for (const key in validated) {
+              if (!(key in result)) {
+                ;(meta.defaulted ||= new Map()).set(key, validated[key])
               }
             }
-            return { ...result, ...validated }
-          } catch {
-            // ignore errors here because they are already handled in matchRoutes
           }
+          return { ...result, ...validated }
+        } catch {
+          // ignore errors here because they are already handled in matchRoutes
         }
         return result
       }
@@ -2864,11 +2857,14 @@ function resolveNextParams(
   spec: unknown,
   base: Record<string, unknown>,
 ): Record<string, unknown> {
-  return spec === false || spec === null
-    ? Object.create(null)
-    : (spec ?? true) === true
-      ? base
-      : Object.assign(base, functionalUpdate(spec as any, base))
+  if (spec === false || spec === null) {
+    return Object.create(null)
+  }
+  if ((spec ?? true) === true) {
+    return base
+  }
+  const next = Object.assign(Object.create(null), base)
+  return Object.assign(next, functionalUpdate(spec as any, next))
 }
 
 function extractStrictParams(