bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/hono/src/jsx/jsx-dev-runtime.ts

@@ -0,0 +1,26 @@
+/**
+ * @module
+ * This module provides Hono's JSX dev runtime.
+ */
+
+import type { HtmlEscapedString } from '../utils/html'
+import { jsxFn } from './base'
+import type { JSXNode } from './base'
+export { Fragment } from './base'
+export type { JSX } from './base'
+
+export function jsxDEV(
+  tag: string | Function,
+  props: Record<string, unknown>,
+  key?: string
+): JSXNode {
+  let node: JSXNode
+  if (!props || !('children' in props)) {
+    node = jsxFn(tag, props, [])
+  } else {
+    const children = props.children as string | HtmlEscapedString
+    node = Array.isArray(children) ? jsxFn(tag, props, children) : jsxFn(tag, props, [children])
+  }
+  node.key = key
+  return node
+}

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

@@ -0,0 +1,18 @@
+/**
+ * @module
+ * This module provides Hono's JSX runtime.
+ */
+
+export { jsxDEV as jsx, Fragment } from './jsx-dev-runtime'
+export { jsxDEV as jsxs } from './jsx-dev-runtime'
+export type { JSX } from './jsx-dev-runtime'
+
+import { html, raw } from '../helper/html'
+import type { HtmlEscapedString } from '../utils/html'
+export { html as jsxTemplate }
+export const jsxAttr = (
+  name: string,
+  value: string | Promise<string>
+): HtmlEscapedString | Promise<HtmlEscapedString> =>
+  typeof value === 'string' ? raw(name + '="' + html`${value}` + '"') : html`${name}="${value}"`
+export const jsxEscape = (value: string) => value

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

@@ -0,0 +1,184 @@
+/**
+ * @module
+ * This module enables JSX to supports streaming Response.
+ */
+
+import { raw } from '../helper/html'
+import { HtmlEscapedCallbackPhase, resolveCallback } from '../utils/html'
+import type { HtmlEscapedString } from '../utils/html'
+import { childrenToString } from './components'
+import { DOM_RENDERER, DOM_STASH } from './constants'
+import { Suspense as SuspenseDomRenderer } from './dom/components'
+import { buildDataStack } from './dom/render'
+import type { HasRenderToDom, NodeObject } from './dom/render'
+import type { Child, FC, PropsWithChildren } from './'
+
+let suspenseCounter = 0
+
+/**
+ * @experimental
+ * `Suspense` is an experimental feature.
+ * The API might be changed.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const Suspense: FC<PropsWithChildren<{ fallback: any }>> = async ({
+  children,
+  fallback,
+}) => {
+  if (!children) {
+    return fallback.toString()
+  }
+  if (!Array.isArray(children)) {
+    children = [children]
+  }
+
+  let resArray: HtmlEscapedString[] | Promise<HtmlEscapedString[]>[] = []
+
+  // for use() hook
+  const stackNode = { [DOM_STASH]: [0, []] } as unknown as NodeObject
+  const popNodeStack = (value?: unknown) => {
+    buildDataStack.pop()
+    return value
+  }
+
+  try {
+    stackNode[DOM_STASH][0] = 0
+    buildDataStack.push([[], stackNode])
+    resArray = children.map((c) =>
+      c == null || typeof c === 'boolean' ? '' : c.toString()
+    ) as HtmlEscapedString[]
+  } catch (e) {
+    if (e instanceof Promise) {
+      resArray = [
+        e.then(() => {
+          stackNode[DOM_STASH][0] = 0
+          buildDataStack.push([[], stackNode])
+          return childrenToString(children as Child[]).then(popNodeStack)
+        }),
+      ] as Promise<HtmlEscapedString[]>[]
+    } else {
+      throw e
+    }
+  } finally {
+    popNodeStack()
+  }
+
+  if (resArray.some((res) => (res as {}) instanceof Promise)) {
+    const index = suspenseCounter++
+    const fallbackStr = await fallback.toString()
+    return raw(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [
+      ...(fallbackStr.callbacks || []),
+      ({ phase, buffer, context }) => {
+        if (phase === HtmlEscapedCallbackPhase.BeforeStream) {
+          return
+        }
+        return Promise.all(resArray).then(async (htmlArray) => {
+          htmlArray = htmlArray.flat()
+          const content = htmlArray.join('')
+          if (buffer) {
+            buffer[0] = buffer[0].replace(
+              new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`),
+              content
+            )
+          }
+          let html = buffer
+            ? ''
+            : `<template data-hono-target="H:${index}">${content}</template><script>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('H:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
+d.replaceWith(c.content)
+})(document)
+</script>`
+
+          const callbacks = htmlArray
+            .map((html) => (html as HtmlEscapedString).callbacks || [])
+            .flat()
+          if (!callbacks.length) {
+            return html
+          }
+
+          if (phase === HtmlEscapedCallbackPhase.Stream) {
+            html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context)
+          }
+
+          return raw(html, callbacks)
+        })
+      },
+    ])
+  } else {
+    return raw(resArray.join(''))
+  }
+}
+;(Suspense as HasRenderToDom)[DOM_RENDERER] = SuspenseDomRenderer
+
+const textEncoder = new TextEncoder()
+/**
+ * @experimental
+ * `renderToReadableStream()` is an experimental feature.
+ * The API might be changed.
+ */
+export const renderToReadableStream = (
+  str: HtmlEscapedString | Promise<HtmlEscapedString>,
+  onError: (e: unknown) => string | void = console.trace
+): ReadableStream<Uint8Array> => {
+  const reader = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      try {
+        const tmp = str instanceof Promise ? await str : await str.toString()
+        const context = typeof tmp === 'object' ? tmp : {}
+        const resolved = await resolveCallback(
+          tmp,
+          HtmlEscapedCallbackPhase.BeforeStream,
+          true,
+          context
+        )
+        controller.enqueue(textEncoder.encode(resolved))
+
+        let resolvedCount = 0
+        const callbacks: Promise<void>[] = []
+        const then = (promise: Promise<string>) => {
+          callbacks.push(
+            promise
+              .catch((err) => {
+                console.log(err)
+                onError(err)
+                return ''
+              })
+              .then(async (res) => {
+                res = await resolveCallback(
+                  res,
+                  HtmlEscapedCallbackPhase.BeforeStream,
+                  true,
+                  context
+                )
+                ;(res as HtmlEscapedString).callbacks
+                  ?.map((c) => c({ phase: HtmlEscapedCallbackPhase.Stream, context }))
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  .filter<Promise<string>>(Boolean as any)
+                  .forEach(then)
+                resolvedCount++
+                controller.enqueue(textEncoder.encode(res))
+              })
+          )
+        }
+        ;(resolved as HtmlEscapedString).callbacks
+          ?.map((c) => c({ phase: HtmlEscapedCallbackPhase.Stream, context }))
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          .filter<Promise<string>>(Boolean as any)
+          .forEach(then)
+        while (resolvedCount !== callbacks.length) {
+          await Promise.all(callbacks)
+        }
+      } catch (e) {
+        // maybe the connection was closed
+        onError(e)
+      }
+
+      controller.close()
+    },
+  })
+  return reader
+}

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

@@ -0,0 +1,41 @@
+/**
+ * All types exported from "hono/jsx" are in this file.
+ */
+import type { Child, JSXNode } from './base'
+import type { JSX } from './intrinsic-elements'
+
+export type { Child, JSXNode, FC } from './base'
+export type { RefObject } from './hooks'
+export type { Context } from './context'
+
+export type PropsWithChildren<P = unknown> = P & { children?: Child | undefined }
+export type CSSProperties = JSX.CSSProperties
+
+/**
+ * React types
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type ReactElement<P = any, T = string | Function> = JSXNode & {
+  type: T
+  props: P
+  key: string | null
+}
+type ReactNode = ReactElement | string | number | boolean | null | undefined
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type ComponentClass<P = {}, S = {}> = unknown
+
+export type { ReactElement, ReactNode, ComponentClass }
+
+export type Event = globalThis.Event
+export type MouseEvent = globalThis.MouseEvent
+export type KeyboardEvent = globalThis.KeyboardEvent
+export type FocusEvent = globalThis.FocusEvent
+export type ClipboardEvent = globalThis.ClipboardEvent
+export type InputEvent = globalThis.InputEvent
+export type PointerEvent = globalThis.PointerEvent
+export type TouchEvent = globalThis.TouchEvent
+export type WheelEvent = globalThis.WheelEvent
+export type AnimationEvent = globalThis.AnimationEvent
+export type TransitionEvent = globalThis.TransitionEvent
+export type DragEvent = globalThis.DragEvent

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

@@ -0,0 +1,36 @@
+const normalizeElementKeyMap: Map<string, string> = new Map([
+  ['className', 'class'],
+  ['htmlFor', 'for'],
+  ['crossOrigin', 'crossorigin'],
+  ['httpEquiv', 'http-equiv'],
+  ['itemProp', 'itemprop'],
+  ['fetchPriority', 'fetchpriority'],
+  ['noModule', 'nomodule'],
+  ['formAction', 'formaction'],
+])
+export const normalizeIntrinsicElementKey = (key: string): string =>
+  normalizeElementKeyMap.get(key) || key
+
+export const styleObjectForEach = (
+  style: Record<string, string | number>,
+  fn: (key: string, value: string | null) => void
+): void => {
+  for (const [k, v] of Object.entries(style)) {
+    const key =
+      k[0] === '-' || !/[A-Z]/.test(k)
+        ? k // a CSS variable or a lowercase only property
+        : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`) // a camelCase property. convert to kebab-case
+    fn(
+      key,
+      v == null
+        ? null
+        : typeof v === 'number'
+        ? !key.match(
+            /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
+          )
+          ? `${v}px`
+          : `${v}`
+        : v
+    )
+  }
+}

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

@@ -0,0 +1,128 @@
+/**
+ * @module
+ * Basic Auth Middleware for Hono.
+ */
+
+import type { Context } from '../../context'
+import { HTTPException } from '../../http-exception'
+import type { MiddlewareHandler } from '../../types'
+import { auth } from '../../utils/basic-auth'
+import { timingSafeEqual } from '../../utils/buffer'
+
+type MessageFunction = (c: Context) => string | object | Promise<string | object>
+
+type BasicAuthOptions =
+  | {
+      username: string
+      password: string
+      realm?: string
+      hashFunction?: Function
+      invalidUserMessage?: string | object | MessageFunction
+    }
+  | {
+      verifyUser: (username: string, password: string, c: Context) => boolean | Promise<boolean>
+      realm?: string
+      hashFunction?: Function
+      invalidUserMessage?: string | object | MessageFunction
+    }
+
+/**
+ * Basic Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/basic-auth}
+ *
+ * @param {BasicAuthOptions} options - The options for the basic authentication middleware.
+ * @param {string} options.username - The username for authentication.
+ * @param {string} options.password - The password for authentication.
+ * @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
+ * @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+ * @param {Function} [options.verifyUser] - The function to verify user credentials.
+ * @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {HTTPException} If neither "username and password" nor "verifyUser" options are provided.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(
+ *   '/auth/*',
+ *   basicAuth({
+ *     username: 'hono',
+ *     password: 'acoolproject',
+ *   })
+ * )
+ *
+ * app.get('/auth/page', (c) => {
+ *   return c.text('You are authorized')
+ * })
+ * ```
+ */
+export const basicAuth = (
+  options: BasicAuthOptions,
+  ...users: { username: string; password: string }[]
+): MiddlewareHandler => {
+  const usernamePasswordInOptions = 'username' in options && 'password' in options
+  const verifyUserInOptions = 'verifyUser' in options
+
+  if (!(usernamePasswordInOptions || verifyUserInOptions)) {
+    throw new Error(
+      'basic auth middleware requires options for "username and password" or "verifyUser"'
+    )
+  }
+
+  if (!options.realm) {
+    options.realm = 'Secure Area'
+  }
+
+  if (!options.invalidUserMessage) {
+    options.invalidUserMessage = 'Unauthorized'
+  }
+
+  if (usernamePasswordInOptions) {
+    users.unshift({ username: options.username, password: options.password })
+  }
+
+  return async function basicAuth(ctx, next) {
+    const requestUser = auth(ctx.req.raw)
+    if (requestUser) {
+      if (verifyUserInOptions) {
+        if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
+          await next()
+          return
+        }
+      } else {
+        for (const user of users) {
+          const [usernameEqual, passwordEqual] = await Promise.all([
+            timingSafeEqual(user.username, requestUser.username, options.hashFunction),
+            timingSafeEqual(user.password, requestUser.password, options.hashFunction),
+          ])
+          if (usernameEqual && passwordEqual) {
+            await next()
+            return
+          }
+        }
+      }
+    }
+    // Invalid user.
+    const status = 401
+    const headers = {
+      'WWW-Authenticate': 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"',
+    }
+    const responseMessage =
+      typeof options.invalidUserMessage === 'function'
+        ? await options.invalidUserMessage(ctx)
+        : options.invalidUserMessage
+    const res =
+      typeof responseMessage === 'string'
+        ? new Response(responseMessage, { status, headers })
+        : new Response(JSON.stringify(responseMessage), {
+            status,
+            headers: {
+              ...headers,
+              'content-type': 'application/json; charset=UTF-8',
+            },
+          })
+    throw new HTTPException(status, { res })
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/middleware/bearer-auth/index.ts

@@ -0,0 +1,159 @@
+/**
+ * @module
+ * Bearer Auth Middleware for Hono.
+ */
+
+import type { Context } from '../../context'
+import { HTTPException } from '../../http-exception'
+import type { MiddlewareHandler } from '../../types'
+import { timingSafeEqual } from '../../utils/buffer'
+import type { StatusCode } from '../../utils/http-status'
+
+const TOKEN_STRINGS = '[A-Za-z0-9._~+/-]+=*'
+const PREFIX = 'Bearer'
+const HEADER = 'Authorization'
+
+type MessageFunction = (c: Context) => string | object | Promise<string | object>
+
+type BearerAuthOptions =
+  | {
+      token: string | string[]
+      realm?: string
+      prefix?: string
+      headerName?: string
+      hashFunction?: Function
+      noAuthenticationHeaderMessage?: string | object | MessageFunction
+      invalidAuthenticationHeaderMessage?: string | object | MessageFunction
+      invalidTokenMessage?: string | object | MessageFunction
+    }
+  | {
+      realm?: string
+      prefix?: string
+      headerName?: string
+      verifyToken: (token: string, c: Context) => boolean | Promise<boolean>
+      hashFunction?: Function
+      noAuthenticationHeaderMessage?: string | object | MessageFunction
+      invalidAuthenticationHeaderMessage?: string | object | MessageFunction
+      invalidTokenMessage?: string | object | MessageFunction
+    }
+
+/**
+ * Bearer Auth Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/bearer-auth}
+ *
+ * @param {BearerAuthOptions} options - The options for the bearer authentication middleware.
+ * @param {string | string[]} [options.token] - The string or array of strings to validate the incoming bearer token against.
+ * @param {Function} [options.verifyToken] - The function to verify the token.
+ * @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
+ * @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
+ * @param {string} [options.headerName=Authorization] - The header name.
+ * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
+ * @param {string | object | MessageFunction} [options.noAuthenticationHeaderMessage="Unauthorized"] - The no authentication header message.
+ * @param {string | object | MessageFunction} [options.invalidAuthenticationHeaderMeasage="Bad Request"] - The invalid authentication header message.
+ * @param {string | object | MessageFunction} [options.invalidTokenMessage="Unauthorized"] - The invalid token message.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {Error} If neither "token" nor "verifyToken" options are provided.
+ * @throws {HTTPException} If authentication fails, with 401 status code for missing or invalid token, or 400 status code for invalid request.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * const token = 'honoiscool'
+ *
+ * app.use('/api/*', bearerAuth({ token }))
+ *
+ * app.get('/api/page', (c) => {
+ *   return c.json({ message: 'You are authorized' })
+ * })
+ * ```
+ */
+export const bearerAuth = (options: BearerAuthOptions): MiddlewareHandler => {
+  if (!('token' in options || 'verifyToken' in options)) {
+    throw new Error('bearer auth middleware requires options for "token"')
+  }
+  if (!options.realm) {
+    options.realm = ''
+  }
+  if (options.prefix === undefined) {
+    options.prefix = PREFIX
+  }
+
+  const realm = options.realm?.replace(/"/g, '\\"')
+  const prefixRegexStr = options.prefix === '' ? '' : `${options.prefix} +`
+  const regexp = new RegExp(`^${prefixRegexStr}(${TOKEN_STRINGS}) *$`)
+  const wwwAuthenticatePrefix = options.prefix === '' ? '' : `${options.prefix} `
+
+  const throwHTTPException = async (
+    c: Context,
+    status: StatusCode,
+    wwwAuthenticateHeader: string,
+    messageOption: string | object | MessageFunction
+  ): Promise<Response> => {
+    const headers = {
+      'WWW-Authenticate': wwwAuthenticateHeader,
+    }
+    const responseMessage =
+      typeof messageOption === 'function' ? await messageOption(c) : messageOption
+    const res =
+      typeof responseMessage === 'string'
+        ? new Response(responseMessage, { status, headers })
+        : new Response(JSON.stringify(responseMessage), {
+            status,
+            headers: {
+              ...headers,
+              'content-type': 'application/json; charset=UTF-8',
+            },
+          })
+    throw new HTTPException(status, { res })
+  }
+
+  return async function bearerAuth(c, next) {
+    const headerToken = c.req.header(options.headerName || HEADER)
+    if (!headerToken) {
+      // No Authorization header
+      await throwHTTPException(
+        c,
+        401,
+        `${wwwAuthenticatePrefix}realm="${realm}"`,
+        options.noAuthenticationHeaderMessage || 'Unauthorized'
+      )
+    } else {
+      const match = regexp.exec(headerToken)
+      if (!match) {
+        // Invalid Request
+        await throwHTTPException(
+          c,
+          400,
+          `${wwwAuthenticatePrefix}error="invalid_request"`,
+          options.invalidAuthenticationHeaderMessage || 'Bad Request'
+        )
+      } else {
+        let equal = false
+        if ('verifyToken' in options) {
+          equal = await options.verifyToken(match[1], c)
+        } else if (typeof options.token === 'string') {
+          equal = await timingSafeEqual(options.token, match[1], options.hashFunction)
+        } else if (Array.isArray(options.token) && options.token.length > 0) {
+          for (const token of options.token) {
+            if (await timingSafeEqual(token, match[1], options.hashFunction)) {
+              equal = true
+              break
+            }
+          }
+        }
+        if (!equal) {
+          // Invalid Token
+          await throwHTTPException(
+            c,
+            401,
+            `${wwwAuthenticatePrefix}error="invalid_token"`,
+            options.invalidTokenMessage || 'Unauthorized'
+          )
+        }
+      }
+    }
+    await next()
+  }
+}