bluera-knowledge 0.9.21

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

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

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

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

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

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

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

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

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