bluera-knowledge 0.14.0 → 0.14.1

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

@@ -1,26 +0,0 @@
-import { decodeBase64 } from './encode'
-
-const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/
-const USER_PASS_REGEXP = /^([^:]*):(.*)$/
-const utf8Decoder = new TextDecoder()
-
-export type Auth = (req: Request) => { username: string; password: string } | undefined
-
-export const auth: Auth = (req: Request) => {
-  const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization') || '')
-  if (!match) {
-    return undefined
-  }
-
-  let userPass = undefined
-  // If an invalid string is passed to atob(), it throws a `DOMException`.
-  try {
-    userPass = USER_PASS_REGEXP.exec(utf8Decoder.decode(decodeBase64(match[1])))
-  } catch {} // Do nothing
-
-  if (!userPass) {
-    return undefined
-  }
-
-  return { username: userPass[1], password: userPass[2] }
-}

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

@@ -1,225 +0,0 @@
-/**
- * @module
- * Body utility.
- */
-
-import { HonoRequest } from '../request'
-
-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
-}
-
-/**
- * Parses the body of a request based on the provided options.
- *
- * @template T - The type of the parsed body data.
- * @param {HonoRequest | 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: HonoRequest | Request,
-    options?: Options
-  ): Promise<T>
-  <T extends BodyData>(
-    request: HonoRequest | Request,
-    options?: Partial<ParseBodyOptions>
-  ): Promise<T>
-}
-export const parseBody: ParseBody = async (
-  request: HonoRequest | Request,
-  options = Object.create(null)
-) => {
-  const { all = false, dot = false } = options
-
-  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers
-  const contentType = headers.get('Content-Type')
-
-  if (
-    contentType?.startsWith('multipart/form-data') ||
-    contentType?.startsWith('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 {HonoRequest | 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: HonoRequest | Request,
-  options: ParseBodyOptions
-): Promise<T> {
-  const formData = await (request as Request).formData()
-
-  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)
-
-  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)
-        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 {
-    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>>
-): void => {
-  let nestedForm = form
-  const keys = key.split('.')
-
-  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
-      ) {
-        nestedForm[key] = Object.create(null)
-      }
-      nestedForm = nestedForm[key] as unknown as BodyData
-    }
-  })
-}

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

@@ -1,65 +0,0 @@
-/**
- * @module
- * Buffer utility.
- */
-
-import { sha256 } from './crypto'
-
-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
-}
-
-export const timingSafeEqual = async (
-  a: string | object | boolean,
-  b: string | object | boolean,
-  hashFunction?: Function
-): Promise<boolean> => {
-  if (!hashFunction) {
-    hashFunction = sha256
-  }
-
-  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)])
-
-  if (!sa || !sb) {
-    return false
-  }
-
-  return sa === sb && a === b
-}
-
-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: {
-      'Content-Type': contentType,
-    },
-  })
-  return response.formData()
-}

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

@@ -1,26 +0,0 @@
-/**
- * @module
- * Color utility.
- */
-
-/**
- * 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 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)
-      : typeof process !== 'undefined'
-        ? // eslint-disable-next-line no-unsafe-optional-chaining
-          'NO_COLOR' in process?.env
-        : false
-
-  return !isNoColor
-}

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

@@ -1,55 +0,0 @@
-/**
- * @module
- * Concurrent utility.
- */
-
-const DEFAULT_CONCURRENCY = 1024
-
-export interface Pool {
-  run<T>(fn: () => T): Promise<T>
-}
-
-export const createPool = ({
-  concurrency,
-  interval,
-}: {
-  concurrency?: number
-  interval?: number
-} = {}): Pool => {
-  concurrency ||= DEFAULT_CONCURRENCY
-
-  if (concurrency === Infinity) {
-    // unlimited
-    return {
-      run: async (fn) => fn(),
-    }
-  }
-
-  const pool: Set<{}> = new Set()
-  const run = async <T>(
-    fn: () => T,
-    promise?: Promise<T>,
-    resolve?: (result: T) => void
-  ): Promise<T> => {
-    if (pool.size >= (concurrency as number)) {
-      promise ||= new Promise<T>((r) => (resolve = r))
-      setTimeout(() => run(fn, promise, resolve))
-      return promise
-    }
-    const marker = {}
-    pool.add(marker)
-    const result = await fn()
-    if (interval) {
-      setTimeout(() => pool.delete(marker), interval)
-    } else {
-      pool.delete(marker)
-    }
-    if (resolve) {
-      resolve(result)
-      return promise as Promise<T>
-    } else {
-      return result
-    }
-  }
-  return { run }
-}

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

@@ -1,230 +0,0 @@
-/**
- * @module
- * Cookie utility.
- */
-
-import { decodeURIComponent_ } from './url'
-
-export type Cookie = Record<string, string>
-export type SignedCookie = Record<string, string | false>
-
-type PartitionCookieConstraint =
-  | { partition: true; secure: true }
-  | { partition?: boolean; secure?: boolean } // reset to default
-type SecureCookieConstraint = { secure: true }
-type HostCookieConstraint = { secure: true; path: '/'; domain?: undefined }
-
-export type CookieOptions = {
-  domain?: string
-  expires?: Date
-  httpOnly?: boolean
-  maxAge?: number
-  path?: string
-  secure?: boolean
-  signingSecret?: string
-  sameSite?: 'Strict' | 'Lax' | 'None' | 'strict' | 'lax' | 'none'
-  partitioned?: boolean
-  prefix?: CookiePrefixOptions
-} & PartitionCookieConstraint
-export type CookiePrefixOptions = 'host' | 'secure'
-
-export type CookieConstraint<Name> = Name extends `__Secure-${string}`
-  ? CookieOptions & SecureCookieConstraint
-  : Name extends `__Host-${string}`
-    ? CookieOptions & HostCookieConstraint
-    : CookieOptions
-
-const algorithm = { name: 'HMAC', hash: 'SHA-256' }
-
-const getCryptoKey = async (secret: string | BufferSource): Promise<CryptoKey> => {
-  const secretBuf = typeof secret === 'string' ? new TextEncoder().encode(secret) : secret
-  return await crypto.subtle.importKey('raw', secretBuf, algorithm, false, ['sign', 'verify'])
-}
-
-const makeSignature = async (value: string, secret: string | BufferSource): Promise<string> => {
-  const key = await getCryptoKey(secret)
-  const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value))
-  // the returned base64 encoded signature will always be 44 characters long and end with one or two equal signs
-  return btoa(String.fromCharCode(...new Uint8Array(signature)))
-}
-
-const verifySignature = async (
-  base64Signature: string,
-  value: string,
-  secret: CryptoKey
-): Promise<boolean> => {
-  try {
-    const signatureBinStr = atob(base64Signature)
-    const signature = new Uint8Array(signatureBinStr.length)
-    for (let i = 0, len = signatureBinStr.length; i < len; i++) {
-      signature[i] = signatureBinStr.charCodeAt(i)
-    }
-    return await crypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value))
-  } catch (e) {
-    return false
-  }
-}
-
-// all alphanumeric chars and all of _!#$%&'*.^`|~+-
-// (see: https://datatracker.ietf.org/doc/html/rfc6265#section-4.1.1)
-const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/
-
-// all ASCII chars 32-126 except 34, 59, and 92 (i.e. space to tilde but not double quote, semicolon, or backslash)
-// (see: https://datatracker.ietf.org/doc/html/rfc6265#section-4.1.1)
-//
-// note: the spec also prohibits comma and space, but we allow both since they are very common in the real world
-// (see: https://github.com/golang/go/issues/7243)
-const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/
-
-export const parse = (cookie: string, name?: string): Cookie => {
-  const pairs = cookie.trim().split(';')
-  return pairs.reduce((parsedCookie, pairStr) => {
-    pairStr = pairStr.trim()
-    const valueStartPos = pairStr.indexOf('=')
-    if (valueStartPos === -1) {
-      return parsedCookie
-    }
-
-    const cookieName = pairStr.substring(0, valueStartPos).trim()
-    if ((name && name !== cookieName) || !validCookieNameRegEx.test(cookieName)) {
-      return parsedCookie
-    }
-
-    let cookieValue = pairStr.substring(valueStartPos + 1).trim()
-    if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) {
-      cookieValue = cookieValue.slice(1, -1)
-    }
-    if (validCookieValueRegEx.test(cookieValue)) {
-      parsedCookie[cookieName] = decodeURIComponent_(cookieValue)
-    }
-
-    return parsedCookie
-  }, {} as Cookie)
-}
-
-export const parseSigned = async (
-  cookie: string,
-  secret: string | BufferSource,
-  name?: string
-): Promise<SignedCookie> => {
-  const parsedCookie: SignedCookie = {}
-  const secretKey = await getCryptoKey(secret)
-
-  for (const [key, value] of Object.entries(parse(cookie, name))) {
-    const signatureStartPos = value.lastIndexOf('.')
-    if (signatureStartPos < 1) {
-      continue
-    }
-
-    const signedValue = value.substring(0, signatureStartPos)
-    const signature = value.substring(signatureStartPos + 1)
-    if (signature.length !== 44 || !signature.endsWith('=')) {
-      continue
-    }
-
-    const isVerified = await verifySignature(signature, signedValue, secretKey)
-    parsedCookie[key] = isVerified ? signedValue : false
-  }
-
-  return parsedCookie
-}
-
-const _serialize = (name: string, value: string, opt: CookieOptions = {}): string => {
-  let cookie = `${name}=${value}`
-
-  if (name.startsWith('__Secure-') && !opt.secure) {
-    // FIXME: replace link to RFC
-    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-13#section-4.1.3.1
-    throw new Error('__Secure- Cookie must have Secure attributes')
-  }
-
-  if (name.startsWith('__Host-')) {
-    // FIXME: replace link to RFC
-    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-13#section-4.1.3.2
-    if (!opt.secure) {
-      throw new Error('__Host- Cookie must have Secure attributes')
-    }
-
-    if (opt.path !== '/') {
-      throw new Error('__Host- Cookie must have Path attributes with "/"')
-    }
-
-    if (opt.domain) {
-      throw new Error('__Host- Cookie must not have Domain attributes')
-    }
-  }
-
-  if (opt && typeof opt.maxAge === 'number' && opt.maxAge >= 0) {
-    if (opt.maxAge > 34560000) {
-      // FIXME: replace link to RFC
-      // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-13#section-4.1.2.2
-      throw new Error(
-        'Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.'
-      )
-    }
-    cookie += `; Max-Age=${Math.floor(opt.maxAge)}`
-  }
-
-  if (opt.domain && opt.prefix !== 'host') {
-    cookie += `; Domain=${opt.domain}`
-  }
-
-  if (opt.path) {
-    cookie += `; Path=${opt.path}`
-  }
-
-  if (opt.expires) {
-    if (opt.expires.getTime() - Date.now() > 34560000_000) {
-      // FIXME: replace link to RFC
-      // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis-13#section-4.1.2.1
-      throw new Error(
-        'Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.'
-      )
-    }
-    cookie += `; Expires=${opt.expires.toUTCString()}`
-  }
-
-  if (opt.httpOnly) {
-    cookie += '; HttpOnly'
-  }
-
-  if (opt.secure) {
-    cookie += '; Secure'
-  }
-
-  if (opt.sameSite) {
-    cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`
-  }
-
-  if (opt.partitioned) {
-    // FIXME: replace link to RFC
-    // https://www.ietf.org/archive/id/draft-cutler-httpbis-partitioned-cookies-01.html#section-2.3
-    if (!opt.secure) {
-      throw new Error('Partitioned Cookie must have Secure attributes')
-    }
-    cookie += '; Partitioned'
-  }
-
-  return cookie
-}
-
-export const serialize = <Name extends string>(
-  name: Name,
-  value: string,
-  opt?: CookieConstraint<Name>
-): string => {
-  value = encodeURIComponent(value)
-  return _serialize(name, value, opt)
-}
-
-export const serializeSigned = async (
-  name: string,
-  value: string,
-  secret: string | BufferSource,
-  opt: CookieOptions = {}
-): Promise<string> => {
-  const signature = await makeSignature(value, secret)
-  value = `${value}.${signature}`
-  value = encodeURIComponent(value)
-  return _serialize(name, value, opt)
-}

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

@@ -1,65 +0,0 @@
-/**
- * @module
- * Crypto utility.
- */
-
-type Algorithm = {
-  name: string
-  alias: string
-}
-
-type Data = string | boolean | number | object | ArrayBufferView | ArrayBuffer | ReadableStream
-
-export const sha256 = async (data: Data): Promise<string | null> => {
-  const algorithm: Algorithm = { name: 'SHA-256', alias: 'sha256' }
-  const hash = await createHash(data, algorithm)
-  return hash
-}
-
-export const sha1 = async (data: Data): Promise<string | null> => {
-  const algorithm: Algorithm = { name: 'SHA-1', alias: 'sha1' }
-  const hash = await createHash(data, algorithm)
-  return hash
-}
-
-export const md5 = async (data: Data): Promise<string | null> => {
-  const algorithm: Algorithm = { name: 'MD5', alias: 'md5' }
-  const hash = await createHash(data, algorithm)
-  return hash
-}
-
-export const createHash = async (data: Data, algorithm: Algorithm): Promise<string | null> => {
-  let sourceBuffer: ArrayBufferView | ArrayBuffer
-
-  if (data instanceof ReadableStream) {
-    let body = ''
-    const reader = data.getReader()
-    await reader?.read().then(async (chuck) => {
-      const value = await createHash(chuck.value || '', algorithm)
-      body += value
-    })
-    return body
-  }
-  if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) {
-    sourceBuffer = data
-  } else {
-    if (typeof data === 'object') {
-      data = JSON.stringify(data)
-    }
-    sourceBuffer = new TextEncoder().encode(String(data))
-  }
-
-  if (crypto && crypto.subtle) {
-    const buffer = await crypto.subtle.digest(
-      {
-        name: algorithm.name,
-      },
-      sourceBuffer as ArrayBuffer
-    )
-    const hash = Array.prototype.map
-      .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
-      .join('')
-    return hash
-  }
-  return null
-}