acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-router/src/core/router/linear-router/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * LinearRouter for App.
+ */
+
+export { LinearRouter } from './router.ts'

package/plugins/acryl-router/src/core/router/linear-router/router.test.ts

@@ -0,0 +1,80 @@
+import { UnsupportedPathError } from '../../router.ts'
+import { runTest } from '../common.case.test.ts'
+import { LinearRouter } from './router.ts'
+
+describe('LinearRouter', () => {
+  runTest({
+    skip: [
+      {
+        reason: 'UnsupportedPath',
+        tests: [
+          'Multi match > `params` per a handler > GET /entry/123/show',
+          'Capture regex pattern has trailing wildcard > GET /foo/bar/file.html',
+          'Capture regex param with trailing wildcard on empty remainder > GET /123',
+          'Capture regex param with trailing wildcard and sibling route > GET /regex-abc/123/ghi',
+          'Trailing wildcard after a label > GET /abc',
+          'Trailing wildcard after a label > GET /abc/sub',
+          'Trailing wildcard after a pattern label > GET /abc',
+          'Trailing wildcard after a pattern label > GET /reverse/abc in reverse registration order',
+          'Trailing wildcard after a pattern label > POST /all/abc with ALL middleware',
+          'Trailing wildcard after a pattern label > GET /posts/2024/comments with nested braces',
+          'Trailing wildcard after a pattern label > GET /files/foo/detail with regexp meta characters',
+          'Trailing wildcard after a pattern label > GET /user/123/profile with the default pattern',
+          'Trailing wildcard after a pattern label > GET /user/123/profile with the default pattern in reverse registration order',
+          'Complex > Parameter with {.*} regexp',
+        ],
+      },
+      {
+        reason: 'LinearRouter allows trailing slashes',
+        tests: ['Trailing slash > GET /book/'],
+      },
+    ],
+    newRouter: () => new LinearRouter(),
+  })
+
+  describe('Multi match', () => {
+    describe('`params` per a handler', () => {
+      const router = new LinearRouter<string>()
+
+      beforeEach(() => {
+        router.add('ALL', '*', 'middleware a')
+        router.add('GET', '/entry/:id/*', 'middleware b')
+        router.add('GET', '/entry/:id/:action', 'action')
+      })
+
+      it('GET /entry/123/show', () => {
+        expect(() => {
+          router.match('GET', '/entry/123/show')
+        }).toThrowError(UnsupportedPathError)
+      })
+    })
+  })
+
+  describe('Trailing slash', () => {
+    const router = new LinearRouter<string>()
+
+    beforeEach(() => {
+      router.add('GET', '/book', 'GET /book')
+      router.add('GET', '/book/:id', 'GET /book/:id')
+    })
+
+    it('GET /book/', () => {
+      const [res] = router.match('GET', '/book/')
+      expect(res.length).toBe(1)
+      expect(res[0][0]).toBe('GET /book')
+    })
+  })
+
+  describe('Skip part', () => {
+    const router = new LinearRouter<string>()
+
+    beforeEach(() => {
+      router.add('GET', '/products/:id{d+}', 'GET /products/:id{d+}')
+    })
+
+    it('GET /products/list', () => {
+      const [res] = router.match('GET', '/products/list')
+      expect(res.length).toBe(0)
+    })
+  })
+})

package/plugins/acryl-router/src/core/router/linear-router/router.ts

@@ -0,0 +1,152 @@
+import type { Params, Result, Router } from '../../router.ts'
+import { METHOD_NAME_ALL, UnsupportedPathError } from '../../router.ts'
+import { checkOptionalParameter } from '../../utils/url.ts'
+
+type RegExpMatchArrayWithIndices = RegExpMatchArray & { indices: [number, number][] }
+
+const emptyParams = Object.create(null)
+
+const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g
+const splitByStarRe = /\*/
+export class LinearRouter<T> implements Router<T> {
+  name: string = 'LinearRouter'
+  #routes: [string, string, T][] = []
+
+  add(method: string, path: string, handler: T) {
+    for (
+      let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length;
+      i < len;
+      i++
+    ) {
+      this.#routes.push([method, paths[i], handler])
+    }
+  }
+
+  match(method: string, path: string): Result<T> {
+    const handlers: [T, Params][] = []
+    ROUTES_LOOP: for (let i = 0, len = this.#routes.length; i < len; i++) {
+      const [routeMethod, routePath, handler] = this.#routes[i]
+      if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
+        if (routePath === '*' || routePath === '/*') {
+          handlers.push([handler, emptyParams])
+          continue
+        }
+
+        const hasStar = routePath.indexOf('*') !== -1
+        const hasLabel = routePath.indexOf(':') !== -1
+        if (!hasStar && !hasLabel) {
+          if (routePath === path || routePath + '/' === path) {
+            handlers.push([handler, emptyParams])
+          }
+        } else if (hasStar && !hasLabel) {
+          const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42
+          const endsWithSlashStar = routePath.endsWith('/*')
+          const parts = (
+            endsWithStar ? routePath.slice(0, endsWithSlashStar ? -2 : -1) : routePath
+          ).split(splitByStarRe)
+
+          const lastIndex = parts.length - 1
+          for (let j = 0, pos = 0, len = parts.length; j < len; j++) {
+            const part = parts[j]
+            const index = path.indexOf(part, pos)
+            if (index !== pos) {
+              continue ROUTES_LOOP
+            }
+            pos += part.length
+            if (j === lastIndex) {
+              if (endsWithSlashStar) {
+                if (pos !== path.length && path.charCodeAt(pos) !== 47) {
+                  continue ROUTES_LOOP
+                }
+              } else if (
+                !endsWithStar &&
+                pos !== path.length &&
+                !(pos === path.length - 1 && path.charCodeAt(pos) === 47)
+              ) {
+                continue ROUTES_LOOP
+              }
+            } else {
+              const index = path.indexOf('/', pos)
+              if (index === -1) {
+                continue ROUTES_LOOP
+              }
+              pos = index
+            }
+          }
+          handlers.push([handler, emptyParams])
+        } else if (hasLabel && !hasStar) {
+          const params: Record<string, string> = Object.create(null)
+          const parts = routePath.match(splitPathRe) as string[]
+
+          const lastIndex = parts.length - 1
+          for (let j = 0, pos = 0, len = parts.length; j < len; j++) {
+            if (pos === -1 || pos >= path.length) {
+              continue ROUTES_LOOP
+            }
+
+            const part = parts[j]
+            if (part.charCodeAt(1) === 58) {
+              if (path.charCodeAt(pos) !== 47) {
+                continue ROUTES_LOOP
+              }
+
+              // /:label
+              let name = part.slice(2)
+              let value
+
+              if (name.charCodeAt(name.length - 1) === 125) {
+                // :label{pattern}
+                const openBracePos = name.indexOf('{')
+                const next = parts[j + 1]
+                const lookahead = next && next[1] !== ':' && next[1] !== '*' ? `(?=${next})` : ''
+                const pattern = name.slice(openBracePos + 1, -1) + lookahead
+                const restPath = path.slice(pos + 1)
+                const match = new RegExp(pattern, 'd').exec(restPath) as RegExpMatchArrayWithIndices
+                if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {
+                  continue ROUTES_LOOP
+                }
+                name = name.slice(0, openBracePos)
+                value = restPath.slice(...match.indices[0])
+                pos += match.indices[0][1] + 1
+              } else {
+                let endValuePos = path.indexOf('/', pos + 1)
+                if (endValuePos === -1) {
+                  endValuePos = path.length
+                }
+                if (endValuePos === pos + 1) {
+                  // an empty segment, as in `/u/` or `/u//posts`
+                  continue ROUTES_LOOP
+                }
+                value = path.slice(pos + 1, endValuePos)
+                pos = endValuePos
+              }
+
+              params[name] ||= value as string
+            } else {
+              const index = path.indexOf(part, pos)
+              if (index !== pos) {
+                continue ROUTES_LOOP
+              }
+              pos += part.length
+            }
+
+            if (j === lastIndex) {
+              if (
+                pos !== path.length &&
+                !(pos === path.length - 1 && path.charCodeAt(pos) === 47)
+              ) {
+                continue ROUTES_LOOP
+              }
+            }
+          }
+
+          handlers.push([handler, params])
+        } else if (hasLabel && hasStar) {
+          throw new UnsupportedPathError()
+        }
+      }
+    }
+
+    return [handlers]
+  }
+}

package/plugins/acryl-router/src/core/router/pattern-router/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * PatternRouter for App.
+ */
+
+export { PatternRouter } from './router.ts'

package/plugins/acryl-router/src/core/router/pattern-router/router.test.ts

@@ -0,0 +1,46 @@
+import { UnsupportedPathError } from '../../router.ts'
+import { runTest } from '../common.case.test.ts'
+import { PatternRouter } from './router.ts'
+
+describe('Pattern', () => {
+  runTest({
+    skip: [
+      {
+        reason: 'UnsupportedPath',
+        tests: [
+          'Duplicate param name > self',
+          'Duplicate param name > self with trailing static',
+          'Duplicate param name > self three times',
+        ],
+      },
+      {
+        reason: 'PatternRouter allows trailing slashes',
+        tests: ['Trailing slash > GET /book/'],
+      },
+    ],
+    newRouter: () => new PatternRouter(),
+  })
+
+  describe('Duplicate param name', () => {
+    it('self', () => {
+      const router = new PatternRouter<string>()
+      expect(() => {
+        router.add('GET', '/:id/:id', 'foo')
+      }).toThrowError(UnsupportedPathError)
+    })
+  })
+  describe('Trailing slash', () => {
+    const router = new PatternRouter<string>()
+
+    beforeEach(() => {
+      router.add('GET', '/book', 'GET /book')
+      router.add('GET', '/book/:id', 'GET /book/:id')
+    })
+
+    it('GET /book/', () => {
+      const [res] = router.match('GET', '/book/')
+      expect(res.length).toBe(1)
+      expect(res[0][0]).toBe('GET /book')
+    })
+  })
+})

package/plugins/acryl-router/src/core/router/pattern-router/router.ts

@@ -0,0 +1,54 @@
+import type { Params, Result, Router } from '../../router.ts'
+import { METHOD_NAME_ALL, UnsupportedPathError } from '../../router.ts'
+
+type Route<T> = [RegExp, string, T] // [pattern, method, handler]
+
+const emptyParams = Object.create(null)
+
+export class PatternRouter<T> implements Router<T> {
+  name: string = 'PatternRouter'
+  #routes: Route<T>[] = []
+
+  add(method: string, path: string, handler: T) {
+    const suffix = path.endsWith('/*') ? '(?:$|/)' : path.endsWith('*') ? '' : '/?$'
+    path = path.replace(/\*$/, '')
+    if (path.at(-1) === '?') {
+      path = path.slice(0, -1)
+      this.add(method, path.replace(/\/[^/]+$/, ''), handler)
+    }
+
+    const parts = (path.match(/\/?(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/?[^\/\?]+/g) || []).map(
+      (part) => {
+        const match = part.match(/^\/:([^{]+)(?:{(.*)})?/)
+        return match
+          ? `/(?<${match[1]}>${match[2] || '[^/]+'})`
+          : part === '/*'
+            ? '/[^/]+'
+            : part.replace(/[.\\+*[^\]$()]/g, '\\$&')
+      }
+    )
+
+    try {
+      this.#routes.push([new RegExp(`^${parts.join('')}${suffix}`), method, handler])
+    } catch {
+      throw new UnsupportedPathError()
+    }
+  }
+
+  match(method: string, path: string): Result<T> {
+    const handlers: [T, Params][] = []
+
+    for (let i = 0, len = this.#routes.length; i < len; i++) {
+      const [pattern, routeMethod, handler] = this.#routes[i]
+
+      if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
+        const match = pattern.exec(path)
+        if (match) {
+          handlers.push([handler, match.groups || emptyParams])
+        }
+      }
+    }
+
+    return [handlers]
+  }
+}

package/plugins/acryl-router/src/core/router/reg-exp-router/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * RegExpRouter for App.
+ */
+
+export { RegExpRouter } from './router.ts'
+export { PreparedRegExpRouter, buildInitParams, serializeInitParams } from './prepared-router.ts'

package/plugins/acryl-router/src/core/router/reg-exp-router/matcher.ts

@@ -0,0 +1,33 @@
+import type { ParamIndexMap, Result, Router } from '../../router.ts'
+import { METHOD_NAME_ALL } from '../../router.ts'
+
+export type HandlerData<T> = [T, ParamIndexMap][]
+export type StaticMap<T> = Record<string, Result<T>>
+export type Matcher<T> = [RegExp, HandlerData<T>[], StaticMap<T>]
+export type MatcherMap<T> = Record<string, Matcher<T> | null>
+
+export const emptyParam: string[] = []
+export 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
+    }
+
+    const match = path.match(matcher[0])
+    if (!match) {
+      return [[], emptyParam]
+    }
+
+    const index = match.indexOf('', 1)
+    return [matcher[1][index], match]
+  }) as Router<T>['match']
+
+  this.match = match
+  return match(method, path)
+}

package/plugins/acryl-router/src/core/router/reg-exp-router/node.ts

@@ -0,0 +1,170 @@
+import { createNullObject } from '../utils.ts'
+
+export const LABEL_REG_EXP_STR = '[^/]+'
+export const ONLY_WILDCARD_REG_EXP_STR = '.*'
+export 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: the only wildcard (.*) precedes the tail wildcard
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return b === TAIL_WILDCARD_REG_EXP_STR ? -1 : 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 {
+  // handler index of a dynamic path, or -1 for a static path terminal
+  #index?: number
+  #varIndex?: number
+  #children: Record<string, Node> = createNullObject()
+
+  insert(
+    tokens: readonly string[],
+    index: number,
+    paramMap: ParamAssocArray,
+    context: Context,
+    isStatic: boolean
+  ): void {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let node: Node = this
+    for (let i = 0, len = tokens.length; i < len; i++) {
+      const token = tokens[i]
+      const pattern =
+        token.length === 1
+          ? token === '*'
+            ? i === len - 1
+              ? ['', '', ONLY_WILDCARD_REG_EXP_STR] // '*' matches to all the trailing paths
+              : ['', '', LABEL_REG_EXP_STR]
+            : null
+          : token === '/*'
+            ? ['', '', TAIL_WILDCARD_REG_EXP_STR] // '/path/to/*' is /\/path\/to(?:|/.*)$
+            : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/)
+
+      let nextNode: Node
+      if (pattern) {
+        const name = pattern[1]
+        let regexpStr = pattern[2] || LABEL_REG_EXP_STR
+        if (name && pattern[2]) {
+          if (regexpStr === '.*') {
+            throw PATH_ERROR
+          }
+          regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, '(?:') // (a|b) => (?:a|b)
+          if (/\((?!\?:)/.test(regexpStr)) {
+            // prefix(?:a|b) is allowed, but prefix(a|b) is not
+            throw PATH_ERROR
+          }
+          if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr)) {
+            // a single-char pattern like :x{.} is ambiguous with a literal character
+            throw PATH_ERROR
+          }
+        }
+
+        nextNode = node.#children[regexpStr]
+        if (!nextNode) {
+          if (regexpStr !== ONLY_WILDCARD_REG_EXP_STR && regexpStr !== TAIL_WILDCARD_REG_EXP_STR) {
+            for (const k in node.#children) {
+              if (
+                // a single-char pattern coexists with single-char literals as a literal does
+                (regexpStr.length > 1 || k.length > 1) &&
+                k !== ONLY_WILDCARD_REG_EXP_STR &&
+                k !== TAIL_WILDCARD_REG_EXP_STR
+              ) {
+                throw PATH_ERROR
+              }
+            }
+          }
+          nextNode = node.#children[regexpStr] = new Node()
+        }
+        if (name !== '') {
+          nextNode.#varIndex ??= context.varIndex++
+          paramMap.push([name, nextNode.#varIndex])
+        }
+      } else {
+        nextNode = node.#children[token]
+        if (!nextNode) {
+          for (const k in node.#children) {
+            if (
+              k.length > 1 &&
+              k !== ONLY_WILDCARD_REG_EXP_STR &&
+              k !== TAIL_WILDCARD_REG_EXP_STR
+            ) {
+              throw PATH_ERROR
+            }
+          }
+          nextNode = node.#children[token] = new Node()
+        }
+      }
+
+      node = nextNode
+    }
+
+    if (node.#index !== undefined) {
+      throw PATH_ERROR
+    }
+    node.#index = isStatic ? -1 : index
+  }
+
+  buildRegExpStr(): string {
+    const childKeys = Object.keys(this.#children).sort(compareKey)
+
+    const strList = childKeys
+      .map((k) => {
+        const c = this.#children[k]
+        const childStr = c.buildRegExpStr()
+        // an empty childStr means a static-only branch, which is handled by staticMap
+        return childStr === ''
+          ? ''
+          : (typeof c.#varIndex === 'number'
+              ? `(${k})@${c.#varIndex}`
+              : regExpMetaChars.has(k)
+                ? `\\${k}`
+                : k) + childStr
+      })
+      .filter(Boolean)
+
+    if (typeof this.#index === 'number' && this.#index !== -1) {
+      strList.unshift(`#${this.#index}`)
+    }
+
+    if (strList.length === 0) {
+      return ''
+    }
+    if (strList.length === 1) {
+      return strList[0]
+    }
+
+    return '(?:' + strList.join('|') + ')'
+  }
+}