bluera-knowledge 0.14.0 → 0.14.1

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

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

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

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

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

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

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

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

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