Merge branch 'skirtles-code-static-path-perf' into app-build

Author: negezor

packages/router/src/matcher/index.ts

@@ -5,6 +5,7 @@ import {
   isRouteName,
 } from '../types'
 import { createRouterError, ErrorTypes, MatcherError } from '../errors'
+import { createMatcherTree } from './matcherTree'
 import { createRouteRecordMatcher, RouteRecordMatcher } from './pathMatcher'
 import { RouteRecordNormalized } from './types'
 
@@ -14,11 +15,9 @@ import type {
   _PathParserOptions,
 } from './pathParserRanker'
 
-import { comparePathParserScore } from './pathParserRanker'
-
 import { warn } from '../warning'
 import { assign, noop } from '../utils'
-import type { RouteRecordNameGeneric, _RouteRecordProps } from '../typed-routes'
+import type { RouteRecordName, _RouteRecordProps } from '../typed-routes'
 
 /**
  * Internal RouterMatcher
@@ -27,13 +26,13 @@ import type { RouteRecordNameGeneric, _RouteRecordProps } from '../typed-routes'
  */
 export interface RouterMatcher {
   addRoute: (record: RouteRecordRaw, parent?: RouteRecordMatcher) => () => void
-  removeRoute(matcher: RouteRecordMatcher): void
-  removeRoute(name: NonNullable<RouteRecordNameGeneric>): void
+  removeRoute: {
+    (matcher: RouteRecordMatcher): void
+    (name: RouteRecordName): void
+  }
   clearRoutes: () => void
   getRoutes: () => RouteRecordMatcher[]
-  getRecordMatcher: (
-    name: NonNullable<RouteRecordNameGeneric>
-  ) => RouteRecordMatcher | undefined
+  getRecordMatcher: (name: RouteRecordName) => RouteRecordMatcher | undefined
 
   /**
    * Resolves a location. Gives access to the route record that corresponds to the actual path as well as filling the corresponding params objects
@@ -58,18 +57,15 @@ export function createRouterMatcher(
   routes: Readonly<RouteRecordRaw[]>,
   globalOptions: PathParserOptions
 ): RouterMatcher {
-  // normalized ordered array of matchers
-  const matchers: RouteRecordMatcher[] = []
-  const matcherMap = new Map<
-    NonNullable<RouteRecordNameGeneric>,
-    RouteRecordMatcher
-  >()
+  // normalized ordered tree of matchers
+  const matcherTree = createMatcherTree()
+  const matcherMap = new Map<RouteRecordName, RouteRecordMatcher>()
   globalOptions = mergeOptions(
     { strict: false, end: true, sensitive: false } as PathParserOptions,
     globalOptions
   )
 
-  function getRecordMatcher(name: NonNullable<RouteRecordNameGeneric>) {
+  function getRecordMatcher(name: RouteRecordName) {
     return matcherMap.get(name)
   }
 
@@ -167,12 +163,6 @@ export function createRouterMatcher(
         }
       }
 
-      // Avoid adding a record that doesn't display anything. This allows passing through records without a component to
-      // not be reached and pass through the catch all route
-      if (isMatchable(matcher)) {
-        insertMatcher(matcher)
-      }
-
       if (mainNormalizedRecord.children) {
         const children = mainNormalizedRecord.children
         for (let i = 0; i < children.length; i++) {
@@ -192,6 +182,17 @@ export function createRouterMatcher(
       // if (parent && isAliasRecord(originalRecord)) {
       //   parent.children.push(originalRecord)
       // }
+
+      // Avoid adding a record that doesn't display anything. This allows passing through records without a component to
+      // not be reached and pass through the catch all route
+      if (
+        (matcher.record.components &&
+          Object.keys(matcher.record.components).length) ||
+        matcher.record.name ||
+        matcher.record.redirect
+      ) {
+        insertMatcher(matcher)
+      }
     }
 
     return originalMatcher
@@ -202,35 +203,29 @@ export function createRouterMatcher(
       : noop
   }
 
-  function removeRoute(
-    matcherRef: NonNullable<RouteRecordNameGeneric> | RouteRecordMatcher
-  ) {
+  function removeRoute(matcherRef: RouteRecordName | RouteRecordMatcher) {
     if (isRouteName(matcherRef)) {
       const matcher = matcherMap.get(matcherRef)
       if (matcher) {
         matcherMap.delete(matcherRef)
-        matchers.splice(matchers.indexOf(matcher), 1)
+        matcherTree.remove(matcher)
         matcher.children.forEach(removeRoute)
         matcher.alias.forEach(removeRoute)
       }
     } else {
-      const index = matchers.indexOf(matcherRef)
-      if (index > -1) {
-        matchers.splice(index, 1)
-        if (matcherRef.record.name) matcherMap.delete(matcherRef.record.name)
-        matcherRef.children.forEach(removeRoute)
-        matcherRef.alias.forEach(removeRoute)
-      }
+      matcherTree.remove(matcherRef)
+      if (matcherRef.record.name) matcherMap.delete(matcherRef.record.name)
+      matcherRef.children.forEach(removeRoute)
+      matcherRef.alias.forEach(removeRoute)
     }
   }
 
   function getRoutes() {
-    return matchers
+    return matcherTree.toArray()
   }
 
   function insertMatcher(matcher: RouteRecordMatcher) {
-    const index = findInsertionIndex(matcher, matchers)
-    matchers.splice(index, 0, matcher)
+    matcherTree.add(matcher)
     // only add the original record to the name map
     if (matcher.record.name && !isAliasRecord(matcher))
       matcherMap.set(matcher.record.name, matcher)
@@ -303,7 +298,7 @@ export function createRouterMatcher(
         )
       }
 
-      matcher = matchers.find(m => m.re.test(path))
+      matcher = matcherTree.find(path)
       // matcher should have a value after the loop
 
       if (matcher) {
@@ -316,7 +311,7 @@ export function createRouterMatcher(
       // match by name or path of current route
       matcher = currentLocation.name
         ? matcherMap.get(currentLocation.name)
-        : matchers.find(m => m.re.test(currentLocation.path))
+        : matcherTree.find(currentLocation.path)
       if (!matcher)
         throw createRouterError<MatcherError>(ErrorTypes.MATCHER_NOT_FOUND, {
           location,
@@ -351,7 +346,6 @@ export function createRouterMatcher(
   routes.forEach(route => addRoute(route))
 
   function clearRoutes() {
-    matchers.length = 0
     matcherMap.clear()
   }
 
@@ -560,79 +554,4 @@ function checkMissingParamsInAbsolutePath(
   }
 }
 
-/**
- * Performs a binary search to find the correct insertion index for a new matcher.
- *
- * Matchers are primarily sorted by their score. If scores are tied then we also consider parent/child relationships,
- * with descendants coming before ancestors. If there's still a tie, new routes are inserted after existing routes.
- *
- * @param matcher - new matcher to be inserted
- * @param matchers - existing matchers
- */
-function findInsertionIndex(
-  matcher: RouteRecordMatcher,
-  matchers: RouteRecordMatcher[]
-) {
-  // First phase: binary search based on score
-  let lower = 0
-  let upper = matchers.length
-
-  while (lower !== upper) {
-    const mid = (lower + upper) >> 1
-    const sortOrder = comparePathParserScore(matcher, matchers[mid])
-
-    if (sortOrder < 0) {
-      upper = mid
-    } else {
-      lower = mid + 1
-    }
-  }
-
-  // Second phase: check for an ancestor with the same score
-  const insertionAncestor = getInsertionAncestor(matcher)
-
-  if (insertionAncestor) {
-    upper = matchers.lastIndexOf(insertionAncestor, upper - 1)
-
-    if (__DEV__ && upper < 0) {
-      // This should never happen
-      warn(
-        `Finding ancestor route "${insertionAncestor.record.path}" failed for "${matcher.record.path}"`
-      )
-    }
-  }
-
-  return upper
-}
-
-function getInsertionAncestor(matcher: RouteRecordMatcher) {
-  let ancestor: RouteRecordMatcher | undefined = matcher
-
-  while ((ancestor = ancestor.parent)) {
-    if (
-      isMatchable(ancestor) &&
-      comparePathParserScore(matcher, ancestor) === 0
-    ) {
-      return ancestor
-    }
-  }
-
-  return
-}
-
-/**
- * Checks if a matcher can be reachable. This means if it's possible to reach it as a route. For example, routes without
- * a component, or name, or redirect, are just used to group other routes.
- * @param matcher
- * @param matcher.record record of the matcher
- * @returns
- */
-function isMatchable({ record }: RouteRecordMatcher): boolean {
-  return !!(
-    record.name ||
-    (record.components && Object.keys(record.components).length) ||
-    record.redirect
-  )
-}
-
 export type { PathParserOptions, _PathParserOptions }