RegExp Router

Copyexport class RegExpRouter<T> implements Router<T> {
  name: string = 'RegExpRouter'
  #middleware?: Record<string, Record<string, HandlerWithMetadata<T>[]>>
  #routes?: Record<string, Record<string, HandlerWithMetadata<T>[]>>
 
  constructor() {
    this.#middleware = { [METHOD_NAME_ALL]: Object.create(null) }
    this.#routes = { [METHOD_NAME_ALL]: Object.create(null) }
  }
  // ...
}

Copyfunction buildWildcardRegExp(path: string): RegExp {
  return (wildcardRegExpCache[path] ??= new RegExp(
    path === '*'
      ? ''
      : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) =>
          metaChar ? `\\${metaChar}` : '(?:|/.*)'
        )}$`
  ))
}

Copyfunction buildMatcherFromPreprocessedRoutes<T>(
  routes: [string, HandlerWithMetadata<T>[]][]
): Matcher<T> {
  const trie = new Trie()
  const handlerData: HandlerData<T>[] = []
  if (routes.length === 0) {
    return nullMatcher
  }

Copy    const groups: [string, string][] = [] // [mark, original string]
    for (let i = 0; ; ) {
      let replaced = false
      path = path.replace(/\{[^}]+\}/g, (m) => {
        const mark = `@\\${i}`
        groups[i] = [mark, m]
        i++
        replaced = true
        return mark
      })
      if (!replaced) {
        break
      }
    }

Copyfunction compareKey(a: string, b: string): number {
  if (a.length === 1) {
    return b.length === 1 ? (a < b ? -1 : 1) : -1
  }
  if (b.length === 1) {
    return 1
  }
 
  // wildcard
  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
    return 1
  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
    return -1
  }
 
  // label
  if (a === LABEL_REG_EXP_STR) {
    return 1
  } else if (b === LABEL_REG_EXP_STR) {
    return -1
  }
 
  return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length
}

CopybuildRegExpStr(): string {
  const childKeys = Object.keys(this.#children).sort(compareKey)
 
  const strList = childKeys.map((k) => {
    const c = this.#children[k]
    return (
      (typeof c.#varIndex === 'number'
        ? `(${k})@${c.#varIndex}`
        : regExpMetaChars.has(k)
          ? `\\${k}`
          : k) + c.buildRegExpStr()
    )
  })
 
  if (typeof this.#index === 'number') {
    strList.unshift(`#${this.#index}`)
  }
 
  if (strList.length === 0) {
    return ''
  }
  if (strList.length === 1) {
    return strList[0]
  }
 
  return '(?:' + strList.join('|') + ')'
}

Copylet wildcardRegExpCache: Record<string, RegExp> = Object.create(null)
function buildWildcardRegExp(path: string): RegExp {
  return (wildcardRegExpCache[path] ??= new RegExp(
    path === '*'
      ? ''
      : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) =>
          metaChar ? `\\${metaChar}` : '(?:|/.*)'
        )}$`
  ))
}

CopybuildRegExp(): [RegExp, ReplacementMap, ReplacementMap] {
  let regexp = this.#root.buildRegExpStr()
  if (regexp === '') {
    return [/^$/, [], []] // never match
  }
 
  let captureIndex = 0
  const indexReplacementMap: ReplacementMap = []
  const paramReplacementMap: ReplacementMap = []
 
  regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
    if (handlerIndex !== undefined) {
      indexReplacementMap[++captureIndex] = Number(handlerIndex)
      return '$()'
    }
    if (paramIndex !== undefined) {
      paramReplacementMap[Number(paramIndex)] = ++captureIndex
      return ''
    }
 
    return ''
  })
 
  return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap]
}

Copyexport function match<R extends Router<T>, T>(this: R, method: string, path: string): Result<T> {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const matchers: MatcherMap<T> = (this as any).buildAllMatchers()
 
  const match = ((method, path) => {
    const matcher = (matchers[method] || matchers[METHOD_NAME_ALL]) as Matcher<T>
 
    const staticMatch = matcher[2][path]
    if (staticMatch) {
      return staticMatch
    }

Copy  const match = path.match(matcher[0])
  if (!match) {
    return [[], emptyParam]
  }
 
  const index = match.indexOf('', 1)
  return [matcher[1][index], match]
}) as Router<T>['match']

Copyconst index = match.indexOf('', 1)
return [matcher[1][index], match]

Copyexport const buildInitParams: (params: {
  paths: string[]
}) => ConstructorParameters<typeof PreparedRegExpRouter> = ({ paths }) => {
  const RegExpRouterWithMatcherExport = class<T> extends RegExpRouter<T> {
    buildAndExportAllMatchers() {
      return this.buildAllMatchers()
    }
  }
  const router = new RegExpRouterWithMatcherExport<string>()
  for (const path of paths) {
    router.add(METHOD_NAME_ALL, path, path)
  }
 
  const matchers = router.buildAndExportAllMatchers()
  const all = matchers[METHOD_NAME_ALL] as Matcher<string>
 
  const relocateMap: RelocateMap = {}
  for (const path of paths) {
    if (path === '/*' || path === '*') {
      continue
    }
    all[1].forEach((list, i) => {
      list.forEach(([p, map]) => {
        if (p === path) {
          if (relocateMap[path]) {
            relocateMap[path][0][1] = {
              ...relocateMap[path][0][1],
              ...map,
            }
          } else {
            relocateMap[path] = [[[], map]]
          }
          if (relocateMap[path][0][0].findIndex((j) => j === i) === -1) {
            relocateMap[path][0][0].push(i)
          }
        }
      })
    })
    for (const path2 in all[2]) {
      all[2][path2][0].forEach(([p]) => {
        if (p === path) {
          relocateMap[path] ||= [[[]]]
          const value = path2 === path ? '' : path2
          if (relocateMap[path][0][0].findIndex((v) => v === value) === -1) {
            relocateMap[path][0][0].push(value)
          }
        }
      })
    }
  }
 
  for (let i = 0, len = all[1].length; i < len; i++) {
    all[1][i] = all[1][i] ? [] : (0 as unknown as HandlerData<string>)
  }
  for (const path in all[2]) {
    all[2][path][0] = []
  }
 
  return [matchers, relocateMap]
}

Copyexport const serializeInitParams: (
  params: ConstructorParameters<typeof PreparedRegExpRouter>
) => string = ([matchers, relocateMap]) => {
  // Embed the regular expression as a result of `toString()` so that it can be evaluated as JavaScript.
  const matchersStr = JSON.stringify(matchers, (_, value) =>
    value instanceof RegExp ? `##${value.toString()}##` : value
  ).replace(/"##(.+?)##"/g, (_, str) => str.replace(/\\\\/g, '\\'))
  const relocateMapStr = JSON.stringify(relocateMap)
  return `[${matchersStr},${relocateMapStr}]`
}

Copyadd(method: string, path: string, handler: T) {
  if (!this.#matchers[method]) {
    const all = this.#matchers[METHOD_NAME_ALL] as Matcher<T>
    const staticMap = {} as StaticMap<T>
    for (const key in all[2]) {
      staticMap[key] = [all[2][key][0].slice(), emptyParam] as Result<T>
    }
    this.#matchers[method] = [
      all[0],
      all[1].map((list) => (Array.isArray(list) ? list.slice() : 0)) as HandlerData<T>[],
      staticMap,
    ]
  }
 
  if (path === '/*' || path === '*') {
    const handlerData: [T, ParamIndexMap] = [handler, {}]
    if (method === METHOD_NAME_ALL) {
      for (const m in this.#matchers) {
        this.#addWildcard(m, handlerData)
      }
    } else {
      this.#addWildcard(method, handlerData)
    }
    return
  }
 
  const data = this.#relocateMap[path]
  if (!data) {
    throw new Error(`Path ${path} is not registered`)
  }
  for (const [indexes, map] of data) {
    if (method === METHOD_NAME_ALL) {
      for (const m in this.#matchers) {
        this.#addPath(m, path, handler, indexes, map)
      }
    } else {
      this.#addPath(method, path, handler, indexes, map)
    }
  }
}