only abort previous transition when the new one is validated.

Author: yyx990803

src/router/index.js

@@ -46,6 +46,7 @@ export default class Router {
     this._started = false
     this._currentRoute = {}
     this._currentTransition = null
+    this._previousTransition = null
     this._notFoundHandler = null
     this._beforeEachHook = null
 

src/router/internal.js

@@ -124,11 +124,6 @@ export default function (Vue, Router) {
     let prevRoute = this._currentRoute
     let prevTransition = this._currentTransition
 
-    // abort ongoing transition
-    if (prevTransition && path !== prevTransition.to.path) {
-      prevTransition.aborted = true
-    }
-
     // do nothing if going to the same route.
     // the route only changes when a transition successfully
     // reaches activation; we don't need to do anything
@@ -140,8 +135,9 @@ export default function (Vue, Router) {
 
     // construct new route and transition context
     let route = new Route(path, this)
-    let transition = this._currentTransition =
-      new RouteTransition(this, route, prevRoute)
+    let transition = new RouteTransition(this, route, prevRoute)
+    this._prevTransition = prevTransition
+    this._currentTransition = transition
 
     if (!this.app) {
       // initial render
@@ -175,15 +171,22 @@ export default function (Vue, Router) {
   }
 
   /**
-   * Switch the current route to a new one.
+   * Set current to the new transition.
    * This is called by the transition object when the
    * validation of a route has succeeded.
    *
-   * @param {Route} route
+   * @param {RouteTransition} transition
    */
 
-  Router.prototype._updateRoute = function (route) {
-    this._currentRoute = route
+  Router.prototype._onTransitionValidated = function (transition) {
+    // now that this one is validated, we can abort
+    // the previous transition.
+    let prevTransition = this._prevTransition
+    if (prevTransition) {
+      prevTransition.aborted = true
+    }
+    // set current route
+    let route = this._currentRoute = transition.to
     // update route context for all children
     if (this.app.$route !== route) {
       this.app.$route = route

src/transition.js

@@ -4,10 +4,6 @@ import {
   canActivate, canDeactivate, canReuse
 } from './pipeline'
 
-// avoid infinite redirect loops on error
-const MAX_ERROR_REDIRECTS = 10
-let errorCount = 0
-
 /**
  * A RouteTransition object manages the pipeline of a
  * router-view switching process. This is also the object
@@ -48,14 +44,15 @@ export default class RouteTransition {
 
   /**
    * Abort current transition and return to previous location.
-   *
-   * @param {Boolean} back
    */
 
-  abort (back) {
+  abort () {
     if (!this.aborted) {
       this.aborted = true
-      if (back !== false) {
+      // if the root path throws an error during validation
+      // on initial load, it gets caught in an infinite loop.
+      let abortingOnLoad = !this.from.path && this.to.path === '/'
+      if (!abortingOnLoad) {
         this.router.replace(this.from.path || '/')
       }
     }
@@ -133,7 +130,7 @@ export default class RouteTransition {
           // 3. Activation phase
 
           // Update router current route
-          transition.router._updateRoute(transition.to)
+          transition.router._onTransitionValidated(transition)
 
           // trigger reuse for all reused views
           reuseQueue && reuseQueue.forEach(function (view) {
@@ -213,16 +210,10 @@ export default class RouteTransition {
 
     // handle errors
     let onError = (err) => {
-      // prevent infinite error redirects
-      errorCount++
-      let canGoBack = errorCount < MAX_ERROR_REDIRECTS
-      if (!canGoBack) {
-        errorCount = 0
-      }
       // cleanup indicates an after-activation hook,
       // so instead of aborting we just let the transition
       // finish.
-      cleanup ? next() : abort(canGoBack)
+      cleanup ? next() : abort()
       if (err && !transition.router._suppress) {
         warn('Uncaught error during transition: ')
         throw err instanceof Error ? err : new Error(err)