refactor: rename matcher to resolver

Author: posva

packages/router/src/experimental/router.ts

@@ -27,8 +27,8 @@ import type {
   NEW_LocationResolved,
   NEW_MatcherRecord,
   NEW_MatcherRecordRaw,
-  NEW_RouterMatcher,
-} from '../new-route-resolver/matcher'
+  NEW_RouterResolver,
+} from '../new-route-resolver/resolver'
 import {
   parseQuery as originalParseQuery,
   stringifyQuery as originalStringifyQuery,
@@ -51,7 +51,6 @@ import type {
   RouteLocationAsRelative,
   RouteLocationAsRelativeTyped,
   RouteLocationAsString,
-  RouteLocationGeneric,
   RouteLocationNormalized,
   RouteLocationNormalizedLoaded,
   RouteLocationRaw,
@@ -191,7 +190,7 @@ export interface EXPERIMENTAL_RouterOptions<
    * Matcher to use to resolve routes.
    * @experimental
    */
-  matcher: NEW_RouterMatcher<NEW_MatcherRecordRaw, TMatcherRecord>
+  matcher: NEW_RouterResolver<NEW_MatcherRecordRaw, TMatcherRecord>
 }
 
 /**
@@ -407,6 +406,9 @@ export interface EXPERIMENTAL_RouteRecordRaw extends NEW_MatcherRecordRaw {
 
 // TODO: is it worth to have 2 types for the undefined values?
 export interface EXPERIMENTAL_RouteRecordNormalized extends NEW_MatcherRecord {
+  /**
+   * Arbitrary data attached to the record.
+   */
   meta: RouteMeta
 }
 
@@ -468,7 +470,7 @@ export function experimental_createRouter(
       | EXPERIMENTAL_RouteRecordRaw,
     route?: EXPERIMENTAL_RouteRecordRaw
   ) {
-    let parent: Parameters<(typeof matcher)['addRoute']>[1] | undefined
+    let parent: Parameters<(typeof matcher)['addMatcher']>[1] | undefined
     let rawRecord: EXPERIMENTAL_RouteRecordRaw
 
     if (isRouteName(parentOrRoute)) {
@@ -486,20 +488,20 @@ export function experimental_createRouter(
       rawRecord = parentOrRoute
     }
 
-    const addedRecord = matcher.addRoute(
+    const addedRecord = matcher.addMatcher(
       normalizeRouteRecord(rawRecord),
       parent
     )
 
     return () => {
-      matcher.removeRoute(addedRecord)
+      matcher.removeMatcher(addedRecord)
     }
   }
 
   function removeRoute(name: NonNullable<RouteRecordNameGeneric>) {
     const recordMatcher = matcher.getMatcher(name)
     if (recordMatcher) {
-      matcher.removeRoute(recordMatcher)
+      matcher.removeMatcher(recordMatcher)
     } else if (__DEV__) {
       warn(`Cannot remove non-existent route "${String(name)}"`)
     }
@@ -1219,7 +1221,7 @@ export function experimental_createRouter(
 
     addRoute,
     removeRoute,
-    clearRoutes: matcher.clearRoutes,
+    clearRoutes: matcher.clearMatchers,
     hasRoute,
     getRoutes,
     resolve,

packages/router/src/matcher/index.ts

@@ -14,10 +14,13 @@ import type {
   _PathParserOptions,
 } from './pathParserRanker'
 
-import { comparePathParserScore } from './pathParserRanker'
+import {
+  comparePathParserScore,
+  PATH_PARSER_OPTIONS_DEFAULTS,
+} from './pathParserRanker'
 
 import { warn } from '../warning'
-import { assign, noop } from '../utils'
+import { assign, mergeOptions, noop } from '../utils'
 import type { RouteRecordNameGeneric, _RouteRecordProps } from '../typed-routes'
 
 /**
@@ -64,8 +67,8 @@ export function createRouterMatcher(
     NonNullable<RouteRecordNameGeneric>,
     RouteRecordMatcher
   >()
-  globalOptions = mergeOptions(
-    { strict: false, end: true, sensitive: false } as PathParserOptions,
+  globalOptions = mergeOptions<PathParserOptions>(
+    PATH_PARSER_OPTIONS_DEFAULTS,
     globalOptions
   )
 
@@ -429,7 +432,7 @@ export function normalizeRouteRecord(
  * components. Also accept a boolean for components.
  * @param record
  */
-function normalizeRecordProps(
+export function normalizeRecordProps(
   record: RouteRecordRaw
 ): Record<string, _RouteRecordProps> {
   const propsObject = {} as Record<string, _RouteRecordProps>
@@ -472,18 +475,6 @@ function mergeMetaFields(matched: MatcherLocation['matched']) {
   )
 }
 
-function mergeOptions<T extends object>(
-  defaults: T,
-  partialOptions: Partial<T>
-): T {
-  const options = {} as T
-  for (const key in defaults) {
-    options[key] = key in partialOptions ? partialOptions[key]! : defaults[key]
-  }
-
-  return options
-}
-
 type ParamKey = RouteRecordMatcher['keys'][number]
 
 function isSameParam(a: ParamKey, b: ParamKey): boolean {
@@ -521,7 +512,7 @@ function checkSameParams(a: RouteRecordMatcher, b: RouteRecordMatcher) {
  * @param mainNormalizedRecord - RouteRecordNormalized
  * @param parent - RouteRecordMatcher
  */
-function checkChildMissingNameWithEmptyPath(
+export function checkChildMissingNameWithEmptyPath(
   mainNormalizedRecord: RouteRecordNormalized,
   parent?: RouteRecordMatcher
 ) {

packages/router/src/matcher/pathParserRanker.ts

@@ -367,3 +367,8 @@ function isLastScoreNegative(score: PathParser['score']): boolean {
   const last = score[score.length - 1]
   return score.length > 0 && last[last.length - 1] < 0
 }
+export const PATH_PARSER_OPTIONS_DEFAULTS: PathParserOptions = {
+  strict: false,
+  end: true,
+  sensitive: false,
+}

packages/router/src/new-route-resolver/index.ts

@@ -1 +1 @@
-export { createCompiledMatcher } from './matcher'
+export { createCompiledMatcher } from './resolver'

packages/router/src/new-route-resolver/matcher-location.ts

@@ -1,5 +1,5 @@
 import type { LocationQueryRaw } from '../query'
-import type { MatcherName } from './matcher'
+import type { MatcherName } from './resolver'
 
 /**
  * Generic object of params that can be passed to a matcher.

packages/router/src/new-route-resolver/matcher-pattern.ts

@@ -1,4 +1,4 @@
-import { decode, MatcherQueryParams } from './matcher'
+import { decode, MatcherQueryParams } from './resolver'
 import { EmptyParams, MatcherParamsFormatted } from './matcher-location'
 import { miss } from './matchers/errors'
 

packages/router/src/new-route-resolver/matcher-resolve.spec.ts

@@ -1,6 +1,5 @@
 import { createRouterMatcher, normalizeRouteRecord } from '../matcher'
 import { RouteComponent, RouteRecordRaw, MatcherLocation } from '../types'
-import { MatcherLocationNormalizedLoose } from '../../__tests__/utils'
 import { defineComponent } from 'vue'
 import { START_LOCATION_NORMALIZED } from '../location'
 import { describe, expect, it } from 'vitest'
@@ -10,7 +9,8 @@ import {
   MatcherLocationRaw,
   NEW_MatcherRecordRaw,
   NEW_LocationResolved,
-} from './matcher'
+  NEW_MatcherRecord,
+} from './resolver'
 import { PathParams, tokensToParser } from '../matcher/pathParserRanker'
 import { tokenizePath } from '../matcher/pathTokenizer'
 import { miss } from './matchers/errors'
@@ -63,22 +63,23 @@ function compileRouteRecord(
 
 describe('RouterMatcher.resolve', () => {
   mockWarn()
-  type Matcher = ReturnType<typeof createRouterMatcher>
+  type Matcher = ReturnType<typeof createCompiledMatcher>
   type MatcherResolvedLocation = ReturnType<Matcher['resolve']>
 
-  const START_LOCATION: NEW_LocationResolved = {
+  const START_LOCATION: MatcherResolvedLocation = {
     name: Symbol('START'),
-    fullPath: '/',
-    path: '/',
     params: {},
+    path: '/',
+    fullPath: '/',
     query: {},
     hash: '',
     matched: [],
+    // meta: {},
   }
 
   function isMatcherLocationResolved(
     location: unknown
-  ): location is NEW_LocationResolved {
+  ): location is NEW_LocationResolved<NEW_MatcherRecord> {
     return !!(
       location &&
       typeof location === 'object' &&
@@ -95,16 +96,16 @@ describe('RouterMatcher.resolve', () => {
     toLocation: MatcherLocationRaw,
     expectedLocation: Partial<MatcherResolvedLocation>,
     fromLocation:
-      | NEW_LocationResolved
+      | NEW_LocationResolved<NEW_MatcherRecord>
       | Exclude<MatcherLocationRaw, string>
       | `/${string}` = START_LOCATION
   ) {
     const records = (Array.isArray(record) ? record : [record]).map(
       (record): NEW_MatcherRecordRaw => compileRouteRecord(record)
     )
-    const matcher = createCompiledMatcher()
+    const matcher = createCompiledMatcher<NEW_MatcherRecord>()
     for (const record of records) {
-      matcher.addRoute(record)
+      matcher.addMatcher(record)
     }
 
     const resolved: MatcherResolvedLocation = {
@@ -137,60 +138,6 @@ describe('RouterMatcher.resolve', () => {
     })
   }
 
-  function _assertRecordMatch(
-    record: RouteRecordRaw | RouteRecordRaw[],
-    location: MatcherLocationRaw,
-    resolved: Partial<MatcherLocationNormalizedLoose>,
-    start: MatcherLocation = START_LOCATION_NORMALIZED
-  ) {
-    record = Array.isArray(record) ? record : [record]
-    const matcher = createRouterMatcher(record, {})
-
-    if (!('meta' in resolved)) {
-      resolved.meta = record[0].meta || {}
-    }
-
-    if (!('name' in resolved)) {
-      resolved.name = undefined
-    }
-
-    // add location if provided as it should be the same value
-    if ('path' in location && !('path' in resolved)) {
-      resolved.path = location.path
-    }
-
-    if ('redirect' in record) {
-      throw new Error('not handled')
-    } else {
-      // use one single record
-      if (!resolved.matched) resolved.matched = record.map(normalizeRouteRecord)
-      // allow passing an expect.any(Array)
-      else if (Array.isArray(resolved.matched))
-        resolved.matched = resolved.matched.map(m => ({
-          ...normalizeRouteRecord(m as any),
-          aliasOf: m.aliasOf,
-        }))
-    }
-
-    // allows not passing params
-    resolved.params =
-      resolved.params || ('params' in location ? location.params : {})
-
-    const startCopy: MatcherLocation = {
-      ...start,
-      matched: start.matched.map(m => ({
-        ...normalizeRouteRecord(m),
-        aliasOf: m.aliasOf,
-      })) as MatcherLocation['matched'],
-    }
-
-    // make matched non enumerable
-    Object.defineProperty(startCopy, 'matched', { enumerable: false })
-
-    const result = matcher.resolve(location, startCopy)
-    expect(result).toEqual(resolved)
-  }
-
   /**
    *
    * @param record - Record or records we are testing the matcher against

packages/router/src/new-route-resolver/matcher.spec.ts

@@ -3,15 +3,15 @@ import {
   createCompiledMatcher,
   NO_MATCH_LOCATION,
   pathEncoded,
-} from './matcher'
+} from './resolver'
 import {
   MatcherPatternParams_Base,
   MatcherPatternPath,
   MatcherPatternQuery,
   MatcherPatternPathStatic,
   MatcherPatternPathDynamic,
 } from './matcher-pattern'
-import { NEW_MatcherRecord } from './matcher'
+import { NEW_MatcherRecord } from './resolver'
 import { miss } from './matchers/errors'
 import { EmptyParams } from './matcher-location'
 
@@ -133,25 +133,25 @@ describe('RouterMatcher', () => {
   describe('adding and removing', () => {
     it('add static path', () => {
       const matcher = createCompiledMatcher()
-      matcher.addRoute(EMPTY_PATH_ROUTE)
+      matcher.addMatcher(EMPTY_PATH_ROUTE)
     })
 
     it('adds dynamic path', () => {
       const matcher = createCompiledMatcher()
-      matcher.addRoute(USER_ID_ROUTE)
+      matcher.addMatcher(USER_ID_ROUTE)
     })
 
     it('removes static path', () => {
       const matcher = createCompiledMatcher()
-      matcher.addRoute(EMPTY_PATH_ROUTE)
-      matcher.removeRoute(EMPTY_PATH_ROUTE)
+      matcher.addMatcher(EMPTY_PATH_ROUTE)
+      matcher.removeMatcher(EMPTY_PATH_ROUTE)
       // Add assertions to verify the route was removed
     })
 
     it('removes dynamic path', () => {
       const matcher = createCompiledMatcher()
-      matcher.addRoute(USER_ID_ROUTE)
-      matcher.removeRoute(USER_ID_ROUTE)
+      matcher.addMatcher(USER_ID_ROUTE)
+      matcher.removeMatcher(USER_ID_ROUTE)
       // Add assertions to verify the route was removed
     })
   })

packages/router/src/new-route-resolver/matcher.test-d.ts

@@ -2,15 +2,15 @@ import { describe, expectTypeOf, it } from 'vitest'
 import {
   NEW_LocationResolved,
   NEW_MatcherRecordRaw,
-  NEW_RouterMatcher,
-} from './matcher'
+  NEW_RouterResolver,
+} from './resolver'
 import { EXPERIMENTAL_RouteRecordNormalized } from '../experimental/router'
 
 describe('Matcher', () => {
   type TMatcherRecordRaw = NEW_MatcherRecordRaw
   type TMatcherRecord = EXPERIMENTAL_RouteRecordNormalized
 
-  const matcher: NEW_RouterMatcher<TMatcherRecordRaw, TMatcherRecord> =
+  const matcher: NEW_RouterResolver<TMatcherRecordRaw, TMatcherRecord> =
     {} as any
 
   describe('matcher.resolve()', () => {

packages/router/src/new-route-resolver/matchers/test-utils.ts

@@ -4,7 +4,7 @@ import {
   MatcherPatternQuery,
   MatcherPatternParams_Base,
 } from '../matcher-pattern'
-import { NEW_MatcherRecord } from '../matcher'
+import { NEW_MatcherRecord } from '../resolver'
 import { miss } from './errors'
 
 export const ANY_PATH_PATTERN_MATCHER: MatcherPatternPath<{