@tanstack/router-core 0.0.1-beta.147 → 0.0.1-beta.149

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/router-core",
   "author": "Tanner Linsley",
-  "version": "0.0.1-beta.147",
+  "version": "0.0.1-beta.149",
   "license": "MIT",
   "repository": "tanstack/router",
   "homepage": "https://tanstack.com/router",
@@ -43,7 +43,7 @@
     "tiny-invariant": "^1.3.1",
     "tiny-warning": "^1.0.3",
     "@gisatcz/cross-package-react-context": "^0.2.0",
-    "@tanstack/react-store": "0.0.1-beta.147"
+    "@tanstack/react-store": "0.0.1-beta.149"
   },
   "scripts": {
     "build": "rollup --config rollup.config.js",

package/src/router.ts

@@ -631,11 +631,15 @@ export class Router<
     let routeParams: AnyPathParams = {}
 
     let foundRoute = this.flatRoutes.find((route) => {
-      const matchedParams = matchPathname(this.basepath, pathname, {
-        to: route.fullPath,
-        caseSensitive:
-          route.options.caseSensitive ?? this.options.caseSensitive,
-      })
+      const matchedParams = matchPathname(
+        this.basepath,
+        trimPathRight(pathname),
+        {
+          to: route.fullPath,
+          caseSensitive:
+            route.options.caseSensitive ?? this.options.caseSensitive,
+        },
+      )
 
       if (matchedParams) {
         routeParams = matchedParams
@@ -830,76 +834,84 @@ export class Router<
   ) => {
     this.cleanMatches()
 
+    if (!opts?.preload) {
+      resolvedMatches.forEach((match) => {
+        // Update each match with its latest url data
+        this.setRouteMatch(match.id, (s) => ({
+          ...s,
+          routeSearch: match.routeSearch,
+          search: match.search,
+          routeContext: match.routeContext,
+          context: match.context,
+          error: match.error,
+          paramsError: match.paramsError,
+          searchError: match.searchError,
+          params: match.params,
+        }))
+      })
+    }
+
     let firstBadMatchIndex: number | undefined
 
     // Check each match middleware to see if the route can be accessed
     try {
-      await Promise.all(
-        resolvedMatches.map(async (match, index) => {
-          const route = this.getRoute(match.routeId)
+      for (const [index, match] of resolvedMatches.entries()) {
+        const route = this.getRoute(match.routeId)
 
-          if (!opts?.preload) {
-            // Update each match with its latest url data
-            this.setRouteMatch(match.id, (s) => ({
-              ...s,
-              routeSearch: match.routeSearch,
-              search: match.search,
-              routeContext: match.routeContext,
-              context: match.context,
-              error: match.error,
-              paramsError: match.paramsError,
-              searchError: match.searchError,
-              params: match.params,
-            }))
+        const handleError = (
+          err: any,
+          handler: undefined | ((err: any) => void),
+        ) => {
+          firstBadMatchIndex = firstBadMatchIndex ?? index
+          handler = handler || route.options.onError
+
+          if (isRedirect(err)) {
+            throw err
           }
 
-          const handleError = (
-            err: any,
-            handler: undefined | ((err: any) => void),
-          ) => {
-            firstBadMatchIndex = firstBadMatchIndex ?? index
-            handler = handler || route.options.onError
+          try {
+            handler?.(err)
+          } catch (errorHandlerErr) {
+            err = errorHandlerErr
 
-            if (isRedirect(err)) {
-              throw err
+            if (isRedirect(errorHandlerErr)) {
+              throw errorHandlerErr
             }
+          }
 
-            try {
-              handler?.(err)
-            } catch (errorHandlerErr) {
-              err = errorHandlerErr
+          this.setRouteMatch(match.id, (s) => ({
+            ...s,
+            error: err,
+            status: 'error',
+            updatedAt: Date.now(),
+          }))
+        }
 
-              if (isRedirect(errorHandlerErr)) {
-                throw errorHandlerErr
-              }
-            }
+        if (match.paramsError) {
+          handleError(match.paramsError, route.options.onParseParamsError)
+        }
 
-            this.setRouteMatch(match.id, (s) => ({
-              ...s,
-              error: err,
-              status: 'error',
-              updatedAt: Date.now(),
-            }))
-          }
+        if (match.searchError) {
+          handleError(match.searchError, route.options.onValidateSearchError)
+        }
 
-          if (match.paramsError) {
-            handleError(match.paramsError, route.options.onParseParamsError)
-          }
+        let didError = false
 
-          if (match.searchError) {
-            handleError(match.searchError, route.options.onValidateSearchError)
-          }
+        try {
+          await route.options.beforeLoad?.({
+            ...match,
+            preload: !!opts?.preload,
+          })
+        } catch (err) {
+          handleError(err, route.options.onBeforeLoadError)
+          didError = true
+        }
 
-          try {
-            await route.options.beforeLoad?.({
-              ...match,
-              preload: !!opts?.preload,
-            })
-          } catch (err) {
-            handleError(err, route.options.onBeforeLoadError)
-          }
-        }),
-      )
+        // If we errored, do not run the next matches' middleware
+        if (didError) {
+          break
+        }
+      }
     } catch (err) {
       if (!opts?.preload) {
         this.navigate(err as any)