bluera-knowledge 0.14.0 → 0.14.2

package/tests/fixtures/corpus/oss-repos/hono/src/router/reg-exp-router/node.ts

@@ -1,159 +0,0 @@
-const LABEL_REG_EXP_STR = '[^/]+'
-const ONLY_WILDCARD_REG_EXP_STR = '.*'
-const TAIL_WILDCARD_REG_EXP_STR = '(?:|/.*)'
-export const PATH_ERROR = Symbol()
-
-export type ParamAssocArray = [string, number][]
-export interface Context {
-  varIndex: number
-}
-
-const regExpMetaChars = new Set('.\\+*[^]$()')
-
-/**
- * Sort order:
- * 1. literal
- * 2. special pattern (e.g. :label{[0-9]+})
- * 3. common label pattern (e.g. :label)
- * 4. wildcard
- */
-function 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
-}
-
-export class Node {
-  index?: number
-  varIndex?: number
-  children: Record<string, Node> = Object.create(null)
-
-  insert(
-    tokens: readonly string[],
-    index: number,
-    paramMap: ParamAssocArray,
-    context: Context,
-    pathErrorCheckOnly: boolean
-  ): void {
-    if (tokens.length === 0) {
-      if (this.index !== undefined) {
-        throw PATH_ERROR
-      }
-      if (pathErrorCheckOnly) {
-        return
-      }
-
-      this.index = index
-      return
-    }
-
-    const [token, ...restTokens] = tokens
-    const pattern =
-      token === '*'
-        ? restTokens.length === 0
-          ? ['', '', ONLY_WILDCARD_REG_EXP_STR] // '*' matches to all the trailing paths
-          : ['', '', LABEL_REG_EXP_STR]
-        : token === '/*'
-          ? ['', '', TAIL_WILDCARD_REG_EXP_STR] // '/path/to/*' is /\/path\/to(?:|/.*)$
-          : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/)
-
-    let node
-    if (pattern) {
-      const name = pattern[1]
-      let regexpStr = pattern[2] || LABEL_REG_EXP_STR
-      if (name && pattern[2]) {
-        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, '(?:') // (a|b) => (?:a|b)
-        if (/\((?!\?:)/.test(regexpStr)) {
-          // prefix(?:a|b) is allowed, but prefix(a|b) is not
-          throw PATH_ERROR
-        }
-      }
-
-      node = this.children[regexpStr]
-      if (!node) {
-        if (
-          Object.keys(this.children).some(
-            (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-          )
-        ) {
-          throw PATH_ERROR
-        }
-        if (pathErrorCheckOnly) {
-          return
-        }
-        node = this.children[regexpStr] = new Node()
-        if (name !== '') {
-          node.varIndex = context.varIndex++
-        }
-      }
-      if (!pathErrorCheckOnly && name !== '') {
-        paramMap.push([name, node.varIndex as number])
-      }
-    } else {
-      node = this.children[token]
-      if (!node) {
-        if (
-          Object.keys(this.children).some(
-            (k) =>
-              k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-          )
-        ) {
-          throw PATH_ERROR
-        }
-        if (pathErrorCheckOnly) {
-          return
-        }
-        node = this.children[token] = new Node()
-      }
-    }
-
-    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly)
-  }
-
-  buildRegExpStr(): 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('|') + ')'
-  }
-}

package/tests/fixtures/corpus/oss-repos/hono/src/router/reg-exp-router/router.ts

@@ -1,274 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import type { ParamIndexMap, Result, Router } from '../../router'
-import {
-  MESSAGE_MATCHER_IS_ALREADY_BUILT,
-  METHOD_NAME_ALL,
-  UnsupportedPathError,
-} from '../../router'
-import { checkOptionalParameter } from '../../utils/url'
-import { PATH_ERROR } from './node'
-import type { ParamAssocArray } from './node'
-import { Trie } from './trie'
-
-type HandlerData<T> = [T, ParamIndexMap][]
-type StaticMap<T> = Record<string, Result<T>>
-type Matcher<T> = [RegExp, HandlerData<T>[], StaticMap<T>]
-type HandlerWithMetadata<T> = [T, number] // [handler, paramCount]
-
-const emptyParam: string[] = []
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const nullMatcher: Matcher<any> = [/^$/, [], Object.create(null)]
-
-let wildcardRegExpCache: Record<string, RegExp> = Object.create(null)
-function buildWildcardRegExp(path: string): RegExp {
-  return (wildcardRegExpCache[path] ??= new RegExp(
-    path === '*'
-      ? ''
-      : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) =>
-          metaChar ? `\\${metaChar}` : '(?:|/.*)'
-        )}$`
-  ))
-}
-
-function clearWildcardRegExpCache() {
-  wildcardRegExpCache = Object.create(null)
-}
-
-function buildMatcherFromPreprocessedRoutes<T>(
-  routes: [string, HandlerWithMetadata<T>[]][]
-): Matcher<T> {
-  const trie = new Trie()
-  const handlerData: HandlerData<T>[] = []
-  if (routes.length === 0) {
-    return nullMatcher
-  }
-
-  const routesWithStaticPathFlag = routes
-    .map(
-      (route) => [!/\*|\/:/.test(route[0]), ...route] as [boolean, string, HandlerWithMetadata<T>[]]
-    )
-    .sort(([isStaticA, pathA], [isStaticB, pathB]) =>
-      isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
-    )
-
-  const staticMap: StaticMap<T> = Object.create(null)
-  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i]
-    if (pathErrorCheckOnly) {
-      staticMap[path] = [handlers.map(([h]) => [h, Object.create(null)]), emptyParam]
-    } else {
-      j++
-    }
-
-    let paramAssoc: ParamAssocArray
-    try {
-      paramAssoc = trie.insert(path, j, pathErrorCheckOnly)
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e
-    }
-
-    if (pathErrorCheckOnly) {
-      continue
-    }
-
-    handlerData[j] = handlers.map(([h, paramCount]) => {
-      const paramIndexMap: ParamIndexMap = Object.create(null)
-      paramCount -= 1
-      for (; paramCount >= 0; paramCount--) {
-        const [key, value] = paramAssoc[paramCount]
-        paramIndexMap[key] = value
-      }
-      return [h, paramIndexMap]
-    })
-  }
-
-  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp()
-  for (let i = 0, len = handlerData.length; i < len; i++) {
-    for (let j = 0, len = handlerData[i].length; j < len; j++) {
-      const map = handlerData[i][j]?.[1]
-      if (!map) {
-        continue
-      }
-      const keys = Object.keys(map)
-      for (let k = 0, len = keys.length; k < len; k++) {
-        map[keys[k]] = paramReplacementMap[map[keys[k]]]
-      }
-    }
-  }
-
-  const handlerMap: HandlerData<T>[] = []
-  // using `in` because indexReplacementMap is a sparse array
-  for (const i in indexReplacementMap) {
-    handlerMap[i] = handlerData[indexReplacementMap[i]]
-  }
-
-  return [regexp, handlerMap, staticMap] as Matcher<T>
-}
-
-function findMiddleware<T>(
-  middleware: Record<string, T[]> | undefined,
-  path: string
-): T[] | undefined {
-  if (!middleware) {
-    return undefined
-  }
-
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path)) {
-      return [...middleware[k]]
-    }
-  }
-
-  return undefined
-}
-
-export 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) }
-  }
-
-  add(method: string, path: string, handler: T) {
-    const { middleware, routes } = this
-
-    if (!middleware || !routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT)
-    }
-
-    if (!middleware[method]) {
-      ;[middleware, routes].forEach((handlerMap) => {
-        handlerMap[method] = Object.create(null)
-        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
-          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]]
-        })
-      })
-    }
-
-    if (path === '/*') {
-      path = '*'
-    }
-
-    const paramCount = (path.match(/\/:/g) || []).length
-
-    if (/\*$/.test(path)) {
-      const re = buildWildcardRegExp(path)
-      if (method === METHOD_NAME_ALL) {
-        Object.keys(middleware).forEach((m) => {
-          middleware[m][path] ||=
-            findMiddleware(middleware[m], path) ||
-            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
-            []
-        })
-      } else {
-        middleware[method][path] ||=
-          findMiddleware(middleware[method], path) ||
-          findMiddleware(middleware[METHOD_NAME_ALL], path) ||
-          []
-      }
-      Object.keys(middleware).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(middleware[m]).forEach((p) => {
-            re.test(p) && middleware[m][p].push([handler, paramCount])
-          })
-        }
-      })
-
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(routes[m]).forEach(
-            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
-          )
-        }
-      })
-
-      return
-    }
-
-    const paths = checkOptionalParameter(path) || [path]
-    for (let i = 0, len = paths.length; i < len; i++) {
-      const path = paths[i]
-
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          routes[m][path] ||= [
-            ...(findMiddleware(middleware[m], path) ||
-              findMiddleware(middleware[METHOD_NAME_ALL], path) ||
-              []),
-          ]
-          routes[m][path].push([handler, paramCount - len + i + 1])
-        }
-      })
-    }
-  }
-
-  match(method: string, path: string): Result<T> {
-    clearWildcardRegExpCache() // no longer used.
-
-    const matchers = this.buildAllMatchers()
-
-    this.match = (method, path) => {
-      const matcher = (matchers[method] || matchers[METHOD_NAME_ALL]) as Matcher<T>
-
-      const staticMatch = matcher[2][path]
-      if (staticMatch) {
-        return staticMatch
-      }
-
-      const match = path.match(matcher[0])
-      if (!match) {
-        return [[], emptyParam]
-      }
-
-      const index = match.indexOf('', 1)
-      return [matcher[1][index], match]
-    }
-
-    return this.match(method, path)
-  }
-
-  private buildAllMatchers(): Record<string, Matcher<T> | null> {
-    const matchers: Record<string, Matcher<T> | null> = Object.create(null)
-
-    ;[...Object.keys(this.routes!), ...Object.keys(this.middleware!)].forEach((method) => {
-      matchers[method] ||= this.buildMatcher(method)
-    })
-
-    // Release cache
-    this.middleware = this.routes = undefined
-
-    return matchers
-  }
-
-  private buildMatcher(method: string): Matcher<T> | null {
-    const routes: [string, HandlerWithMetadata<T>[]][] = []
-
-    let hasOwnRoute = method === METHOD_NAME_ALL
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    ;[this.middleware!, this.routes!].forEach((r) => {
-      const ownRoute = r[method]
-        ? Object.keys(r[method]).map((path) => [path, r[method][path]])
-        : []
-      if (ownRoute.length !== 0) {
-        hasOwnRoute ||= true
-        routes.push(...(ownRoute as [string, HandlerWithMetadata<T>[]][]))
-      } else if (method !== METHOD_NAME_ALL) {
-        routes.push(
-          ...(Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]]) as [
-            string,
-            HandlerWithMetadata<T>[],
-          ][])
-        )
-      }
-    })
-
-    if (!hasOwnRoute) {
-      return null
-    } else {
-      return buildMatcherFromPreprocessedRoutes(routes)
-    }
-  }
-}

package/tests/fixtures/corpus/oss-repos/hono/src/router/reg-exp-router/trie.ts

@@ -1,74 +0,0 @@
-import type { Context, ParamAssocArray } from './node'
-import { Node } from './node'
-
-export type ReplacementMap = number[]
-
-export class Trie {
-  context: Context = { varIndex: 0 }
-  root: Node = new Node()
-
-  insert(path: string, index: number, pathErrorCheckOnly: boolean): ParamAssocArray {
-    const paramAssoc: ParamAssocArray = []
-
-    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
-      }
-    }
-
-    /**
-     *  - pattern (:label, :label{0-9]+}, ...)
-     *  - /* wildcard
-     *  - character
-     */
-    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || []
-    for (let i = groups.length - 1; i >= 0; i--) {
-      const [mark] = groups[i]
-      for (let j = tokens.length - 1; j >= 0; j--) {
-        if (tokens[j].indexOf(mark) !== -1) {
-          tokens[j] = tokens[j].replace(mark, groups[i][1])
-          break
-        }
-      }
-    }
-
-    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly)
-
-    return paramAssoc
-  }
-
-  buildRegExp(): [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 (typeof handlerIndex !== 'undefined') {
-        indexReplacementMap[++captureIndex] = Number(handlerIndex)
-        return '$()'
-      }
-      if (typeof paramIndex !== 'undefined') {
-        paramReplacementMap[Number(paramIndex)] = ++captureIndex
-        return ''
-      }
-
-      return ''
-    })
-
-    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap]
-  }
-}

package/tests/fixtures/corpus/oss-repos/hono/src/router/smart-router/index.ts

@@ -1,6 +0,0 @@
-/**
- * @module
- * SmartRouter for Hono.
- */
-
-export { SmartRouter } from './router'

package/tests/fixtures/corpus/oss-repos/hono/src/router/smart-router/router.ts

@@ -1,69 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import type { Result, Router } from '../../router'
-import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from '../../router'
-
-export class SmartRouter<T> implements Router<T> {
-  name: string = 'SmartRouter'
-  routers: Router<T>[] = []
-  routes?: [string, string, T][] = []
-
-  constructor(init: Pick<SmartRouter<T>, 'routers'>) {
-    Object.assign(this, init)
-  }
-
-  add(method: string, path: string, handler: T) {
-    if (!this.routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT)
-    }
-
-    this.routes.push([method, path, handler])
-  }
-
-  match(method: string, path: string): Result<T> {
-    if (!this.routes) {
-      throw new Error('Fatal error')
-    }
-
-    const { routers, routes } = this
-    const len = routers.length
-    let i = 0
-    let res
-    for (; i < len; i++) {
-      const router = routers[i]
-      try {
-        routes.forEach((args) => {
-          router.add(...args)
-        })
-        res = router.match(method, path)
-      } catch (e) {
-        if (e instanceof UnsupportedPathError) {
-          continue
-        }
-        throw e
-      }
-
-      this.match = router.match.bind(router)
-      this.routers = [router]
-      this.routes = undefined
-      break
-    }
-
-    if (i === len) {
-      // not found
-      throw new Error('Fatal error')
-    }
-
-    // e.g. "SmartRouter + RegExpRouter"
-    this.name = `SmartRouter + ${this.activeRouter.name}`
-
-    return res as Result<T>
-  }
-
-  get activeRouter(): Router<T> {
-    if (this.routes || this.routers.length !== 1) {
-      throw new Error('No active router has been determined yet.')
-    }
-
-    return this.routers[0]
-  }
-}

package/tests/fixtures/corpus/oss-repos/hono/src/router/trie-router/index.ts

@@ -1,6 +0,0 @@
-/**
- * @module
- * TrieRouter for Hono.
- */
-
-export { TrieRouter } from './router'