acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-router/src/core/utils/body.ts

@@ -0,0 +1,263 @@
+/**
+ * @module
+ * Body utility.
+ */
+
+import type { AppRequest } from '../request.ts'
+import { bufferToFormData } from './buffer.ts'
+
+const MAX_NESTING_DEPTH = 32
+const MAX_NESTED_OBJECTS = 10_000
+
+type BodyDataValueDot = { [x: string]: string | File | BodyDataValueDot }
+type BodyDataValueDotAll = {
+  [x: string]: string | File | (string | File)[] | BodyDataValueDotAll
+}
+type SimplifyBodyData<T> = {
+  [K in keyof T]: string | File | (string | File)[] | BodyDataValueDotAll extends T[K]
+    ? string | File | (string | File)[] | BodyDataValueDotAll
+    : string | File | BodyDataValueDot extends T[K]
+      ? string | File | BodyDataValueDot
+      : string | File | (string | File)[] extends T[K]
+        ? string | File | (string | File)[]
+        : string | File
+} & {}
+
+type BodyDataValueComponent<T> =
+  | string
+  | File
+  | (T extends { all: false }
+      ? never // explicitly set to false
+      : T extends { all: true } | { all: boolean }
+        ? (string | File)[] // use all option
+        : never) // without options
+type BodyDataValueObject<T> = { [key: string]: BodyDataValueComponent<T> | BodyDataValueObject<T> }
+type BodyDataValue<T> =
+  | BodyDataValueComponent<T>
+  | (T extends { dot: false }
+      ? never // explicitly set to false
+      : T extends { dot: true } | { dot: boolean }
+        ? BodyDataValueObject<T> // use dot option
+        : never) // without options
+export type BodyData<T extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<
+  Record<string, BodyDataValue<T>>
+>
+
+export type ParseBodyOptions = {
+  /**
+   * Determines whether all fields with multiple values should be parsed as arrays.
+   * @default false
+   * @example
+   * const data = new FormData()
+   * data.append('file', 'aaa')
+   * data.append('file', 'bbb')
+   * data.append('message', 'hello')
+   *
+   * If all is false:
+   * parseBody should return { file: 'bbb', message: 'hello' }
+   *
+   * If all is true:
+   * parseBody should return { file: ['aaa', 'bbb'], message: 'hello' }
+   */
+  all: boolean
+  /**
+   * Determines whether all fields with dot notation should be parsed as nested objects.
+   * @default false
+   * @example
+   * const data = new FormData()
+   * data.append('obj.key1', 'value1')
+   * data.append('obj.key2', 'value2')
+   *
+   * If dot is false:
+   * parseBody should return { 'obj.key1': 'value1', 'obj.key2': 'value2' }
+   *
+   * If dot is true:
+   * parseBody should return { obj: { key1: 'value1', key2: 'value2' } }
+   */
+  dot: boolean
+}
+
+const isRawRequest = (request: AppRequest | Request): request is Request => 'headers' in request // 'headers' method exists only on Request, not on AppRequest.
+
+/**
+ * Parses the body of a request based on the provided options.
+ *
+ * @template T - The type of the parsed body data.
+ * @param {AppRequest | Request} request - The request object to parse.
+ * @param {Partial<ParseBodyOptions>} [options] - Options for parsing the body.
+ * @returns {Promise<T>} The parsed body data.
+ */
+interface ParseBody {
+  <Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(
+    request: AppRequest | Request,
+    options?: Options
+  ): Promise<T>
+  <T extends BodyData>(
+    request: AppRequest | Request,
+    options?: Partial<ParseBodyOptions>
+  ): Promise<T>
+}
+export const parseBody: ParseBody = async (
+  request: AppRequest | Request,
+  options = Object.create(null)
+) => {
+  const { all = false, dot = false } = options
+
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers
+  const contentType = headers.get('Content-Type')
+
+  const mediaType = contentType?.split(';')[0].trim().toLowerCase()
+
+  if (mediaType === 'multipart/form-data' || mediaType === 'application/x-www-form-urlencoded') {
+    return parseFormData(request, { all, dot })
+  }
+
+  return {}
+}
+
+/**
+ * Parses form data from a request.
+ *
+ * @template T - The type of the parsed body data.
+ * @param {AppRequest | Request} request - The request object containing form data.
+ * @param {ParseBodyOptions} options - Options for parsing the form data.
+ * @returns {Promise<T>} The parsed body data.
+ */
+async function parseFormData<T extends BodyData>(
+  request: AppRequest | Request,
+  options: ParseBodyOptions
+): Promise<T> {
+  if (!isRawRequest(request) && request.bodyCache.formData) {
+    return convertFormDataToBodyData<T>(
+      await (request.bodyCache.formData as FormData | Promise<FormData>),
+      options
+    )
+  }
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers
+  const arrayBuffer = await (request as Request).arrayBuffer()
+  const formDataPromise = bufferToFormData(arrayBuffer, headers.get('Content-Type') || '')
+  if (!isRawRequest(request)) {
+    // Cache so that a later `c.req.formData()` reuses the already-consumed body
+    request.bodyCache.formData = formDataPromise as unknown as FormData
+  }
+  const formData = await formDataPromise
+
+  if (formData) {
+    return convertFormDataToBodyData<T>(formData, options)
+  }
+
+  return {} as T
+}
+
+/**
+ * Converts form data to body data based on the provided options.
+ *
+ * @template T - The type of the parsed body data.
+ * @param {FormData} formData - The form data to convert.
+ * @param {ParseBodyOptions} options - Options for parsing the form data.
+ * @returns {T} The converted body data.
+ */
+function convertFormDataToBodyData<T extends BodyData = BodyData>(
+  formData: FormData,
+  options: ParseBodyOptions
+): T {
+  const form: BodyData = Object.create(null)
+  const nestingState = { count: 0 }
+
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith('[]')
+
+    if (!shouldParseAllValues) {
+      form[key] = value
+    } else {
+      handleParsingAllValues(form, key, value)
+    }
+  })
+
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes('.')
+
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value, nestingState)
+        delete form[key]
+      }
+    })
+  }
+
+  return form as T
+}
+
+/**
+ * Handles parsing all values for a given key, supporting multiple values as arrays.
+ *
+ * @param {BodyData} form - The form data object.
+ * @param {string} key - The key to parse.
+ * @param {FormDataEntryValue} value - The value to assign.
+ */
+const handleParsingAllValues = (
+  form: BodyData<{ all: true }>,
+  key: string,
+  value: FormDataEntryValue
+): void => {
+  if (form[key] !== undefined) {
+    if (Array.isArray(form[key])) {
+      ;(form[key] as (string | File)[]).push(value)
+    } else {
+      form[key] = [form[key] as string | File, value]
+    }
+  } else {
+    if (!key.endsWith('[]')) {
+      form[key] = value
+    } else {
+      form[key] = [value]
+    }
+  }
+}
+
+/**
+ * Handles parsing nested values using dot notation keys.
+ *
+ * @param {BodyData} form - The form data object.
+ * @param {string} key - The dot notation key.
+ * @param {BodyDataValue} value - The value to assign.
+ */
+const handleParsingNestedValues = (
+  form: BodyData,
+  key: string,
+  value: BodyDataValue<Partial<ParseBodyOptions>>,
+  state: { count: number }
+): void => {
+  if (/(?:^|\.)__proto__\./.test(key)) {
+    return
+  }
+
+  let nestedForm = form
+  const keys = key.split('.', MAX_NESTING_DEPTH + 2)
+  if (keys.length > MAX_NESTING_DEPTH + 1) {
+    throwNestingLimitExceeded()
+  }
+
+  keys.forEach((key, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key] = value
+    } else {
+      if (
+        !nestedForm[key] ||
+        typeof nestedForm[key] !== 'object' ||
+        Array.isArray(nestedForm[key]) ||
+        nestedForm[key] instanceof File
+      ) {
+        if (state.count++ >= MAX_NESTED_OBJECTS) {
+          throwNestingLimitExceeded()
+        }
+        nestedForm[key] = Object.create(null)
+      }
+      nestedForm = nestedForm[key] as unknown as BodyData
+    }
+  })
+}
+
+const throwNestingLimitExceeded = (): never => {
+  throw new Error('Nesting limit exceeded')
+}

package/plugins/acryl-router/src/core/utils/buffer.test.ts

@@ -0,0 +1,147 @@
+import { createHash } from 'node:crypto'
+import { bufferToFormData, bufferToString, equal, timingSafeEqual } from './buffer.ts'
+
+describe('equal', () => {
+  it('should return true for identical ArrayBuffers', () => {
+    const buffer1 = new ArrayBuffer(1)
+    const buffer2 = buffer1
+    expect(equal(buffer1, buffer2)).toBe(true)
+  })
+
+  it('should return false for ArrayBuffers of different lengths', () => {
+    const buffer1 = new ArrayBuffer(1)
+    const buffer2 = new ArrayBuffer(2)
+    expect(equal(buffer1, buffer2)).toBe(false)
+  })
+
+  it('should return false for ArrayBuffers with different content', () => {
+    const buffer1 = new Uint8Array([1, 2, 3, 4]).buffer
+    const buffer2 = new Uint8Array([2, 2, 3, 4]).buffer
+    expect(equal(buffer1, buffer2)).toBe(false)
+  })
+
+  it('should return true for ArrayBuffers with identical content', () => {
+    const buffer1 = new Uint8Array([1, 2, 3, 4]).buffer
+    const buffer2 = new Uint8Array([1, 2, 3, 4]).buffer
+    expect(equal(buffer1, buffer2)).toBe(true)
+  })
+})
+
+describe('buffer', () => {
+  it('positive', async () => {
+    expect(
+      await timingSafeEqual(
+        '127e6fbfe24a750e72930c220a8e138275656b8e5d8f48a98c3c92df2caba935',
+        '127e6fbfe24a750e72930c220a8e138275656b8e5d8f48a98c3c92df2caba935'
+      )
+    ).toBe(true)
+    expect(await timingSafeEqual('a', 'a')).toBe(true)
+    expect(await timingSafeEqual('', '')).toBe(true)
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(await timingSafeEqual(undefined, undefined)).toBe(true)
+  })
+
+  it('negative', async () => {
+    expect(await timingSafeEqual('a', 'b')).toBe(false)
+    expect(
+      await timingSafeEqual('a', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+    ).toBe(false)
+    expect(
+      await timingSafeEqual('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'a')
+    ).toBe(false)
+    expect(await timingSafeEqual('alpha', 'beta')).toBe(false)
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(await timingSafeEqual(false, undefined)).toBe(false)
+
+    expect(
+      await timingSafeEqual(
+        // well known md5 hash collision
+        // https://marc-stevens.nl/research/md5-1block-collision/
+        'TEXTCOLLBYfGiJUETHQ4hAcKSMd5zYpgqf1YRDhkmxHkhPWptrkoyz28wnI9V0aHeAuaKnak',
+        'TEXTCOLLBYfGiJUETHQ4hEcKSMd5zYpgqf1YRDhkmxHkhPWptrkoyz28wnI9V0aHeAuaKnak',
+        (input) => createHash('md5').update(input).digest('hex')
+      )
+    ).toBe(false)
+  })
+
+  it.skip('comparing variables except string are deprecated', async () => {
+    expect(await timingSafeEqual(true, true)).toBe(true)
+    expect(await timingSafeEqual(false, false)).toBe(true)
+    expect(
+      await timingSafeEqual(true, true, (d: boolean) =>
+        createHash('sha256').update(d.toString()).digest('hex')
+      )
+    )
+    expect(await timingSafeEqual(false, true)).toBe(false)
+    expect(
+      await timingSafeEqual(
+        () => {},
+        () => {}
+      )
+    ).toBe(false)
+    expect(await timingSafeEqual({}, {})).toBe(false)
+    expect(await timingSafeEqual({ a: 1 }, { a: 1 })).toBe(false)
+    expect(await timingSafeEqual({ a: 1 }, { a: 2 })).toBe(false)
+    expect(await timingSafeEqual([1, 2], [1, 2])).toBe(false)
+    expect(await timingSafeEqual([1, 2], [1, 2, 3])).toBe(false)
+    expect(await timingSafeEqual('a', 'b', () => undefined)).toBe(false)
+  })
+})
+
+describe('bufferToString', () => {
+  it('Should return あいうえお', () => {
+    const bytes = [227, 129, 130, 227, 129, 132, 227, 129, 134, 227, 129, 136, 227, 129, 138]
+    const buffer = Uint8Array.from(bytes).buffer
+    expect(bufferToString(buffer)).toBe('あいうえお')
+  })
+  it('should return the passed arguments as is ', () => {
+    const notBuffer = 'あいうえお' as unknown as ArrayBuffer
+    expect(bufferToString(notBuffer)).toBe('あいうえお')
+  })
+})
+
+describe('bufferToFormData', () => {
+  it('Should parse multipart/form-data from ArrayBuffer', async () => {
+    const encoder = new TextEncoder()
+    const testData =
+      '--sampleboundary\r\nContent-Disposition: form-data; name="test"\r\n\r\nHello\r\n--sampleboundary--'
+    const arrayBuffer = encoder.encode(testData).buffer
+
+    const result = await bufferToFormData(
+      arrayBuffer,
+      'multipart/form-data; boundary=sampleboundary'
+    )
+
+    expect(result.get('test')).toBe('Hello')
+  })
+
+  it('Should parse mixed-case multipart/form-data media type while keeping the boundary', async () => {
+    const encoder = new TextEncoder()
+    const testData =
+      '--sampleBoundary\r\nContent-Disposition: form-data; name="test"\r\n\r\nHello\r\n--sampleBoundary--'
+    const arrayBuffer = encoder.encode(testData).buffer
+
+    const result = await bufferToFormData(
+      arrayBuffer,
+      'Multipart/Form-Data; boundary=sampleBoundary'
+    )
+
+    expect(result.get('test')).toBe('Hello')
+  })
+
+  it('Should parse application/x-www-form-urlencoded from ArrayBuffer', async () => {
+    const encoder = new TextEncoder()
+    const searchParams = new URLSearchParams()
+    searchParams.append('id', '123')
+    searchParams.append('title', 'Good title')
+    const testData = searchParams.toString()
+    const arrayBuffer = encoder.encode(testData).buffer
+
+    const result = await bufferToFormData(arrayBuffer, 'application/x-www-form-urlencoded')
+
+    expect(result.get('id')).toBe('123')
+    expect(result.get('title')).toBe('Good title')
+  })
+})

package/plugins/acryl-router/src/core/utils/buffer.ts

@@ -0,0 +1,117 @@
+/**
+ * @module
+ * Buffer utility.
+ */
+
+import { sha256 } from './crypto.ts'
+
+export const equal = (a: ArrayBuffer, b: ArrayBuffer): boolean => {
+  if (a === b) {
+    return true
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false
+  }
+
+  const va = new DataView(a)
+  const vb = new DataView(b)
+
+  let i = va.byteLength
+  while (i--) {
+    if (va.getUint8(i) !== vb.getUint8(i)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+const constantTimeEqualString = (a: string, b: string): boolean => {
+  const aLen = a.length
+  const bLen = b.length
+  const maxLen = Math.max(aLen, bLen)
+  let out = aLen ^ bLen
+  for (let i = 0; i < maxLen; i++) {
+    const aChar = i < aLen ? a.charCodeAt(i) : 0
+    const bChar = i < bLen ? b.charCodeAt(i) : 0
+    out |= aChar ^ bChar
+  }
+  return out === 0
+}
+
+type StringHashFunction = (input: string) => string | null | Promise<string | null>
+
+const timingSafeEqualString = async (
+  a: string,
+  b: string,
+  hashFunction?: StringHashFunction
+): Promise<boolean> => {
+  if (!hashFunction) {
+    hashFunction = sha256
+  }
+
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)])
+
+  if (sa == null || sb == null || typeof sa !== 'string' || typeof sb !== 'string') {
+    return false
+  }
+
+  const hashEqual = constantTimeEqualString(sa, sb)
+  const originalEqual = constantTimeEqualString(a, b)
+
+  return hashEqual && originalEqual
+}
+
+type TimingSafeEqual = {
+  (a: string, b: string, hashFunction?: StringHashFunction): Promise<boolean>
+  /**
+   * @deprecated object and boolean signatures that take boolean as first and second arguments, and functions with signatures that take non-string arguments have been deprecated
+   */
+  (
+    a: string | object | boolean,
+    b: string | object | boolean,
+    hashFunction?: Function
+  ): Promise<boolean>
+}
+export const timingSafeEqual: TimingSafeEqual = async (
+  a,
+  b,
+  hashFunction?: Function
+): Promise<boolean> => {
+  if (typeof a === 'string' && typeof b === 'string') {
+    return timingSafeEqualString(a, b, hashFunction as StringHashFunction)
+  }
+
+  if (!hashFunction) {
+    hashFunction = sha256
+  }
+
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)])
+
+  if (!sa || !sb || typeof sa !== 'string' || typeof sb !== 'string') {
+    return false
+  }
+
+  return timingSafeEqualString(sa, sb)
+}
+
+export const bufferToString = (buffer: ArrayBuffer): string => {
+  if (buffer instanceof ArrayBuffer) {
+    const enc = new TextDecoder('utf-8')
+    return enc.decode(buffer)
+  }
+  return buffer
+}
+
+export const bufferToFormData = (
+  arrayBuffer: ArrayBuffer,
+  contentType: string
+): Promise<FormData> => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      // Normalize the media type (case-insensitive) while keeping parameters like the boundary
+      'Content-Type': contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase()),
+    },
+  })
+  return response.formData()
+}

package/plugins/acryl-router/src/core/utils/color.test.ts

@@ -0,0 +1,23 @@
+import { getColorEnabled, getColorEnabledAsync } from './color.ts'
+
+describe('getColorEnabled() / getColorEnabledAsync() - With colors enabled', () => {
+  it('should return true', async () => {
+    expect(getColorEnabled()).toBe(true)
+    expect(await getColorEnabledAsync()).toBe(true)
+  })
+})
+
+describe('getColorEnabled() / getColorEnabledAsync() - With NO_COLOR environment variable set', () => {
+  beforeAll(() => {
+    vi.stubEnv('NO_COLOR', '1')
+  })
+
+  afterAll(() => {
+    vi.unstubAllEnvs()
+  })
+
+  it('should return false', async () => {
+    expect(getColorEnabled()).toBe(false)
+    expect(await getColorEnabledAsync()).toBe(false)
+  })
+})

package/plugins/acryl-router/src/core/utils/color.ts

@@ -0,0 +1,56 @@
+/**
+ * @module
+ * Color utility.
+ */
+
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * Unlike getColorEnabledAsync(), this cannot check Cloudflare environment variables.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+export function getColorEnabled(): boolean {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const { process, Deno } = globalThis as any
+
+  const isNoColor =
+    typeof Deno?.noColor === 'boolean'
+      ? (Deno.noColor as boolean)
+      : process !== undefined
+        ? // eslint-disable-next-line no-unsafe-optional-chaining
+          'NO_COLOR' in process?.env
+        : false
+
+  return !isNoColor
+}
+
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+export async function getColorEnabledAsync(): Promise<boolean> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const { navigator } = globalThis as any
+  // Avoid analysis of cloudflare scheme by bundlers
+  const cfWorkers = 'cloudflare:workers'
+
+  const isNoColor =
+    navigator !== undefined && navigator.userAgent === 'Cloudflare-Workers'
+      ? await (async () => {
+          try {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            return 'NO_COLOR' in ((await import(cfWorkers)).env ?? {}) // {} is for backward compat
+          } catch {
+            return false
+          }
+        })()
+      : !getColorEnabled()
+
+  return !isNoColor
+}

package/plugins/acryl-router/src/core/utils/compress.ts

@@ -0,0 +1,10 @@
+/**
+ * @module
+ * Constants for compression.
+ */
+
+/**
+ * Match for compressible content type.
+ */
+export const COMPRESSIBLE_CONTENT_TYPE_REGEX =
+  /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|msgpack|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|vnd\.msgpack|wasm|x-httpd-php|x-javascript|x-msgpack|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml|msgpack))(?:[;\s]|$)/i

package/plugins/acryl-router/src/core/utils/concurrent.test.ts

@@ -0,0 +1,69 @@
+import { createPool } from './concurrent.ts'
+
+describe('concurrent execution', () => {
+  test.each`
+    concurrency | count
+    ${1}        | ${10}
+    ${10}       | ${10}
+    ${100}      | ${10}
+    ${Infinity} | ${2000}
+  `('concurrency $concurrency, count $count', async ({ concurrency, count }) => {
+    const running = new Set()
+
+    const pool = createPool({ concurrency })
+    let resolve: (() => void) | undefined
+    const promise = new Promise<void>((r) => {
+      resolve = r
+    })
+    const fn = async (i: number) => {
+      if (running.size > concurrency) {
+        throw new Error('concurrency exceeded')
+      }
+
+      running.add(i)
+      await promise
+      running.delete(i)
+      return i
+    }
+
+    const jobs = new Array(count).fill(0).map((_, i) => () => fn(i))
+    const expectedResults = new Array(count).fill(0).map((_, i) => i)
+    const resultPromises = jobs.map((job) => pool.run(job))
+
+    expect(running.size).toBe(Math.min(concurrency, count))
+    resolve?.()
+    const results = await Promise.all(resultPromises)
+    expect(running.size).toBe(0)
+    expect(results).toEqual(expectedResults)
+  })
+
+  describe('with interval', () => {
+    test.each`
+      concurrency | interval
+      ${1}        | ${10}
+      ${2}        | ${10}
+    `('concurrency $concurrency, interval $interval', async ({ concurrency, interval }) => {
+      const workingTimeQueue: number[] = []
+      const pool = createPool({ concurrency, interval })
+      const fn = async (i: number) => {
+        const now = Date.now()
+        if (workingTimeQueue.length >= concurrency) {
+          const last = workingTimeQueue.shift()
+          // Not so accurate, -1 ms is acceptable
+          if (last && now - last < interval - 1) {
+            throw new Error('interval violated')
+          }
+        }
+        workingTimeQueue.push(now)
+        return i
+      }
+
+      const jobs = new Array(10).fill(0).map((_, i) => () => fn(i))
+      const expectedResults = new Array(10).fill(0).map((_, i) => i)
+      const resultPromises = jobs.map((job) => pool.run(job))
+
+      const results = await Promise.all(resultPromises)
+      expect(results).toEqual(expectedResults)
+    })
+  })
+})