bluera-knowledge 0.14.0 → 0.14.2

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

@@ -1,102 +0,0 @@
-/**
- * @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

@@ -1,310 +0,0 @@
-/**
- * @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

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

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

@@ -1,151 +0,0 @@
-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

@@ -1,23 +0,0 @@
-{
-  "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

@@ -1,28 +0,0 @@
-{
-  "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

@@ -1,34 +0,0 @@
-/// <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',
-  },
-})