bluera-knowledge 0.14.0 → 0.14.2

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

@@ -1,84 +0,0 @@
-import type { Context } from '../../context'
-
-export type AcceptHeader =
-  | 'Accept'
-  | 'Accept-Charset'
-  | 'Accept-Encoding'
-  | 'Accept-Language'
-  | 'Accept-Patch'
-  | 'Accept-Post'
-  | 'Accept-Ranges'
-
-export interface Accept {
-  type: string
-  params: Record<string, string>
-  q: number
-}
-
-export interface acceptsConfig {
-  header: AcceptHeader
-  supports: string[]
-  default: string
-}
-
-export interface acceptsOptions extends acceptsConfig {
-  match?: (accepts: Accept[], config: acceptsConfig) => string
-}
-
-export const parseAccept = (acceptHeader: string): Accept[] => {
-  // Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
-  const accepts = acceptHeader.split(',') // ['text/html', 'application/xhtml+xml', 'application/xml;q=0.9', 'image/webp', '*/*;q=0.8']
-  return accepts.map((accept) => {
-    const parts = accept.trim().split(';') // ['text/html', 'q=0.9', 'image/webp']
-    const type = parts[0] // text/html
-    const params = parts.slice(1) // ['q=0.9', 'image/webp']
-    const q = params.find((param) => param.startsWith('q='))
-
-    const paramsObject = params.reduce(
-      (acc, param) => {
-        const keyValue = param.split('=')
-        const key = keyValue[0].trim()
-        const value = keyValue[1].trim()
-        acc[key] = value
-        return acc
-      },
-      {} as { [key: string]: string }
-    )
-
-    return {
-      type: type,
-      params: paramsObject,
-      q: q ? parseFloat(q.split('=')[1]) : 1,
-    }
-  })
-}
-
-export const defaultMatch = (accepts: Accept[], config: acceptsConfig): string => {
-  const { supports, default: defaultSupport } = config
-  const accept = accepts.sort((a, b) => b.q - a.q).find((accept) => supports.includes(accept.type))
-  return accept ? accept.type : defaultSupport
-}
-
-/**
- * Match the accept header with the given options.
- * @example
- * ```ts
- * app.get('/users', (c) => {
- *   const lang = accepts(c, {
- *     header: 'Accept-Language',
- *     supports: ['en', 'zh'],
- *     default: 'en',
- *   })
- * })
- * ```
- */
-export const accepts = (c: Context, options: acceptsOptions): string => {
-  const acceptHeader = c.req.header(options.header)
-  if (!acceptHeader) {
-    return options.default
-  }
-  const accepts = parseAccept(acceptHeader)
-  const match = options.match || defaultMatch
-
-  return match(accepts, options)
-}

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

@@ -1,6 +0,0 @@
-/**
- * @module
- * Accepts Helper for Hono.
- */
-
-export { accepts } from './accepts'

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

@@ -1,85 +0,0 @@
-/**
- * @module
- * Adapter Helper for Hono.
- */
-
-import type { Context } from '../../context'
-
-export type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | 'other'
-
-export const env = <T extends Record<string, unknown>, C extends Context = Context<{}>>(
-  c: C,
-  runtime?: Runtime
-): T & C['env'] => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const global = globalThis as any
-  const globalEnv = global?.process?.env as T
-
-  runtime ??= getRuntimeKey()
-
-  const runtimeEnvHandlers: Record<string, () => T> = {
-    bun: () => globalEnv,
-    node: () => globalEnv,
-    'edge-light': () => globalEnv,
-    deno: () => {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      return Deno.env.toObject() as T
-    },
-    workerd: () => c.env,
-    // On Fastly Compute, you can use the ConfigStore to manage user-defined data.
-    fastly: () => ({}) as T,
-    other: () => ({}) as T,
-  }
-
-  return runtimeEnvHandlers[runtime]()
-}
-
-export const knownUserAgents: Partial<Record<Runtime, string>> = {
-  deno: 'Deno',
-  bun: 'Bun',
-  workerd: 'Cloudflare-Workers',
-  node: 'Node.js',
-}
-
-export const getRuntimeKey = (): Runtime => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const global = globalThis as any
-
-  // check if the current runtime supports navigator.userAgent
-  const userAgentSupported =
-    typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string'
-
-  // if supported, check the user agent
-  if (userAgentSupported) {
-    for (const [runtimeKey, userAgent] of Object.entries(knownUserAgents)) {
-      if (checkUserAgentEquals(userAgent)) {
-        return runtimeKey as Runtime
-      }
-    }
-  }
-
-  // check if running on Edge Runtime
-  if (typeof global?.EdgeRuntime === 'string') {
-    return 'edge-light'
-  }
-
-  // check if running on Fastly
-  if (global?.fastly !== undefined) {
-    return 'fastly'
-  }
-
-  // userAgent isn't supported before Node v21.1.0; so fallback to the old way
-  if (global?.process?.release?.name === 'node') {
-    return 'node'
-  }
-
-  // couldn't detect the runtime
-  return 'other'
-}
-
-export const checkUserAgentEquals = (platform: string): boolean => {
-  const userAgent = navigator.userAgent
-
-  return userAgent.startsWith(platform)
-}

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

@@ -1,6 +0,0 @@
-/**
- * @module
- * ConnInfo Helper for Hono.
- */
-
-export type { AddressType, NetAddrInfo, ConnInfo, GetConnInfo } from './types'

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

@@ -1,45 +0,0 @@
-import type { Context } from '../../context'
-
-export type AddressType = 'IPv6' | 'IPv4' | undefined
-
-export type NetAddrInfo = {
-  /**
-   * Transport protocol type
-   */
-  transport?: 'tcp' | 'udp'
-  /**
-   * Transport port number
-   */
-  port?: number
-
-  address?: string
-  addressType?: AddressType
-} & (
-  | {
-      /**
-       * Host name such as IP Addr
-       */
-      address: string
-
-      /**
-       * Host name type
-       */
-      addressType: AddressType
-    }
-  | {}
-)
-
-/**
- * HTTP Connection information
- */
-export interface ConnInfo {
-  /**
-   * Remote information
-   */
-  remote: NetAddrInfo
-}
-
-/**
- * Helper type
- */
-export type GetConnInfo = (c: Context) => ConnInfo

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

@@ -1,130 +0,0 @@
-/**
- * @module
- * Cookie Helper for Hono.
- */
-
-import type { Context } from '../../context'
-import { parse, parseSigned, serialize, serializeSigned } from '../../utils/cookie'
-import type { Cookie, CookieOptions, CookiePrefixOptions, SignedCookie } from '../../utils/cookie'
-
-interface GetCookie {
-  (c: Context, key: string): string | undefined
-  (c: Context): Cookie
-  (c: Context, key: string, prefixOptions: CookiePrefixOptions): string | undefined
-}
-
-interface GetSignedCookie {
-  (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>
-  (c: Context, secret: string): Promise<SignedCookie>
-  (
-    c: Context,
-    secret: string | BufferSource,
-    key: string,
-    prefixOptions: CookiePrefixOptions
-  ): Promise<string | undefined | false>
-}
-
-export const getCookie: GetCookie = (c, key?, prefix?: CookiePrefixOptions) => {
-  const cookie = c.req.raw.headers.get('Cookie')
-  if (typeof key === 'string') {
-    if (!cookie) {
-      return undefined
-    }
-    let finalKey = key
-    if (prefix === 'secure') {
-      finalKey = '__Secure-' + key
-    } else if (prefix === 'host') {
-      finalKey = '__Host-' + key
-    }
-    const obj = parse(cookie, finalKey)
-    return obj[finalKey]
-  }
-  if (!cookie) {
-    return {}
-  }
-  const obj = parse(cookie)
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return obj as any
-}
-
-export const getSignedCookie: GetSignedCookie = async (
-  c,
-  secret,
-  key?,
-  prefix?: CookiePrefixOptions
-) => {
-  const cookie = c.req.raw.headers.get('Cookie')
-  if (typeof key === 'string') {
-    if (!cookie) {
-      return undefined
-    }
-    let finalKey = key
-    if (prefix === 'secure') {
-      finalKey = '__Secure-' + key
-    } else if (prefix === 'host') {
-      finalKey = '__Host-' + key
-    }
-    const obj = await parseSigned(cookie, secret, finalKey)
-    return obj[finalKey]
-  }
-  if (!cookie) {
-    return {}
-  }
-  const obj = await parseSigned(cookie, secret)
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return obj as any
-}
-
-export const setCookie = (c: Context, name: string, value: string, opt?: CookieOptions): void => {
-  // Cookie names prefixed with __Secure- can be used only if they are set with the secure attribute.
-  // Cookie names prefixed with __Host- can be used only if they are set with the secure attribute, must have a path of / (meaning any path at the host)
-  // and must not have a Domain attribute.
-  // Read more at https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes'
-  let cookie
-  if (opt?.prefix === 'secure') {
-    cookie = serialize('__Secure-' + name, value, { path: '/', ...opt, secure: true })
-  } else if (opt?.prefix === 'host') {
-    cookie = serialize('__Host-' + name, value, {
-      ...opt,
-      path: '/',
-      secure: true,
-      domain: undefined,
-    })
-  } else {
-    cookie = serialize(name, value, { path: '/', ...opt })
-  }
-  c.header('set-cookie', cookie, { append: true })
-}
-
-export const setSignedCookie = async (
-  c: Context,
-  name: string,
-  value: string,
-  secret: string | BufferSource,
-  opt?: CookieOptions
-): Promise<void> => {
-  let cookie
-  if (opt?.prefix === 'secure') {
-    cookie = await serializeSigned('__Secure-' + name, value, secret, {
-      path: '/',
-      ...opt,
-      secure: true,
-    })
-  } else if (opt?.prefix === 'host') {
-    cookie = await serializeSigned('__Host-' + name, value, secret, {
-      ...opt,
-      path: '/',
-      secure: true,
-      domain: undefined,
-    })
-  } else {
-    cookie = await serializeSigned(name, value, secret, { path: '/', ...opt })
-  }
-  c.header('set-cookie', cookie, { append: true })
-}
-
-export const deleteCookie = (c: Context, name: string, opt?: CookieOptions): string | undefined => {
-  const deletedCookie = getCookie(c, name)
-  setCookie(c, name, '', { ...opt, maxAge: 0 })
-  return deletedCookie
-}

package/tests/fixtures/corpus/oss-repos/hono/src/helper/css/common.ts

@@ -1,243 +0,0 @@
-// provide utility functions for css helper both on server and client
-export const PSEUDO_GLOBAL_SELECTOR = ':-hono-global'
-export const isPseudoGlobalSelectorRe = new RegExp(`^${PSEUDO_GLOBAL_SELECTOR}{(.*)}$`)
-export const DEFAULT_STYLE_ID = 'hono-css'
-
-export const SELECTOR: unique symbol = Symbol()
-export const CLASS_NAME: unique symbol = Symbol()
-export const STYLE_STRING: unique symbol = Symbol()
-export const SELECTORS: unique symbol = Symbol()
-export const EXTERNAL_CLASS_NAMES: unique symbol = Symbol()
-const CSS_ESCAPED: unique symbol = Symbol()
-
-export interface CssClassName {
-  [SELECTOR]: string
-  [CLASS_NAME]: string
-  [STYLE_STRING]: string
-  [SELECTORS]: CssClassName[]
-  [EXTERNAL_CLASS_NAMES]: string[]
-}
-
-export const IS_CSS_ESCAPED = Symbol()
-
-interface CssEscapedString {
-  [CSS_ESCAPED]: string
-}
-
-/**
- * @experimental
- * `rawCssString` is an experimental feature.
- * The API might be changed.
- */
-export const rawCssString = (value: string): CssEscapedString => {
-  return {
-    [CSS_ESCAPED]: value,
-  }
-}
-
-/**
- * Used the goober'code as a reference:
- * https://github.com/cristianbote/goober/blob/master/src/core/to-hash.js
- * MIT License, Copyright (c) 2019 Cristian Bote
- */
-const toHash = (str: string): string => {
-  let i = 0,
-    out = 11
-  while (i < str.length) {
-    out = (101 * out + str.charCodeAt(i++)) >>> 0
-  }
-  return 'css-' + out
-}
-
-const cssStringReStr: string = [
-  '"(?:(?:\\\\[\\s\\S]|[^"\\\\])*)"', // double quoted string
-  // eslint-disable-next-line quotes
-  "'(?:(?:\\\\[\\s\\S]|[^'\\\\])*)'", // single quoted string
-].join('|')
-const minifyCssRe: RegExp = new RegExp(
-  [
-    '(' + cssStringReStr + ')', // $1: quoted string
-
-    '(?:' +
-      [
-        '^\\s+', // head whitespace
-        '\\/\\*.*?\\*\\/\\s*', // multi-line comment
-        '\\/\\/.*\\n\\s*', // single-line comment
-        '\\s+$', // tail whitespace
-      ].join('|') +
-      ')',
-
-    '\\s*;\\s*(}|$)\\s*', // $2: trailing semicolon
-    '\\s*([{};:,])\\s*', // $3: whitespace around { } : , ;
-    '(\\s)\\s+', // $4: 2+ spaces
-  ].join('|'),
-  'g'
-)
-
-export const minify = (css: string): string => {
-  return css.replace(minifyCssRe, (_, $1, $2, $3, $4) => $1 || $2 || $3 || $4 || '')
-}
-
-type CssVariableBasicType =
-  | CssClassName
-  | CssEscapedString
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-type CssVariableAsyncType = Promise<CssVariableBasicType>
-type CssVariableArrayType = (CssVariableBasicType | CssVariableAsyncType)[]
-export type CssVariableType = CssVariableBasicType | CssVariableAsyncType | CssVariableArrayType
-
-export const buildStyleString = (
-  strings: TemplateStringsArray,
-  values: CssVariableType[]
-): [string, string, CssClassName[], string[]] => {
-  const selectors: CssClassName[] = []
-  const externalClassNames: string[] = []
-
-  const label = strings[0].match(/^\s*\/\*(.*?)\*\//)?.[1] || ''
-  let styleString = ''
-  for (let i = 0, len = strings.length; i < len; i++) {
-    styleString += strings[i]
-    let vArray = values[i]
-    if (typeof vArray === 'boolean' || vArray === null || vArray === undefined) {
-      continue
-    }
-
-    if (!Array.isArray(vArray)) {
-      vArray = [vArray]
-    }
-    for (let j = 0, len = vArray.length; j < len; j++) {
-      let value = vArray[j]
-      if (typeof value === 'boolean' || value === null || value === undefined) {
-        continue
-      }
-      if (typeof value === 'string') {
-        if (/([\\"'\/])/.test(value)) {
-          styleString += value.replace(/([\\"']|(?<=<)\/)/g, '\\$1')
-        } else {
-          styleString += value
-        }
-      } else if (typeof value === 'number') {
-        styleString += value
-      } else if ((value as CssEscapedString)[CSS_ESCAPED]) {
-        styleString += (value as CssEscapedString)[CSS_ESCAPED]
-      } else if ((value as CssClassName)[CLASS_NAME].startsWith('@keyframes ')) {
-        selectors.push(value as CssClassName)
-        styleString += ` ${(value as CssClassName)[CLASS_NAME].substring(11)} `
-      } else {
-        if (strings[i + 1]?.match(/^\s*{/)) {
-          // assume this value is a class name
-          selectors.push(value as CssClassName)
-          value = `.${(value as CssClassName)[CLASS_NAME]}`
-        } else {
-          selectors.push(...(value as CssClassName)[SELECTORS])
-          externalClassNames.push(...(value as CssClassName)[EXTERNAL_CLASS_NAMES])
-          value = (value as CssClassName)[STYLE_STRING]
-          const valueLen = value.length
-          if (valueLen > 0) {
-            const lastChar = value[valueLen - 1]
-            if (lastChar !== ';' && lastChar !== '}') {
-              value += ';'
-            }
-          }
-        }
-        styleString += `${value || ''}`
-      }
-    }
-  }
-
-  return [label, minify(styleString), selectors, externalClassNames]
-}
-
-export const cssCommon = (
-  strings: TemplateStringsArray,
-  values: CssVariableType[]
-): CssClassName => {
-  let [label, thisStyleString, selectors, externalClassNames] = buildStyleString(strings, values)
-  const isPseudoGlobal = isPseudoGlobalSelectorRe.exec(thisStyleString)
-  if (isPseudoGlobal) {
-    thisStyleString = isPseudoGlobal[1]
-  }
-  const selector = (isPseudoGlobal ? PSEUDO_GLOBAL_SELECTOR : '') + toHash(label + thisStyleString)
-  const className = (
-    isPseudoGlobal ? selectors.map((s) => s[CLASS_NAME]) : [selector, ...externalClassNames]
-  ).join(' ')
-
-  return {
-    [SELECTOR]: selector,
-    [CLASS_NAME]: className,
-    [STYLE_STRING]: thisStyleString,
-    [SELECTORS]: selectors,
-    [EXTERNAL_CLASS_NAMES]: externalClassNames,
-  }
-}
-
-export const cxCommon = (
-  args: (string | boolean | null | undefined | CssClassName)[]
-): (string | boolean | null | undefined | CssClassName)[] => {
-  for (let i = 0, len = args.length; i < len; i++) {
-    const arg = args[i]
-    if (typeof arg === 'string') {
-      args[i] = {
-        [SELECTOR]: '',
-        [CLASS_NAME]: '',
-        [STYLE_STRING]: '',
-        [SELECTORS]: [],
-        [EXTERNAL_CLASS_NAMES]: [arg],
-      }
-    }
-  }
-
-  return args
-}
-
-export const keyframesCommon = (
-  strings: TemplateStringsArray,
-  ...values: CssVariableType[]
-): CssClassName => {
-  const [label, styleString] = buildStyleString(strings, values)
-  return {
-    [SELECTOR]: '',
-    [CLASS_NAME]: `@keyframes ${toHash(label + styleString)}`,
-    [STYLE_STRING]: styleString,
-    [SELECTORS]: [],
-    [EXTERNAL_CLASS_NAMES]: [],
-  }
-}
-
-type ViewTransitionType = {
-  (strings: TemplateStringsArray, values: CssVariableType[]): CssClassName
-  (content: CssClassName): CssClassName
-  (): CssClassName
-}
-
-let viewTransitionNameIndex = 0
-export const viewTransitionCommon: ViewTransitionType = ((
-  strings: TemplateStringsArray | CssClassName | undefined,
-  values: CssVariableType[]
-): CssClassName => {
-  if (!strings) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    strings = [`/* h-v-t ${viewTransitionNameIndex++} */`] as any
-  }
-  const content = Array.isArray(strings)
-    ? cssCommon(strings as TemplateStringsArray, values)
-    : (strings as CssClassName)
-
-  const transitionName = content[CLASS_NAME]
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const res = cssCommon(['view-transition-name:', ''] as any, [transitionName])
-
-  content[CLASS_NAME] = PSEUDO_GLOBAL_SELECTOR + content[CLASS_NAME]
-  content[STYLE_STRING] = content[STYLE_STRING].replace(
-    /(?<=::view-transition(?:[a-z-]*)\()(?=\))/g,
-    transitionName
-  )
-  res[CLASS_NAME] = res[SELECTOR] = transitionName
-  res[SELECTORS] = [...content[SELECTORS], content]
-
-  return res
-}) as ViewTransitionType