bluera-knowledge 0.14.0 → 0.14.2

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

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

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

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

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

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

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

@@ -1,159 +0,0 @@
-/**
- * @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()
-  }
-}