wip: route-pattern trie + benchmarks

packages/route-pattern/bench/comparison.bench.ts

@@ -11,6 +11,7 @@ import { bench, describe } from 'vitest'
 import FindMyWay from 'find-my-way'
 import { match } from 'path-to-regexp'
 import { ArrayMatcher, TrieMatcher } from '../src'
+import { TrieMatcher as TrieMatcher2 } from '../src/lib2'
 
 type Syntax = 'route-pattern' | 'find-my-way' | 'path-to-regexp'
 
@@ -24,6 +25,11 @@ const matchers: Array<{
   syntax: Syntax
   createMatcher: () => Matcher
 }> = [
+  {
+    name: 'route-pattern/lib2/trie',
+    syntax: 'route-pattern',
+    createMatcher: () => new TrieMatcher2(),
+  },
   {
     name: 'route-pattern/trie',
     syntax: 'route-pattern',

packages/route-pattern/package.json

@@ -36,6 +36,7 @@
     "@ark/attest": "^0.49.0",
     "@types/node": "catalog:",
     "@typescript/native-preview": "catalog:",
+    "dedent": "^1.7.1",
     "find-my-way": "^9.1.0",
     "path-to-regexp": "^8.2.0",
     "typescript": "catalog:",

packages/route-pattern/src/lib2/errors.test.ts

@@ -0,0 +1,23 @@
+import dedent from 'dedent'
+import { describe, expect, it } from 'vitest'
+
+import { ParseError } from './errors.ts'
+
+describe('ParseError', () => {
+  it('exposes type, source, and index properties', () => {
+    let error = new ParseError('unmatched (', 'foo(bar', 3)
+    expect(error.type).toBe('unmatched (')
+    expect(error.source).toBe('foo(bar')
+    expect(error.index).toBe(3)
+  })
+
+  it('shows caret under the problematic index', () => {
+    let error = new ParseError('unmatched (', 'api/(v:major', 4)
+    expect(error.toString()).toBe(dedent`
+      ParseError: unmatched (
+
+      api/(v:major
+          ^
+    `)
+  })
+})

packages/route-pattern/src/lib2/errors.ts

@@ -0,0 +1,18 @@
+type ParseErrorType = 'unmatched (' | 'unmatched )' | 'missing variable name' | 'dangling escape'
+
+export class ParseError extends Error {
+  type: ParseErrorType
+  source: string
+  index: number
+
+  constructor(type: ParseErrorType, source: string, index: number) {
+    let underline = ' '.repeat(index) + '^'
+    let message = `${type}\n\n${source}\n${underline}`
+
+    super(message)
+    this.name = 'ParseError'
+    this.type = type
+    this.source = source
+    this.index = index
+  }
+}

packages/route-pattern/src/lib2/es2025.ts

@@ -0,0 +1,5 @@
+/**
+ * Backport of [RegExp.escape](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/escape)
+ */
+export const RegExp_escape = (string: string): string =>
+  string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')

packages/route-pattern/src/lib2/index.ts

@@ -0,0 +1,2 @@
+export { TrieMatcher } from './matchers/index.ts'
+export { ParseError } from './errors.ts'

packages/route-pattern/src/lib2/matchers/index.ts

@@ -0,0 +1,2 @@
+export type { Matcher } from './matcher.ts'
+export { TrieMatcher } from './trie/index.ts'

packages/route-pattern/src/lib2/matchers/matcher.ts

@@ -0,0 +1,10 @@
+import type * as RoutePattern from '../route-pattern/index.ts'
+
+export type Params = Record<string, string | undefined>
+
+export type Matcher<data> = {
+  add: (pattern: RoutePattern.AST, data: data) => void
+  match: (url: URL) => { params: Params; data: data } | null
+  matchAll: (url: URL) => Array<{ params: Params; data: data }>
+  size: number
+}

packages/route-pattern/src/lib2/matchers/trie/index.ts

@@ -0,0 +1 @@
+export { TrieMatcher } from './matcher.ts'

packages/route-pattern/src/lib2/matchers/trie/matcher.ts

@@ -0,0 +1,37 @@
+import * as RoutePattern from '../../route-pattern/index.ts'
+import { Trie, type Match } from './trie.ts'
+import * as Rank from './rank.ts'
+
+export class TrieMatcher<data> {
+  #trie: Trie<data> = new Trie()
+  #size: number = 0
+
+  add(pattern: string | RoutePattern.AST, data: data) {
+    pattern = typeof pattern === 'string' ? RoutePattern.parse(pattern) : pattern
+    this.#trie.insert(pattern, data)
+    this.#size += 1
+  }
+
+  match(url: URL) {
+    let best: Match<data> | null = null
+    for (let match of this.#trie.search(url)) {
+      if (best === null || Rank.lessThan(match.rank, best.rank)) {
+        best = match
+      }
+    }
+    return best ? { params: best.params, data: best.data } : null
+  }
+
+  matchAll(url: URL) {
+    let matches = []
+    for (let match of this.#trie.search(url)) {
+      matches.push(match)
+    }
+    matches.sort((a, b) => Rank.compare(a.rank, b.rank))
+    return matches
+  }
+
+  get size() {
+    return this.#size
+  }
+}

packages/route-pattern/src/lib2/matchers/trie/rank.ts

@@ -0,0 +1,28 @@
+import * as RoutePattern from '../../route-pattern/index.ts'
+
+type Rank = {
+  hierarchical: Array<string>
+  search: RoutePattern.Search.Constraints
+}
+
+export function lessThan(a: Rank, b: Rank): boolean {
+  return compare(a, b) === -1
+}
+
+export function compare(a: Rank, b: Rank): number {
+  let hierarchical = compareHierarchical(a.hierarchical, b.hierarchical)
+  if (hierarchical !== 0) return hierarchical
+  return RoutePattern.Search.compare(a.search, b.search)
+}
+
+function compareHierarchical(a: Rank['hierarchical'], b: Rank['hierarchical']): -1 | 0 | 1 {
+  for (let i = 0; i < a.length; i++) {
+    let segmentA = a[i]
+    let segmentB = b[i]
+    if (segmentA < segmentB) return -1
+    if (segmentA > segmentB) return 1
+  }
+  if (a.length < b.length) return -1
+  if (a.length > b.length) return 1
+  return 0
+}