bluera-knowledge 0.9.21

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

@@ -0,0 +1,388 @@
+import { replaceUrlParam } from '../../client/utils'
+import type { Hono } from '../../hono'
+import type { Env, Schema } from '../../types'
+import { createPool } from '../../utils/concurrent'
+import { getExtension } from '../../utils/mime'
+import type { AddedSSGDataRequest, SSGParams } from './middleware'
+import { SSG_CONTEXT, X_HONO_DISABLE_SSG_HEADER_KEY } from './middleware'
+import { dirname, filterStaticGenerateRoutes, joinPaths } from './utils'
+
+const DEFAULT_CONCURRENCY = 2 // default concurrency for ssg
+
+// 'default_content_type' is designed according to Bun's performance optimization,
+//  which omits Content-Type by default for text responses.
+//  This is based on benchmarks showing performance gains without Content-Type.
+//  In Hono, using `c.text()` without a Content-Type implicitly assumes 'text/plain; charset=UTF-8'.
+//  This approach maintains performance consistency across different environments.
+//  For details, see GitHub issues: oven-sh/bun#8530 and https://github.com/honojs/hono/issues/2284.
+const DEFAULT_CONTENT_TYPE = 'text/plain'
+
+/**
+ * @experimental
+ * `FileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export interface FileSystemModule {
+  writeFile(path: string, data: string | Uint8Array): Promise<void>
+  mkdir(path: string, options: { recursive: boolean }): Promise<void | string>
+}
+
+/**
+ * @experimental
+ * `ToSSGResult` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGResult {
+  success: boolean
+  files: string[]
+  error?: Error
+}
+
+const generateFilePath = (
+  routePath: string,
+  outDir: string,
+  mimeType: string,
+  extensionMap?: Record<string, string>
+): string => {
+  const extension = determineExtension(mimeType, extensionMap)
+
+  if (routePath.endsWith(`.${extension}`)) {
+    return joinPaths(outDir, routePath)
+  }
+
+  if (routePath === '/') {
+    return joinPaths(outDir, `index.${extension}`)
+  }
+  if (routePath.endsWith('/')) {
+    return joinPaths(outDir, routePath, `index.${extension}`)
+  }
+  return joinPaths(outDir, `${routePath}.${extension}`)
+}
+
+const parseResponseContent = async (response: Response): Promise<string | ArrayBuffer> => {
+  const contentType = response.headers.get('Content-Type')
+
+  try {
+    if (contentType?.includes('text') || contentType?.includes('json')) {
+      return await response.text()
+    } else {
+      return await response.arrayBuffer()
+    }
+  } catch (error) {
+    throw new Error(
+      `Error processing response: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}
+
+export const defaultExtensionMap: Record<string, string> = {
+  'text/html': 'html',
+  'text/xml': 'xml',
+  'application/xml': 'xml',
+  'application/yaml': 'yaml',
+}
+
+const determineExtension = (
+  mimeType: string,
+  userExtensionMap?: Record<string, string>
+): string => {
+  const extensionMap = userExtensionMap || defaultExtensionMap
+  if (mimeType in extensionMap) {
+    return extensionMap[mimeType]
+  }
+  return getExtension(mimeType) || 'html'
+}
+
+export type BeforeRequestHook = (req: Request) => Request | false | Promise<Request | false>
+export type AfterResponseHook = (res: Response) => Response | false | Promise<Response | false>
+export type AfterGenerateHook = (result: ToSSGResult) => void | Promise<void>
+
+export const combineBeforeRequestHooks = (
+  hooks: BeforeRequestHook | BeforeRequestHook[]
+): BeforeRequestHook => {
+  if (!Array.isArray(hooks)) {
+    return hooks
+  }
+  return async (req: Request): Promise<Request | false> => {
+    let currentReq = req
+    for (const hook of hooks) {
+      const result = await hook(currentReq)
+      if (result === false) {
+        return false
+      }
+      if (result instanceof Request) {
+        currentReq = result
+      }
+    }
+    return currentReq
+  }
+}
+
+export const combineAfterResponseHooks = (
+  hooks: AfterResponseHook | AfterResponseHook[]
+): AfterResponseHook => {
+  if (!Array.isArray(hooks)) {
+    return hooks
+  }
+  return async (res: Response): Promise<Response | false> => {
+    let currentRes = res
+    for (const hook of hooks) {
+      const result = await hook(currentRes)
+      if (result === false) {
+        return false
+      }
+      if (result instanceof Response) {
+        currentRes = result
+      }
+    }
+    return currentRes
+  }
+}
+
+export const combineAfterGenerateHooks = (
+  hooks: AfterGenerateHook | AfterGenerateHook[]
+): AfterGenerateHook => {
+  if (!Array.isArray(hooks)) {
+    return hooks
+  }
+  return async (result: ToSSGResult): Promise<void> => {
+    for (const hook of hooks) {
+      await hook(result)
+    }
+  }
+}
+
+export interface ToSSGOptions {
+  dir?: string
+  beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[]
+  afterResponseHook?: AfterResponseHook | AfterResponseHook[]
+  afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[]
+  concurrency?: number
+  extensionMap?: Record<string, string>
+}
+
+/**
+ * @experimental
+ * `fetchRoutesContent` is an experimental feature.
+ * The API might be changed.
+ */
+export const fetchRoutesContent = function* <
+  E extends Env = Env,
+  S extends Schema = {},
+  BasePath extends string = '/'
+>(
+  app: Hono<E, S, BasePath>,
+  beforeRequestHook?: BeforeRequestHook,
+  afterResponseHook?: AfterResponseHook,
+  concurrency?: number
+): Generator<
+  Promise<
+    | Generator<
+        Promise<{ routePath: string; mimeType: string; content: string | ArrayBuffer } | undefined>
+      >
+    | undefined
+  >
+> {
+  const baseURL = 'http://localhost'
+  const pool = createPool({ concurrency })
+
+  for (const route of filterStaticGenerateRoutes(app)) {
+    // GET Route Info
+    const thisRouteBaseURL = new URL(route.path, baseURL).toString()
+
+    let forGetInfoURLRequest = new Request(thisRouteBaseURL) as AddedSSGDataRequest
+
+    // eslint-disable-next-line no-async-promise-executor
+    yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
+      try {
+        if (beforeRequestHook) {
+          const maybeRequest = await beforeRequestHook(forGetInfoURLRequest)
+          if (!maybeRequest) {
+            resolveGetInfo(undefined)
+            return
+          }
+          forGetInfoURLRequest = maybeRequest as unknown as AddedSSGDataRequest
+        }
+
+        await pool.run(() => app.fetch(forGetInfoURLRequest))
+
+        if (!forGetInfoURLRequest.ssgParams) {
+          if (isDynamicRoute(route.path)) {
+            resolveGetInfo(undefined)
+            return
+          }
+          forGetInfoURLRequest.ssgParams = [{}]
+        }
+
+        const requestInit = {
+          method: forGetInfoURLRequest.method,
+          headers: forGetInfoURLRequest.headers,
+        }
+
+        resolveGetInfo(
+          (function* () {
+            for (const param of forGetInfoURLRequest.ssgParams as SSGParams) {
+              // eslint-disable-next-line no-async-promise-executor
+              yield new Promise(async (resolveReq, rejectReq) => {
+                try {
+                  const replacedUrlParam = replaceUrlParam(route.path, param)
+                  let response = await pool.run(() =>
+                    app.request(replacedUrlParam, requestInit, {
+                      [SSG_CONTEXT]: true,
+                    })
+                  )
+                  if (response.headers.get(X_HONO_DISABLE_SSG_HEADER_KEY)) {
+                    resolveReq(undefined)
+                    return
+                  }
+                  if (afterResponseHook) {
+                    const maybeResponse = await afterResponseHook(response)
+                    if (!maybeResponse) {
+                      resolveReq(undefined)
+                      return
+                    }
+                    response = maybeResponse
+                  }
+                  const mimeType =
+                    response.headers.get('Content-Type')?.split(';')[0] || DEFAULT_CONTENT_TYPE
+                  const content = await parseResponseContent(response)
+                  resolveReq({
+                    routePath: replacedUrlParam,
+                    mimeType,
+                    content,
+                  })
+                } catch (error) {
+                  rejectReq(error)
+                }
+              })
+            }
+          })()
+        )
+      } catch (error) {
+        rejectGetInfo(error)
+      }
+    })
+  }
+}
+
+const isDynamicRoute = (path: string): boolean => {
+  return path.split('/').some((segment) => segment.startsWith(':') || segment.includes('*'))
+}
+
+/**
+ * @experimental
+ * `saveContentToFile` is an experimental feature.
+ * The API might be changed.
+ */
+const createdDirs: Set<string> = new Set()
+export const saveContentToFile = async (
+  data: Promise<{ routePath: string; content: string | ArrayBuffer; mimeType: string } | undefined>,
+  fsModule: FileSystemModule,
+  outDir: string,
+  extensionMap?: Record<string, string>
+): Promise<string | undefined> => {
+  const awaitedData = await data
+  if (!awaitedData) {
+    return
+  }
+  const { routePath, content, mimeType } = awaitedData
+  const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap)
+  const dirPath = dirname(filePath)
+
+  if (!createdDirs.has(dirPath)) {
+    await fsModule.mkdir(dirPath, { recursive: true })
+    createdDirs.add(dirPath)
+  }
+  if (typeof content === 'string') {
+    await fsModule.writeFile(filePath, content)
+  } else if (content instanceof ArrayBuffer) {
+    await fsModule.writeFile(filePath, new Uint8Array(content))
+  }
+  return filePath
+}
+
+/**
+ * @experimental
+ * `ToSSGInterface` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGInterface {
+  (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    app: Hono<any, any, any>,
+    fsModule: FileSystemModule,
+    options?: ToSSGOptions
+  ): Promise<ToSSGResult>
+}
+
+/**
+ * @experimental
+ * `ToSSGAdaptorInterface` is an experimental feature.
+ * The API might be changed.
+ */
+export interface ToSSGAdaptorInterface<
+  E extends Env = Env,
+  S extends Schema = {},
+  BasePath extends string = '/'
+> {
+  (app: Hono<E, S, BasePath>, options?: ToSSGOptions): Promise<ToSSGResult>
+}
+
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export const toSSG: ToSSGInterface = async (app, fs, options) => {
+  let result: ToSSGResult | undefined
+  const getInfoPromises: Promise<unknown>[] = []
+  const savePromises: Promise<string | undefined>[] = []
+  try {
+    const outputDir = options?.dir ?? './static'
+    const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY
+
+    const combinedBeforeRequestHook = combineBeforeRequestHooks(
+      options?.beforeRequestHook || ((req) => req)
+    )
+    const combinedAfterResponseHook = combineAfterResponseHooks(
+      options?.afterResponseHook || ((req) => req)
+    )
+    const getInfoGen = fetchRoutesContent(
+      app,
+      combinedBeforeRequestHook,
+      combinedAfterResponseHook,
+      concurrency
+    )
+    for (const getInfo of getInfoGen) {
+      getInfoPromises.push(
+        getInfo.then((getContentGen) => {
+          if (!getContentGen) {
+            return
+          }
+          for (const content of getContentGen) {
+            savePromises.push(saveContentToFile(content, fs, outputDir).catch((e) => e))
+          }
+        })
+      )
+    }
+    await Promise.all(getInfoPromises)
+    const files: string[] = []
+    for (const savePromise of savePromises) {
+      const fileOrError = await savePromise
+      if (typeof fileOrError === 'string') {
+        files.push(fileOrError)
+      } else if (fileOrError) {
+        throw fileOrError
+      }
+    }
+    result = { success: true, files }
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error))
+    result = { success: false, files: [], error: errorObj }
+  }
+  if (options?.afterGenerateHook) {
+    const conbinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook)
+    await conbinedAfterGenerateHooks(result)
+  }
+  return result
+}

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

@@ -0,0 +1,71 @@
+import type { Hono } from '../../hono'
+import { METHOD_NAME_ALL } from '../../router'
+import type { Env, RouterRoute } from '../../types'
+import { findTargetHandler, isMiddleware } from '../../utils/handler'
+
+/**
+ * Get dirname
+ * @param path File Path
+ * @returns Parent dir path
+ */
+export const dirname = (path: string): string => {
+  const splittedPath = path.split(/[\/\\]/)
+  return splittedPath.slice(0, -1).join('/') // Windows supports slash path
+}
+
+const normalizePath = (path: string): string => {
+  return path.replace(/(\\)/g, '/').replace(/\/$/g, '')
+}
+
+const handleParent = (resultPaths: string[], beforeParentFlag: boolean): void => {
+  if (resultPaths.length === 0 || beforeParentFlag) {
+    resultPaths.push('..')
+  } else {
+    resultPaths.pop()
+  }
+}
+
+const handleNonDot = (path: string, resultPaths: string[]): void => {
+  path = path.replace(/^\.(?!.)/, '')
+  if (path !== '') {
+    resultPaths.push(path)
+  }
+}
+
+const handleSegments = (paths: string[], resultPaths: string[]): void => {
+  let beforeParentFlag = false
+  for (const path of paths) {
+    // Handle `..`
+    if (path === '..') {
+      handleParent(resultPaths, beforeParentFlag)
+      beforeParentFlag = true
+    } else {
+      // Handle `.` or `abc`
+      handleNonDot(path, resultPaths)
+      beforeParentFlag = false
+    }
+  }
+}
+
+export const joinPaths = (...paths: string[]): string => {
+  paths = paths.map(normalizePath)
+  const resultPaths: string[] = []
+  handleSegments(paths.join('/').split('/'), resultPaths)
+  return (paths[0][0] === '/' ? '/' : '') + resultPaths.join('/')
+}
+
+interface FilterStaticGenerateRouteData {
+  path: string
+}
+
+export const filterStaticGenerateRoutes = <E extends Env>(
+  hono: Hono<E>
+): FilterStaticGenerateRouteData[] => {
+  return hono.routes.reduce((acc, { method, handler, path }: RouterRoute) => {
+    const targetHandler = findTargetHandler(handler)
+    if (['GET', METHOD_NAME_ALL].includes(method) && !isMiddleware(targetHandler)) {
+      acc.push({ path })
+    }
+    return acc
+  }, [] as FilterStaticGenerateRouteData[])
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @module
+ * Streaming Helper for Hono.
+ */
+
+export { stream } from './stream'
+export type { SSEMessage } from './sse'
+export { streamSSE, SSEStreamingApi } from './sse'
+export { streamText } from './text'

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

@@ -0,0 +1,89 @@
+import type { Context } from '../../context'
+import { StreamingApi } from '../../utils/stream'
+import { HtmlEscapedCallbackPhase, resolveCallback } from '../../utils/html'
+
+export interface SSEMessage {
+  data: string | Promise<string>
+  event?: string
+  id?: string
+  retry?: number
+}
+
+export class SSEStreamingApi extends StreamingApi {
+  constructor(writable: WritableStream, readable: ReadableStream) {
+    super(writable, readable)
+  }
+
+  async writeSSE(message: SSEMessage) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {})
+    const dataLines = (data as string)
+      .split('\n')
+      .map((line) => {
+        return `data: ${line}`
+      })
+      .join('\n')
+
+    const sseData =
+      [
+        message.event && `event: ${message.event}`,
+        dataLines,
+        message.id && `id: ${message.id}`,
+        message.retry && `retry: ${message.retry}`,
+      ]
+        .filter(Boolean)
+        .join('\n') + '\n\n'
+
+    await this.write(sseData)
+  }
+}
+
+const run = async (
+  stream: SSEStreamingApi,
+  cb: (stream: SSEStreamingApi) => Promise<void>,
+  onError?: (e: Error, stream: SSEStreamingApi) => Promise<void>
+): Promise<void> => {
+  try {
+    await cb(stream)
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream)
+
+      await stream.writeSSE({
+        event: 'error',
+        data: e.message,
+      })
+    } else {
+      console.error(e)
+    }
+  } finally {
+    stream.close()
+  }
+}
+
+const contextStash: WeakMap<ReadableStream, Context> = new WeakMap<ReadableStream, Context>()
+export const streamSSE = (
+  c: Context,
+  cb: (stream: SSEStreamingApi) => Promise<void>,
+  onError?: (e: Error, stream: SSEStreamingApi) => Promise<void>
+): Response => {
+  const { readable, writable } = new TransformStream()
+  const stream = new SSEStreamingApi(writable, readable)
+
+  // bun does not cancel response stream when request is canceled, so detect abort by signal
+  c.req.raw.signal.addEventListener('abort', () => {
+    if (!stream.closed) {
+      stream.abort()
+    }
+  })
+  // in bun, `c` is destroyed when the request is returned, so hold it until the end of streaming
+  contextStash.set(stream.responseReadable, c)
+
+  c.header('Transfer-Encoding', 'chunked')
+  c.header('Content-Type', 'text/event-stream')
+  c.header('Cache-Control', 'no-cache')
+  c.header('Connection', 'keep-alive')
+
+  run(stream, cb, onError)
+
+  return c.newResponse(stream.responseReadable)
+}

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

@@ -0,0 +1,36 @@
+import type { Context } from '../../context'
+import { StreamingApi } from '../../utils/stream'
+
+const contextStash: WeakMap<ReadableStream, Context> = new WeakMap<ReadableStream, Context>()
+export const stream = (
+  c: Context,
+  cb: (stream: StreamingApi) => Promise<void>,
+  onError?: (e: Error, stream: StreamingApi) => Promise<void>
+): Response => {
+  const { readable, writable } = new TransformStream()
+  const stream = new StreamingApi(writable, readable)
+
+  // bun does not cancel response stream when request is canceled, so detect abort by signal
+  c.req.raw.signal.addEventListener('abort', () => {
+    if (!stream.closed) {
+      stream.abort()
+    }
+  })
+  // in bun, `c` is destroyed when the request is returned, so hold it until the end of streaming
+  contextStash.set(stream.responseReadable, c)
+  ;(async () => {
+    try {
+      await cb(stream)
+    } catch (e) {
+      if (e instanceof Error && onError) {
+        await onError(e, stream)
+      } else {
+        console.error(e)
+      }
+    } finally {
+      stream.close()
+    }
+  })()
+
+  return c.newResponse(stream.responseReadable)
+}

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

@@ -0,0 +1,15 @@
+import type { Context } from '../../context'
+import { TEXT_PLAIN } from '../../context'
+import type { StreamingApi } from '../../utils/stream'
+import { stream } from './'
+
+export const streamText = (
+  c: Context,
+  cb: (stream: StreamingApi) => Promise<void>,
+  onError?: (e: Error, stream: StreamingApi) => Promise<void>
+): Response => {
+  c.header('Content-Type', TEXT_PLAIN)
+  c.header('X-Content-Type-Options', 'nosniff')
+  c.header('Transfer-Encoding', 'chunked')
+  return stream(c, cb, onError)
+}

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

@@ -0,0 +1,26 @@
+/**
+ * @module
+ * Testing Helper for Hono.
+ */
+
+import { hc } from '../../client'
+import type { Client } from '../../client/types'
+import type { ExecutionContext } from '../../context'
+import type { Hono } from '../../hono'
+import type { Schema } from '../../types'
+import type { UnionToIntersection } from '../../utils/types'
+
+type ExtractEnv<T> = T extends Hono<infer E, Schema, string> ? E : never
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const testClient = <T extends Hono<any, Schema, string>>(
+  app: T,
+  Env?: ExtractEnv<T>['Bindings'] | {},
+  executionCtx?: ExecutionContext
+): UnionToIntersection<Client<T>> => {
+  const customFetch = (input: RequestInfo | URL, init?: RequestInit) => {
+    return app.request(input, init, Env, executionCtx)
+  }
+
+  return hc<typeof app>('http://localhost', { fetch: customFetch })
+}

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

@@ -0,0 +1,57 @@
+/**
+ * @module
+ * WebSocket Helper for Hono.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Context } from '../../context'
+import type { MiddlewareHandler } from '../../types'
+
+/**
+ * WebSocket Event Listeners type
+ */
+export interface WSEvents<T = unknown> {
+  onOpen?: (evt: Event, ws: WSContext<T>) => void
+  onMessage?: (evt: MessageEvent<WSMessageReceive>, ws: WSContext<T>) => void
+  onClose?: (evt: CloseEvent, ws: WSContext<T>) => void
+  onError?: (evt: Event, ws: WSContext<T>) => void
+}
+
+/**
+ * Upgrade WebSocket Type
+ */
+export type UpgradeWebSocket<T = unknown, U = any> = (
+  createEvents: (c: Context) => WSEvents<T> | Promise<WSEvents<T>>,
+  options?: U
+) => MiddlewareHandler<
+  any,
+  string,
+  {
+    outputFormat: 'ws'
+  }
+>
+
+export type WSReadyState = 0 | 1 | 2 | 3
+
+export type WSContext<T = unknown> = {
+  send(
+    source: string | ArrayBuffer | Uint8Array,
+    options?: {
+      compress: boolean
+    }
+  ): void
+  raw?: T
+  binaryType: BinaryType
+  readyState: WSReadyState
+  url: URL | null
+  protocol: string | null
+  close(code?: number, reason?: string): void
+}
+
+export type WSMessageReceive = string | Blob | ArrayBufferLike
+
+export const createWSMessageEvent = (source: WSMessageReceive): MessageEvent<WSMessageReceive> => {
+  return new MessageEvent<WSMessageReceive>('message', {
+    data: source,
+  })
+}