acrylblends 0.6.3 → 0.7.0

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

@@ -1,80 +0,0 @@
-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/pattern-router/router.test.ts

@@ -1,46 +0,0 @@
-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/reg-exp-router/prepared-router.test.ts

@@ -1,154 +0,0 @@
-import { METHOD_NAME_ALL } from '../../router.ts'
-import { runTest } from '../common.case.test.ts'
-import { buildInitParams, serializeInitParams, PreparedRegExpRouter } from './prepared-router.ts'
-
-describe('PreparedRegExpRouter', async () => {
-  runTest({
-    skip: [
-      {
-        reason: 'UnsupportedPath',
-        tests: [
-          'Duplicate param name > parent',
-          'Duplicate param name > child',
-          'Capture Group > Complex capturing group > GET request',
-          'Capture complex multiple directories > GET /part1/middle-b/latest',
-          'Capture complex multiple directories > GET /part1/middle-b/end-c/latest',
-          'Complex > Parameter with {.*} regexp',
-        ],
-      },
-      {
-        reason:
-          'This route can not be added with `:label` to PreparedRegExpRouter. This is ambiguous',
-        tests: ['Including slashes > GET /js/main.js'],
-      },
-    ],
-    newRouter: <T>() => {
-      let router: PreparedRegExpRouter<T>
-      const routes: [string, string, T][] = []
-      return {
-        name: 'PreparedRegExpRouterBuilder',
-        add: (method: string, path: string, handler: T) => {
-          routes.push([method, path, handler])
-        },
-        match: (method: string, path: string) => {
-          if (!router) {
-            const serialized = serializeInitParams(
-              buildInitParams({
-                paths: routes.map((r) => r[1]),
-              })
-            )
-            const params = eval(serialized) as ConstructorParameters<typeof PreparedRegExpRouter<T>>
-            router = new PreparedRegExpRouter<T>(...params)
-
-            for (const route of routes) {
-              router.add(...route)
-            }
-          }
-          return router.match(method, path)
-        },
-      }
-    },
-  })
-
-  describe('add()', () => {
-    it('should add a route', () => {
-      const params = buildInitParams({
-        paths: ['/hello'],
-      })
-      const router = new PreparedRegExpRouter(...params)
-      router.add('GET', '/hello', 'get hello')
-      expect(router.match('GET', '/hello')).toEqual([[['get hello', {}]], []])
-    })
-
-    it('should throw an error if the path is not pre-registered', () => {
-      const params = buildInitParams({
-        paths: ['/hello'],
-      })
-      const router = new PreparedRegExpRouter(...params)
-      expect(() => router.add('GET', '/unknown', 'get hello')).toThrowError()
-    })
-  })
-})
-
-describe('buildInitParams() and serializeInitParams()', () => {
-  it('should build empty init params', () => {
-    const params = buildInitParams({
-      paths: [],
-    })
-    expect(params).toEqual([{ [METHOD_NAME_ALL]: [/^$/, [], {}] }, {}])
-    expect((0, eval)(serializeInitParams(params))).toEqual(params)
-  })
-
-  it('should build init params with one static path', () => {
-    const params = buildInitParams({
-      paths: ['/hello'],
-    })
-    expect(params).toEqual([
-      {
-        [METHOD_NAME_ALL]: [
-          /^$/,
-          [],
-          {
-            '/hello': [[], []],
-          },
-        ],
-      },
-      {
-        '/hello': [[['']]],
-      },
-    ])
-    expect((0, eval)(serializeInitParams(params))).toEqual(params)
-  })
-
-  it('should build init params with paths with params', () => {
-    const params = buildInitParams({
-      paths: ['/hello/:name', '/hello/:name/posts/:postId'],
-    })
-    expect(params).toEqual([
-      {
-        [METHOD_NAME_ALL]: [/^\/hello\/([^/]+)(?:$()|\/posts\/([^/]+)$())/, [0, 0, [], 0, []], {}],
-      },
-      {
-        '/hello/:name': [[[2], { name: 1 }]],
-        '/hello/:name/posts/:postId': [[[4], { name: 1, postId: 3 }]],
-      },
-    ])
-    expect((0, eval)(serializeInitParams(params))).toEqual(params)
-  })
-
-  it('should build init params with wildcard', () => {
-    const params = buildInitParams({
-      paths: ['*'],
-    })
-    expect(params).toEqual([
-      {
-        [METHOD_NAME_ALL]: [/^.*$()/, [0, []], {}],
-      },
-      {},
-    ])
-    expect((0, eval)(serializeInitParams(params))).toEqual(params)
-  })
-
-  it('should build init params with complex path', () => {
-    const params = buildInitParams({
-      paths: ['/hello', '/hello/:name', '/hello/:name/posts/:postId', '*'],
-    })
-    expect(params).toEqual([
-      {
-        [METHOD_NAME_ALL]: [
-          /^(?:\/hello\/([^/]+)(?:$()|\/posts\/([^/]+)$())|.*$())/,
-          [0, 0, [], 0, [], []],
-          {
-            '/hello': [[], []],
-          },
-        ],
-      },
-      {
-        '/hello': [[['']]],
-        '/hello/:name': [[[2], { name: 1 }]],
-        '/hello/:name/posts/:postId': [[[4], { name: 1, postId: 3 }]],
-      },
-    ])
-    expect((0, eval)(serializeInitParams(params))).toEqual(params)
-  })
-})

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

@@ -1,265 +0,0 @@
-import type { ParamIndexMap, ParamStash } from '../../router.ts'
-import { UnsupportedPathError } from '../../router.ts'
-import { runTest } from '../common.case.test.ts'
-import { RegExpRouter } from './router.ts'
-
-describe('RegExpRouter', () => {
-  runTest({
-    skip: [
-      {
-        reason: 'UnsupportedPath',
-        tests: [
-          'Duplicate param name > parent',
-          'Duplicate param name > child',
-          'Capture Group > Complex capturing group > GET request',
-          'Capture complex multiple directories > GET /part1/middle-b/latest',
-          'Capture complex multiple directories > GET /part1/middle-b/end-c/latest',
-          'Complex > Parameter with {.*} regexp',
-        ],
-      },
-      {
-        reason: 'This route can not be added with `:label` to RegExpRouter. This is ambiguous',
-        tests: ['Including slashes > GET /js/main.js'],
-      },
-    ],
-    newRouter: () => new RegExpRouter(),
-  })
-
-  describe('Return value type', () => {
-    it('Should return [[T, ParamIndexMap][], ParamStash]', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/posts/:id', 'get post')
-
-      const [res, stash] = router.match('GET', '/posts/1')
-      expect(res.length).toBe(1)
-      expect(res).toEqual([['get post', { id: 1 }]])
-      expect((stash as ParamStash)[1]).toBe('1')
-    })
-  })
-
-  describe('UnsupportedPathError', () => {
-    describe('Ambiguous', () => {
-      it('GET /entry/:name', () => {
-        const router = new RegExpRouter<string>()
-        router.add('GET', '/:user/entries', 'get user entries')
-        expect(() => {
-          router.add('GET', '/entry/:name', 'get entry')
-        }).toThrowError(UnsupportedPathError)
-      })
-    })
-
-    describe('Multiple handlers with different label', () => {
-      it('GET /:class/:id', () => {
-        const router = new RegExpRouter<string>()
-        router.add('GET', '/:type/:id', ':type')
-        expect(() => {
-          router.add('GET', '/:class/:id', ':class')
-        }).toThrowError(UnsupportedPathError)
-      })
-    })
-
-    it('parent', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/:id/:action', 'foo')
-      expect(() => {
-        router.add('GET', '/posts/:id', 'bar')
-      }).toThrowError(UnsupportedPathError)
-    })
-
-    it('child', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/posts/:id', 'foo')
-      expect(() => {
-        router.add('GET', '/:id/:action', 'bar')
-      }).toThrowError(UnsupportedPathError)
-    })
-
-    describe('static and dynamic', () => {
-      it('static first', () => {
-        const router = new RegExpRouter<string>()
-        router.add('GET', '/reg-exp/router', 'foo')
-        expect(() => {
-          router.add('GET', '/reg-exp/:id', 'bar')
-        }).toThrowError(UnsupportedPathError)
-      })
-
-      it('long label', () => {
-        const router = new RegExpRouter<string>()
-        router.add('GET', '/reg-exp/router', 'foo')
-        expect(() => {
-          router.add('GET', '/reg-exp/:service', 'bar')
-        }).toThrowError(UnsupportedPathError)
-      })
-
-      it('dynamic first', () => {
-        const router = new RegExpRouter<string>()
-        router.add('GET', '/reg-exp/:id', 'bar')
-        expect(() => {
-          router.add('GET', '/reg-exp/router', 'foo')
-        }).toThrowError(UnsupportedPathError)
-      })
-    })
-
-    it('different regular expression', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/:id/:action{create|update}', 'foo')
-      expect(() => {
-        router.add('GET', '/:id/:action{delete}', 'bar')
-      }).toThrowError(UnsupportedPathError)
-    })
-
-    it('ALL route added after a specific-method route', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/foo/:a', 'foo')
-      expect(() => {
-        router.add('ALL', '/foo/:b', 'bar')
-      }).toThrowError(UnsupportedPathError)
-    })
-
-    it('specific-method route added after an ALL route', () => {
-      const router = new RegExpRouter<string>()
-      router.add('ALL', '/reg-exp/router', 'foo')
-
-      expect(() => {
-        router.add('GET', '/reg-exp/:id', 'bar')
-      }).toThrowError(UnsupportedPathError)
-    })
-
-    it('different methods do not conflict', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/reg-exp/router', 'foo')
-      router.add('POST', '/reg-exp/:id', 'bar')
-
-      expect(router.match('GET', '/reg-exp/router')[0][0][0]).toBe('foo')
-      expect(router.match('POST', '/reg-exp/router')[0][0][0]).toBe('bar')
-    })
-
-    describe('Capture Group', () => {
-      describe('Complex capturing group', () => {
-        it('GET request', () => {
-          const router = new RegExpRouter<string>()
-          expect(() => {
-            router.add('GET', '/foo/:capture{ba(r|z)}', 'ok')
-          }).toThrowError(UnsupportedPathError)
-        })
-      })
-    })
-  })
-
-  describe('Wildcard after label', () => {
-    it('Should be able to add a tail wildcard after a label', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/api/:x', 'label')
-      router.add('GET', '/api/*', 'wildcard')
-
-      const [res] = router.match('GET', '/api/foo')
-      expect(res.length).toBe(2)
-      expect(res[0][0]).toBe('label')
-      expect(res[1][0]).toBe('wildcard')
-    })
-
-    it('Should prioritize the only wildcard over the tail wildcard regardless of the order', () => {
-      for (const paths of [
-        ['/a*', '/a/*'],
-        ['/a/*', '/a*'],
-      ]) {
-        const router = new RegExpRouter<string>()
-        for (const path of paths) {
-          router.add('GET', path, path)
-        }
-        const [res] = router.match('GET', '/a')
-        expect(res[0][0]).toBe('/a*')
-      }
-    })
-  })
-
-  describe('Single character regexp pattern', () => {
-    it('Should capture a param even if a static path created the node first', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/a/c', 'static')
-      router.add('GET', '/:x{a}/b', 'pattern')
-
-      const [res, stash] = router.match('GET', '/a/b')
-      expect(res.length).toBe(1)
-      expect(res[0][0]).toBe('pattern')
-      expect((stash as ParamStash)[(res[0][1] as ParamIndexMap)['x']]).toBe('a')
-    })
-
-    it('Should throw an error when a pattern terminal conflicts with a static terminal', () => {
-      for (const paths of [
-        ['/a', '/:x{a}'],
-        ['/:x{a}', '/a'],
-      ]) {
-        const router = new RegExpRouter<string>()
-        router.add('GET', paths[0], paths[0])
-        expect(() => {
-          router.add('GET', paths[1], paths[1])
-        }).toThrowError(UnsupportedPathError)
-      }
-    })
-
-    it('Should coexist with static paths regardless of the order', () => {
-      for (const paths of [
-        ['/foo/bar', '/:y{b}'],
-        ['/:y{b}', '/foo/bar'],
-      ]) {
-        const router = new RegExpRouter<string>()
-        for (const path of paths) {
-          router.add('GET', path, path)
-        }
-        expect(router.match('GET', '/foo/bar')[0][0][0]).toBe('/foo/bar')
-        expect(router.match('GET', '/b')[0][0][0]).toBe('/:y{b}')
-      }
-    })
-
-    it('Should coexist with dynamic paths regardless of the order', () => {
-      for (const paths of [
-        ['/foo/:p', '/:x{a}'],
-        ['/:x{a}', '/foo/:p'],
-      ]) {
-        const router = new RegExpRouter<string>()
-        for (const path of paths) {
-          router.add('GET', path, path)
-        }
-        expect(router.match('GET', '/a')[0][0][0]).toBe('/:x{a}')
-        expect(router.match('GET', '/foo/v')[0][0][0]).toBe('/foo/:p')
-      }
-    })
-
-    it('Should throw an error for a single meta character pattern', () => {
-      const router = new RegExpRouter<string>()
-      expect(() => {
-        router.add('GET', '/:x{.}', 'meta')
-      }).toThrowError(UnsupportedPathError)
-    })
-  })
-
-  describe('Capture a param of a label node created by a middle wildcard', () => {
-    it('Should capture the param', () => {
-      const router = new RegExpRouter<string>()
-      router.add('GET', '/w/*/x', 'wildcard')
-      router.add('GET', '/w/:id/y', 'label')
-
-      const [res, stash] = router.match('GET', '/w/123/y')
-      expect(res.length).toBe(1)
-      expect(res[0][0]).toBe('label')
-      expect((stash as ParamStash)[(res[0][1] as ParamIndexMap)['id']]).toBe('123')
-    })
-  })
-
-  describe('Static path including a colon in the middle', () => {
-    it('Should be treated as a static path', () => {
-      for (const paths of [
-        ['/v1/name:activate', '/v1/name2'],
-        ['/v1/name2', '/v1/name:activate'],
-      ]) {
-        const router = new RegExpRouter<string>()
-        for (const path of paths) {
-          router.add('GET', path, path)
-        }
-        expect(router.match('GET', '/v1/name:activate')[0][0][0]).toBe('/v1/name:activate')
-        expect(router.match('GET', '/v1/name2')[0][0][0]).toBe('/v1/name2')
-      }
-    })
-  })
-})

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

@@ -1,13 +0,0 @@
-import { runTest } from '../common.case.test.ts'
-import { RegExpRouter } from '../reg-exp-router/index.ts'
-import { TrieRouter } from '../trie-router/index.ts'
-import { SmartRouter } from './router.ts'
-
-describe('SmartRouter', () => {
-  runTest({
-    newRouter: () =>
-      new SmartRouter({
-        routers: [new RegExpRouter(), new TrieRouter()],
-      }),
-  })
-})