feat: unify api name and avoid unnecessary recalculation

packages/client/src/components/RouteLink.ts

@@ -1,7 +1,7 @@
 import { computed, defineComponent, h } from 'vue'
 import type { SlotsType, VNode } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
-import { resolveRoutePath } from '../router/index.js'
+import { resolveRouteFullPath } from '../router/index.js'
 
 /**
  * Forked from https://github.com/vuejs/router/blob/941b2131e80550009e5221d4db9f366b1fea3fd5/packages/router/src/RouterLink.ts#L293
@@ -91,7 +91,7 @@ export const RouteLink = defineComponent({
     const path = computed(() =>
       props.to.startsWith('#') || props.to.startsWith('?')
         ? props.to
-        : `${__VUEPRESS_BASE__}${resolveRoutePath(props.to, route.path).substring(1)}`,
+        : `${__VUEPRESS_BASE__}${resolveRouteFullPath(props.to, route.path).substring(1)}`,
     )
 
     return () =>

packages/client/src/router/index.ts

@@ -2,4 +2,5 @@ export type { Router, RouteLocationNormalizedLoaded } from 'vue-router'
 export { useRoute, useRouter } from 'vue-router'
 
 export * from './resolveRoute.js'
+export * from './resolveRouteFullPath.js'
 export * from './resolveRoutePath.js'

packages/client/src/router/resolveRoute.ts

@@ -1,4 +1,4 @@
-import { resolveRouteFullPath } from '@vuepress/shared'
+import { resolveRoutePathInfo } from '@vuepress/shared'
 import { routes } from '../internal/routes.js'
 import type { Route, RouteMeta } from '../types/index.js'
 import { resolveRoutePath } from './resolveRoutePath.js'
@@ -16,16 +16,25 @@ export const resolveRoute = <T extends RouteMeta = RouteMeta>(
   path: string,
   currentPath?: string,
 ): ResolvedRoute<T> => {
-  const routePath = resolveRoutePath(path, currentPath)
-  const [pathname] = resolveRouteFullPath(routePath)
-  const route = routes.value[pathname] ?? {
-    ...routes.value['/404.html'],
-    notFound: true,
+  // get only the pathname from the path
+  const [pathname, hashAndQueries] = resolveRoutePathInfo(path)
+
+  // resolve the route path
+  const routePath = resolveRoutePath(pathname, currentPath)
+  const routeFullPath = routePath + hashAndQueries
+
+  // the route not found
+  if (!routes.value[routePath]) {
+    return {
+      ...routes.value['/404.html'],
+      path: routeFullPath,
+      notFound: true,
+    } as ResolvedRoute<T>
   }
 
   return {
-    path: routePath,
+    ...routes.value[routePath],
+    path: routeFullPath,
     notFound: false,
-    ...route,
   } as ResolvedRoute<T>
 }

packages/client/src/router/resolveRouteFullPath.ts

@@ -0,0 +1,14 @@
+import { resolveRoutePathInfo } from '@vuepress/shared'
+import { resolveRoutePath } from './resolveRoutePath.js'
+
+/**
+ * Resolve route full path with given raw path
+ */
+export const resolveRouteFullPath = (
+  path: string,
+  currentPath?: string,
+): string => {
+  const [pathname, hashAndQueries] = resolveRoutePathInfo(path)
+
+  return resolveRoutePath(pathname, currentPath) + hashAndQueries
+}

packages/client/src/router/resolveRoutePath.ts

@@ -1,29 +1,34 @@
-import { normalizeRoutePath, resolveRouteFullPath } from '@vuepress/shared'
+import { normalizeRoutePath } from '@vuepress/shared'
 import { redirects, routes } from '../internal/routes.js'
 
 /**
  * Resolve route path with given raw path
  */
 export const resolveRoutePath = (
-  path: string,
+  pathname: string,
   currentPath?: string,
 ): string => {
   // normalized path
-  const normalizedPath = normalizeRoutePath(path, currentPath)
-  const [normalizedPathname, queryAndHash] =
-    resolveRouteFullPath(normalizedPath)
+  const normalizedRoutePath = normalizeRoutePath(pathname, currentPath)
 
-  if (routes.value[normalizedPathname]) return normalizedPath
+  // check if the normalized path is in routes
+  if (routes.value[normalizedRoutePath]) return normalizedRoutePath
 
-  // encoded path
-  const encodedPathname = encodeURI(normalizedPathname)
-  if (routes.value[encodedPathname]) return encodeURI(normalizedPath)
+  // check encoded path
+  const encodedRoutePath = encodeURI(normalizedRoutePath)
 
-  // redirected path
-  const redirectPath =
-    redirects.value[normalizedPathname] || redirects.value[encodedPathname]
-  if (redirectPath) return redirectPath + queryAndHash
+  if (routes.value[encodedRoutePath]) {
+    return encodedRoutePath
+  }
 
-  // fallback to the normalized path
-  return normalizedPath
+  // check redirected path with normalized path and encoded path
+  const redirectedRoutePath =
+    redirects.value[normalizedRoutePath] || redirects.value[encodedRoutePath]
+
+  if (redirectedRoutePath) {
+    return redirectedRoutePath
+  }
+
+  // default to normalized route path
+  return normalizedRoutePath
 }

packages/shared/src/utils/index.ts

@@ -15,5 +15,5 @@ export * from './removeLeadingSlash.js'
 export * from './resolveHeadIdentifier.js'
 export * from './resolveLocalePath.js'
 export * from './resolveRoutePathFromUrl.js'
-export * from './resolveRouteFullPath.js'
+export * from './resolveRoutePathInfo.js'
 export * from './typeGuards.js'

packages/shared/src/utils/normalizeRoutePath.ts

@@ -1,22 +1,20 @@
 import { inferRoutePath } from './inferRoutePath.js'
-import { resolveRouteFullPath } from './resolveRouteFullPath.js'
 
 const FAKE_HOST = 'http://.'
 
 /**
- * Normalize the given path to the final route path
+ * Normalize the given pathname path to the final route path
  */
-export const normalizeRoutePath = (path: string, current?: string): string => {
-  if (!path.startsWith('/') && current) {
+export const normalizeRoutePath = (
+  pathname: string,
+  current?: string,
+): string => {
+  if (!pathname.startsWith('/') && current) {
     // the relative path should be resolved against the current path
     const loc = current.slice(0, current.lastIndexOf('/'))
 
-    const { pathname, search, hash } = new URL(`${loc}/${path}`, FAKE_HOST)
-
-    return inferRoutePath(pathname) + search + hash
+    return inferRoutePath(new URL(`${loc}/${pathname}`, FAKE_HOST).pathname)
   }
 
-  const [pathname, queryAndHash] = resolveRouteFullPath(path)
-
-  return inferRoutePath(pathname) + queryAndHash
+  return inferRoutePath(pathname)
 }

packages/shared/src/utils/resolveRoutePathInfo.ts

@@ -0,0 +1,12 @@
+const SPLIT_CHAR_REGEXP = /(#|\?)/
+
+/**
+ * Extract pathname / hash and queries from a full route path
+ */
+export const resolveRoutePathInfo = (
+  path: string,
+): [pathname: string, hashAndQueries: string] => {
+  const [pathname, ...hashAndQueries] = path.split(SPLIT_CHAR_REGEXP)
+
+  return [pathname, hashAndQueries.join('')]
+}

packages/shared/tests/normalizeRoutePath.spec.ts

@@ -204,42 +204,3 @@ describe('should normalize clean paths correctly', () => {
     }),
   )
 })
-
-describe('should normalize paths with query correctly', () => {
-  testCases
-    .map(([[path, current], expected]) => [
-      [`${path}?foo=bar`, current],
-      `${expected}?foo=bar`,
-    ])
-    .forEach(([[path, current], expected]) =>
-      it(`${current ? `"${current}"-` : ''}"${path}" -> "${expected}"`, () => {
-        expect(normalizeRoutePath(path, current)).toBe(expected)
-      }),
-    )
-})
-
-describe('should normalize paths with hash correctly', () => {
-  testCases
-    .map(([[path, current], expected]) => [
-      [`${path}#foobar`, current],
-      `${expected}#foobar`,
-    ])
-    .map(([[path, current], expected]) =>
-      it(`${current ? `"${current}"-` : ''}"${path}" -> "${expected}"`, () => {
-        expect(normalizeRoutePath(path, current)).toBe(expected)
-      }),
-    )
-})
-
-describe('should normalize paths with query and hash correctly', () => {
-  testCases
-    .map(([[path, current], expected]) => [
-      [`${path}?foo=1&bar=2#foobar`, current],
-      `${expected}?foo=1&bar=2#foobar`,
-    ])
-    .map(([[path, current], expected]) =>
-      it(`${current ? `"${current}"-` : ''}"${path}" -> "${expected}"`, () => {
-        expect(normalizeRoutePath(path, current)).toBe(expected)
-      }),
-    )
-})

packages/shared/tests/resolveRouteFullPath.spec.ts → packages/shared/tests/resolveRoutePathInfo.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { resolveRouteFullPath } from '../src/index.js'
+import { resolveRoutePathInfo } from '../src/index.js'
 
 const testCases: [string, [string, string]][] = [
   ['/a/b/c/', ['/a/b/c/', '']],
@@ -12,10 +12,10 @@ const testCases: [string, [string, string]][] = [
   ['/a/index.html?a=1#b', ['/a/index.html', '?a=1#b']],
 ]
 
-describe('should resolve route pathname correctly', () => {
+describe('should resolve route path info correctly', () => {
   testCases.forEach(([source, expected]) => {
     it(`${source} -> ${expected}`, () => {
-      expect(resolveRouteFullPath(source)).toEqual(expected)
+      expect(resolveRoutePathInfo(source)).toEqual(expected)
     })
   })
 })