bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/hono/src/utils/types.ts

@@ -0,0 +1,105 @@
+/**
+ * @module
+ * Types utility.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export type Expect<T extends true> = T
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+  ? true
+  : false
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true
+
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I
+) => void
+  ? I
+  : never
+
+export type RemoveBlankRecord<T> = T extends Record<infer K, unknown>
+  ? K extends string
+    ? T
+    : never
+  : never
+
+export type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T
+
+export type JSONPrimitive = string | boolean | number | null
+export type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[]
+export type JSONObject = {
+  [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue
+}
+export type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown)
+
+type InvalidToNull<T> = T extends InvalidJSONValue ? null : T
+
+type IsInvalid<T> = T extends InvalidJSONValue ? true : false
+
+/**
+ * symbol keys are omitted through `JSON.stringify`
+ */
+type OmitSymbolKeys<T> = { [K in keyof T as K extends symbol ? never : K]: T[K] }
+
+export type JSONValue = JSONObject | JSONArray | JSONPrimitive
+// Non-JSON values such as `Date` implement `.toJSON()`, so they can be transformed to a value assignable to `JSONObject`:
+export type JSONParsed<T> = T extends { toJSON(): infer J }
+  ? (() => J) extends () => JSONPrimitive
+    ? J
+    : (() => J) extends () => { toJSON(): unknown }
+    ? {}
+    : JSONParsed<J>
+  : T extends JSONPrimitive
+  ? T
+  : T extends InvalidJSONValue
+  ? never
+  : T extends []
+  ? []
+  : T extends readonly [infer R, ...infer U]
+  ? [JSONParsed<InvalidToNull<R>>, ...JSONParsed<U>]
+  : T extends Array<infer U>
+  ? Array<JSONParsed<InvalidToNull<U>>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<JSONParsed<InvalidToNull<U>>>
+  : T extends Set<unknown> | Map<unknown, unknown>
+  ? {}
+  : T extends object
+  ? {
+      [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true
+        ? never
+        : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K]> | undefined : JSONParsed<T[K]>
+    }
+  : never
+
+/**
+ * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+ * @copyright from sindresorhus/type-fest
+ */
+export type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {}
+
+/**
+ * A simple extension of Simplify that will deeply traverse array elements.
+ */
+export type SimplifyDeepArray<T> = T extends any[]
+  ? { [E in keyof T]: SimplifyDeepArray<T[E]> }
+  : Simplify<T>
+
+export type InterfaceToType<T> = T extends Function ? T : { [K in keyof T]: InterfaceToType<T[K]> }
+
+export type RequiredKeysOf<BaseType extends object> = Exclude<
+  {
+    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never
+  }[keyof BaseType],
+  undefined
+>
+
+export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never
+  ? false
+  : true
+
+export type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false
+
+/**
+ * String literal types with auto-completion
+ * @see https://github.com/Microsoft/TypeScript/issues/29729
+ */
+export type StringLiteralUnion<T> = T | (string & Record<never, never>)

package/tests/fixtures/corpus/oss-repos/hono/src/utils/url.ts

@@ -0,0 +1,310 @@
+/**
+ * @module
+ * URL utility.
+ */
+
+export type Pattern = readonly [string, string, RegExp | true] | '*'
+
+export const splitPath = (path: string): string[] => {
+  const paths = path.split('/')
+  if (paths[0] === '') {
+    paths.shift()
+  }
+  return paths
+}
+
+export const splitRoutingPath = (routePath: string): string[] => {
+  const { groups, path } = extractGroupsFromPath(routePath)
+
+  const paths = splitPath(path)
+  return replaceGroupMarks(paths, groups)
+}
+
+const extractGroupsFromPath = (path: string): { groups: [string, string][]; path: string } => {
+  const groups: [string, string][] = []
+
+  path = path.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`
+    groups.push([mark, match])
+    return mark
+  })
+
+  return { groups, path }
+}
+
+const replaceGroupMarks = (paths: string[], groups: [string, string][]): string[] => {
+  for (let i = groups.length - 1; i >= 0; i--) {
+    const [mark] = groups[i]
+
+    for (let j = paths.length - 1; j >= 0; j--) {
+      if (paths[j].includes(mark)) {
+        paths[j] = paths[j].replace(mark, groups[i][1])
+        break
+      }
+    }
+  }
+
+  return paths
+}
+
+const patternCache: { [key: string]: Pattern } = {}
+export const getPattern = (label: string): Pattern | null => {
+  // *            => wildcard
+  // :id{[0-9]+}  => ([0-9]+)
+  // :id          => (.+)
+  //const name = ''
+
+  if (label === '*') {
+    return '*'
+  }
+
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/)
+  if (match) {
+    if (!patternCache[label]) {
+      if (match[2]) {
+        patternCache[label] = [label, match[1], new RegExp('^' + match[2] + '$')]
+      } else {
+        patternCache[label] = [label, match[1], true]
+      }
+    }
+
+    return patternCache[label]
+  }
+
+  return null
+}
+
+/**
+ * Try to apply decodeURI() to given string.
+ * If it fails, skip invalid percent encoding or invalid UTF-8 sequences, and apply decodeURI() to the rest as much as possible.
+ * @param str The string to decode.
+ * @returns The decoded string that sometimes contains undecodable percent encoding.
+ * @example
+ * tryDecodeURI('Hello%20World') // 'Hello World'
+ * tryDecodeURI('Hello%20World/%A4%A2') // 'Hello World/%A4%A2'
+ */
+const tryDecodeURI = (str: string): string => {
+  try {
+    return decodeURI(str)
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decodeURI(match)
+      } catch {
+        return match
+      }
+    })
+  }
+}
+
+export const getPath = (request: Request): string => {
+  const url = request.url
+  const start = url.indexOf('/', 8)
+  let i = start
+  for (; i < url.length; i++) {
+    const charCode = url.charCodeAt(i)
+    if (charCode === 37) {
+      // '%'
+      // If the path contains percent encoding, use `indexOf()` to find '?' and return the result immediately.
+      // Although this is a performance disadvantage, it is acceptable since we prefer cases that do not include percent encoding.
+      const queryIndex = url.indexOf('?', i)
+      const path = url.slice(start, queryIndex === -1 ? undefined : queryIndex)
+      return tryDecodeURI(path.includes('%25') ? path.replace(/%25/g, '%2525') : path)
+    } else if (charCode === 63) {
+      // '?'
+      break
+    }
+  }
+  return url.slice(start, i)
+}
+
+export const getQueryStrings = (url: string): string => {
+  const queryIndex = url.indexOf('?', 8)
+  return queryIndex === -1 ? '' : '?' + url.slice(queryIndex + 1)
+}
+
+export const getPathNoStrict = (request: Request): string => {
+  const result = getPath(request)
+
+  // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
+  return result.length > 1 && result[result.length - 1] === '/' ? result.slice(0, -1) : result
+}
+
+export const mergePath = (...paths: string[]): string => {
+  let p: string = ''
+  let endsWithSlash = false
+
+  for (let path of paths) {
+    /* ['/hey/','/say'] => ['/hey', '/say'] */
+    if (p[p.length - 1] === '/') {
+      p = p.slice(0, -1)
+      endsWithSlash = true
+    }
+
+    /* ['/hey','say'] => ['/hey', '/say'] */
+    if (path[0] !== '/') {
+      path = `/${path}`
+    }
+
+    /* ['/hey/', '/'] => `/hey/` */
+    if (path === '/' && endsWithSlash) {
+      p = `${p}/`
+    } else if (path !== '/') {
+      p = `${p}${path}`
+    }
+
+    /* ['/', '/'] => `/` */
+    if (path === '/' && p === '') {
+      p = '/'
+    }
+  }
+
+  return p
+}
+
+export const checkOptionalParameter = (path: string): string[] | null => {
+  /*
+   If path is `/api/animals/:type?` it will return:
+   [`/api/animals`, `/api/animals/:type`]
+   in other cases it will return null
+  */
+
+  if (!path.match(/\:.+\?$/)) {
+    return null
+  }
+
+  const segments = path.split('/')
+  const results: string[] = []
+  let basePath = ''
+
+  segments.forEach((segment) => {
+    if (segment !== '' && !/\:/.test(segment)) {
+      basePath += '/' + segment
+    } else if (/\:/.test(segment)) {
+      if (/\?/.test(segment)) {
+        if (results.length === 0 && basePath === '') {
+          results.push('/')
+        } else {
+          results.push(basePath)
+        }
+        const optionalSegment = segment.replace('?', '')
+        basePath += '/' + optionalSegment
+        results.push(basePath)
+      } else {
+        basePath += '/' + segment
+      }
+    }
+  })
+
+  return results.filter((v, i, a) => a.indexOf(v) === i)
+}
+
+// Optimized
+const _decodeURI = (value: string) => {
+  if (!/[%+]/.test(value)) {
+    return value
+  }
+  if (value.indexOf('+') !== -1) {
+    value = value.replace(/\+/g, ' ')
+  }
+  return /%/.test(value) ? decodeURIComponent_(value) : value
+}
+
+const _getQueryParam = (
+  url: string,
+  key?: string,
+  multiple?: boolean
+): string | undefined | Record<string, string> | string[] | Record<string, string[]> => {
+  let encoded
+
+  if (!multiple && key && !/[%+]/.test(key)) {
+    // optimized for unencoded key
+
+    let keyIndex = url.indexOf(`?${key}`, 8)
+    if (keyIndex === -1) {
+      keyIndex = url.indexOf(`&${key}`, 8)
+    }
+    while (keyIndex !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex + key.length + 1)
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex + key.length + 2
+        const endIndex = url.indexOf('&', valueIndex)
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? undefined : endIndex))
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return ''
+      }
+      keyIndex = url.indexOf(`&${key}`, keyIndex + 1)
+    }
+
+    encoded = /[%+]/.test(url)
+    if (!encoded) {
+      return undefined
+    }
+    // fallback to default routine
+  }
+
+  const results: Record<string, string> | Record<string, string[]> = {}
+  encoded ??= /[%+]/.test(url)
+
+  let keyIndex = url.indexOf('?', 8)
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf('&', keyIndex + 1)
+    let valueIndex = url.indexOf('=', keyIndex)
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1
+    }
+    let name = url.slice(
+      keyIndex + 1,
+      valueIndex === -1 ? (nextKeyIndex === -1 ? undefined : nextKeyIndex) : valueIndex
+    )
+    if (encoded) {
+      name = _decodeURI(name)
+    }
+
+    keyIndex = nextKeyIndex
+
+    if (name === '') {
+      continue
+    }
+
+    let value
+    if (valueIndex === -1) {
+      value = ''
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? undefined : nextKeyIndex)
+      if (encoded) {
+        value = _decodeURI(value)
+      }
+    }
+
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = []
+      }
+      ;(results[name] as string[]).push(value)
+    } else {
+      results[name] ??= value
+    }
+  }
+
+  return key ? results[key] : results
+}
+
+export const getQueryParam: (
+  url: string,
+  key?: string
+) => string | undefined | Record<string, string> = _getQueryParam as (
+  url: string,
+  key?: string
+) => string | undefined | Record<string, string>
+
+export const getQueryParams = (
+  url: string,
+  key?: string
+): string[] | undefined | Record<string, string[]> => {
+  return _getQueryParam(url, key, true) as string[] | undefined | Record<string, string[]>
+}
+
+// `decodeURIComponent` is a long name.
+// By making it a function, we can use it commonly when minified, reducing the amount of code.
+export const decodeURIComponent_ = decodeURIComponent

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

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Validator for Hono.
+ */
+
+export { validator } from './validator'
+export type { ValidationFunction } from './validator'

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

@@ -0,0 +1,151 @@
+import type { Context } from '../context'
+import { getCookie } from '../helper/cookie'
+import { HTTPException } from '../http-exception'
+import type { Env, MiddlewareHandler, TypedResponse, ValidationTargets } from '../types'
+import type { BodyData } from '../utils/body'
+import { bufferToFormData } from '../utils/buffer'
+
+type ValidationTargetKeysWithBody = 'form' | 'json'
+type ValidationTargetByMethod<M> = M extends 'get' | 'head' // GET and HEAD request must not have a body content.
+  ? Exclude<keyof ValidationTargets, ValidationTargetKeysWithBody>
+  : keyof ValidationTargets
+
+export type ValidationFunction<
+  InputType,
+  OutputType,
+  E extends Env = {},
+  P extends string = string
+> = (
+  value: InputType,
+  c: Context<E, P>
+) => OutputType | Response | Promise<OutputType> | Promise<Response>
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type ExcludeResponseType<T> = T extends Response & TypedResponse<any> ? never : T
+
+const jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/
+const multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/
+const urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/
+
+export const validator = <
+  InputType,
+  P extends string,
+  M extends string,
+  U extends ValidationTargetByMethod<M>,
+  OutputType = ValidationTargets[U],
+  OutputTypeExcludeResponseType = ExcludeResponseType<OutputType>,
+  P2 extends string = P,
+  V extends {
+    in: {
+      [K in U]: K extends 'json'
+        ? unknown extends InputType
+          ? OutputTypeExcludeResponseType
+          : InputType
+        : { [K2 in keyof OutputTypeExcludeResponseType]: ValidationTargets[K][K2] }
+    }
+    out: { [K in U]: OutputTypeExcludeResponseType }
+  } = {
+    in: {
+      [K in U]: K extends 'json'
+        ? unknown extends InputType
+          ? OutputTypeExcludeResponseType
+          : InputType
+        : { [K2 in keyof OutputTypeExcludeResponseType]: ValidationTargets[K][K2] }
+    }
+    out: { [K in U]: OutputTypeExcludeResponseType }
+  },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E extends Env = any
+>(
+  target: U,
+  validationFunc: ValidationFunction<
+    unknown extends InputType ? ValidationTargets[U] : InputType,
+    OutputType,
+    E,
+    P2
+  >
+): MiddlewareHandler<E, P, V> => {
+  return async (c, next) => {
+    let value = {}
+    const contentType = c.req.header('Content-Type')
+
+    switch (target) {
+      case 'json':
+        if (!contentType || !jsonRegex.test(contentType)) {
+          break
+        }
+        try {
+          value = await c.req.json()
+        } catch {
+          const message = 'Malformed JSON in request body'
+          throw new HTTPException(400, { message })
+        }
+        break
+      case 'form': {
+        if (
+          !contentType ||
+          !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))
+        ) {
+          break
+        }
+
+        let formData: FormData
+
+        if (c.req.bodyCache.formData) {
+          formData = await c.req.bodyCache.formData
+        } else {
+          try {
+            const arrayBuffer = await c.req.arrayBuffer()
+            formData = await bufferToFormData(arrayBuffer, contentType)
+            c.req.bodyCache.formData = formData
+          } catch (e) {
+            let message = 'Malformed FormData request.'
+            message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`
+            throw new HTTPException(400, { message })
+          }
+        }
+
+        const form: BodyData<{ all: true }> = {}
+        formData.forEach((value, key) => {
+          if (key.endsWith('[]')) {
+            ;((form[key] ??= []) as unknown[]).push(value)
+          } else if (Array.isArray(form[key])) {
+            ;(form[key] as unknown[]).push(value)
+          } else if (key in form) {
+            form[key] = [form[key] as string | File, value]
+          } else {
+            form[key] = value
+          }
+        })
+        value = form
+        break
+      }
+      case 'query':
+        value = Object.fromEntries(
+          Object.entries(c.req.queries()).map(([k, v]) => {
+            return v.length === 1 ? [k, v[0]] : [k, v]
+          })
+        )
+        break
+      case 'param':
+        value = c.req.param() as Record<string, string>
+        break
+      case 'header':
+        value = c.req.header()
+        break
+      case 'cookie':
+        value = getCookie(c)
+        break
+    }
+
+    const res = await validationFunc(value as never, c as never)
+
+    if (res instanceof Response) {
+      return res
+    }
+
+    c.req.addValidatedData(target, res as never)
+
+    await next()
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/tsconfig.build.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "rootDir": "./src/",
+    "outDir": "./dist/types/",
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.mts"
+  ],
+  "exclude": [
+    "src/mod.ts",
+    "src/helper.ts",
+    "src/middleware.ts",
+    "src/deno/**/*.ts",
+    "src/test-utils/*.ts",
+    "src/**/*.test.ts",
+    "src/**/*.test.tsx"
+  ]
+}

package/tests/fixtures/corpus/oss-repos/hono/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "declaration": true,
+    "moduleResolution": "Bundler",
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "types": [
+      "node",
+      "vitest/globals"
+    ],
+    "jsx": "react",
+    "jsxFactory": "jsx",
+    "jsxFragmentFactory": "Fragment",
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.d.ts",
+    "src/**/*.mts",
+    "src/**/*.test.ts",
+    "src/**/*.test.tsx"
+  ],
+}

package/tests/fixtures/corpus/oss-repos/hono/vitest.config.ts

@@ -0,0 +1,34 @@
+/// <reference types="vitest" />
+import { configDefaults, defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  esbuild: {
+    jsx: 'automatic',
+    jsxImportSource: __dirname + '/../src/jsx',
+  },
+  test: {
+    globals: true,
+    include: ['**/src/**/(*.)+(spec|test).+(ts|tsx|js)'],
+    exclude: [...configDefaults.exclude, '**/sandbox/**', '**/*.case.test.+(ts|tsx|js)'],
+    setupFiles: ['./.vitest.config/setup-vitest.ts'],
+    coverage: {
+      enabled: true,
+      provider: 'v8',
+      reportsDirectory: './coverage/raw/default',
+      reporter: ['json', 'text', 'html'],
+      exclude: [
+        ...(configDefaults.coverage.exclude ?? []),
+        'benchmarks',
+        'runtime_tests',
+        'build.ts',
+        'src/test-utils',
+
+        // types are compile-time only, so their coverage cannot be measured
+        'src/**/types.ts',
+        'src/jsx/intrinsic-elements.ts',
+        'src/utils/http-status.ts',
+      ],
+    },
+    pool: 'forks',
+  },
+})