expose redirectedFrom on $route

Author: yyx990803

flow/declarations.js

@@ -66,6 +66,7 @@ declare type Route = {
   params: StringHash;
   fullPath: string;
   matched: Array<RouteRecord>;
+  redirectedFrom?: string;
 }
 
 declare type Matcher = (location: RawLocation, current?: Route) => Route;

src/components/link.js

@@ -23,7 +23,7 @@ export default {
     const current = this.$route
     const to = normalizeLocation(this.to, current, this.append)
     const resolved = router.match(to)
-    const fullPath = resolved.fullPath
+    const fullPath = resolved.redirectedFrom || resolved.fullPath
     const base = router.history.base
     const href = base ? cleanPath(base + fullPath) : fullPath
     const classes = {}

src/create-matcher.js

@@ -21,47 +21,62 @@ const regexpCompileCache: {
 export function createMatcher (routes: Array<RouteConfig>): Matcher {
   const { pathMap, nameMap } = createRouteMap(routes)
 
-  function match (raw: RawLocation, currentRoute?: Route): Route {
+  function match (
+    raw: RawLocation,
+    currentRoute?: Route,
+    redirectedFrom?: Location
+  ): Route {
     const location = normalizeLocation(raw, currentRoute)
     const { name } = location
 
     if (name) {
       const record = nameMap[name]
       if (record) {
         location.path = fillParams(record.path, location.params, `named route "${name}"`)
-        return createRouteContext(record, location)
+        return createRouteContext(record, location, redirectedFrom)
       }
     } else if (location.path) {
       location.params = {}
       for (const path in pathMap) {
         if (matchRoute(path, location.params, location.path)) {
-          return createRouteContext(pathMap[path], location)
+          return createRouteContext(pathMap[path], location, redirectedFrom)
         }
       }
     }
     // no match
     return createRouteContext(null, location)
   }
 
-  function createRouteContext (record: ?RouteRecord, location: Location): Route {
+  function createRouteContext (
+    record: ?RouteRecord,
+    location: Location,
+    redirectedFrom?: Location
+  ): Route {
     if (record && record.redirect) {
-      return redirect(record, location)
+      return redirect(record, redirectedFrom || location)
     }
     if (record && record.matchAs) {
       return alias(record, location, record.matchAs)
     }
-    return Object.freeze({
+    const route: Route = {
       name: location.name,
       path: location.path || '/',
       hash: location.hash || '',
       query: location.query || {},
       params: location.params || {},
       fullPath: getFullPath(location),
       matched: record ? formatMatch(record) : []
-    })
+    }
+    if (redirectedFrom) {
+      route.redirectedFrom = getFullPath(redirectedFrom)
+    }
+    return Object.freeze(route)
   }
 
-  function redirect (record: RouteRecord, location: Location): Route {
+  function redirect (
+    record: RouteRecord,
+    location: Location
+  ): Route {
     const { query, hash, params } = location
     const { redirect } = record
     const name = redirect && typeof redirect === 'object' && redirect.name
@@ -75,7 +90,7 @@ export function createMatcher (routes: Array<RouteConfig>): Matcher {
         query,
         hash,
         params
-      })
+      }, undefined, location)
     } else if (typeof redirect === 'string') {
       // 1. resolve relative redirect
       const rawPath = resolveRecordPath(redirect, record)
@@ -87,14 +102,18 @@ export function createMatcher (routes: Array<RouteConfig>): Matcher {
         path,
         query,
         hash
-      })
+      }, undefined, location)
     } else {
       warn(`invalid redirect option: ${JSON.stringify(redirect)}`)
       return createRouteContext(null, location)
     }
   }
 
-  function alias (record: RouteRecord, location: Location, matchAs: string): Route {
+  function alias (
+    record: RouteRecord,
+    location: Location,
+    matchAs: string
+  ): Route {
     const aliasedPath = fillParams(matchAs, location.params, `aliased route with path "${matchAs}"`)
     const aliasedMatch = match({
       _normalized: true,
@@ -112,7 +131,11 @@ export function createMatcher (routes: Array<RouteConfig>): Matcher {
   return match
 }
 
-function matchRoute (path: string, params: Object, pathname: string): boolean {
+function matchRoute (
+  path: string,
+  params: Object,
+  pathname: string
+): boolean {
   let keys, regexp
   const hit = regexpCache[path]
   if (hit) {
@@ -140,16 +163,11 @@ function matchRoute (path: string, params: Object, pathname: string): boolean {
   return true
 }
 
-function formatMatch (record: ?RouteRecord): Array<RouteRecord> {
-  const res = []
-  while (record) {
-    res.unshift(record)
-    record = record.parent
-  }
-  return res
-}
-
-function fillParams (path: string, params: ?Object, routeMsg: string): string {
+function fillParams (
+  path: string,
+  params: ?Object,
+  routeMsg: string
+): string {
   try {
     const filler =
       regexpCompileCache[path] ||
@@ -161,6 +179,15 @@ function fillParams (path: string, params: ?Object, routeMsg: string): string {
   }
 }
 
+function formatMatch (record: ?RouteRecord): Array<RouteRecord> {
+  const res = []
+  while (record) {
+    res.unshift(record)
+    record = record.parent
+  }
+  return res
+}
+
 function resolveRecordPath (path: string, record: RouteRecord): string {
   return resolvePath(path, record.parent ? record.parent.path : '/', true)
 }

test/e2e/specs/redirect.js

@@ -5,12 +5,12 @@ module.exports = {
       .waitForElementVisible('#app', 1000)
       .assert.count('li a', 6)
       // assert correct href with base
-      .assert.attributeContains('li:nth-child(1) a', 'href', '/redirect/foo')
-      .assert.attributeContains('li:nth-child(2) a', 'href', '/redirect/foo?foo=bar')
-      .assert.attributeContains('li:nth-child(3) a', 'href', '/redirect/bar')
-      .assert.attributeContains('li:nth-child(4) a', 'href', '/redirect/baz')
-      .assert.attributeContains('li:nth-child(5) a', 'href', '/redirect/with-params/123')
-      .assert.attributeContains('li:nth-child(6) a', 'href', '/redirect/')
+      .assert.attributeContains('li:nth-child(1) a', 'href', '/redirect/relative-redirect')
+      .assert.attributeContains('li:nth-child(2) a', 'href', '/redirect/relative-redirect?foo=bar')
+      .assert.attributeContains('li:nth-child(3) a', 'href', '/redirect/absolute-redirect')
+      .assert.attributeContains('li:nth-child(4) a', 'href', '/redirect/named-redirect')
+      .assert.attributeContains('li:nth-child(5) a', 'href', '/redirect/redirect-with-params/123')
+      .assert.attributeContains('li:nth-child(6) a', 'href', '/not-found')
 
       .assert.containsText('.view', 'default')